array bidimensional fincion

[slcna]

Tengo una duda, se puede devolver un array bidimencional mediante referencia
me entere que por return no se puede.
E estado intentado y buscando pero no e encontrado nada

Código C:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <conio.h>
 
//-- recibe dos parametros una cadena y un array bidimensional de cadenas
void pal(char * palabra,char * bidi){
    strcpy(palabra, "hola");
    
        // en la posicion 0 y 1 de arrar intento introducir un texto
    strcpy(bidi[0], "hola");
    strcpy(bidi[1], "Adios");
    
//return bidi;
}
 
//-- MAIN -----------------------------------------------------------------------------
int main(int argc, char *argv[]) {
    printf("\n Biblioteca");
    printf("\n--------------------------------\n");
 
    //- creo las variables
    char palabra[100];
    char bidi[2][50] = {""};
        
    //- llamo a la funcion
    pal(palabra, bidi);
        
    // y muestro el valor de las variables.
    printf(" %s\n", bidi[0]);
    printf(" %s\n", bidi[1]);
    printf(" %s\n", palabra);
    
return 0;}
 

C me esta haciendo un lio

[eferion]

En C hay que tener cuidado con estas cosas. Los arrays se pueden almacenar de varias formas en C.

Código C:

// Array definido en la pila
char array1[10];
 
// En este caso array2 es un puntero y apunta a una región de memoria (que puede ser de solo lectura) donde se encuentra la cadena
char *array2 = "una prueba";
 
// Array bidimensional definido en la pila.
// Nota que para acceder a un char tienes que usar dos valores
char bidi1[2][10];
 
// Puntero a array bidimensional
// Los dos punteros indican precisamente eso, que hacen falta dos saltos
// para encontrar un char.
char **bidi2;
 

Por otro lado, los arrays bidimensionales definidos en la pila tienen una estructura plana, quiero decir, los elementos del array se encuentran en posiciones sucesivas de la pila. En el caso de bidi[2][10], primero están los diez bytes del primer elemento y después los diez bytes del segundo elemento.

Sin embargo un array bidimensional en memoria dinámica ya no se almacena (o no tiene por que almacenarse) de forma secuencial en la memoria.

Para explicar lo siguiente vamos a asumir un array bidimensional tal que bidi[filas][columnas]. Nota, en el caso de los arrays bidimensionales en la pila, que para acceder a bidi[1] el compilador necesita saber cuántos elementos tiene cada fila. Este dato es bastante importante para entender la siguiente línea:

Código C:

// El tamaño de las columnas ha de ser fijo en el caso de arrays en la pila
void pal(char * palabra,char[][10]  bidi){
 

Esto permite que el compilador sepa lo que le vas a pasar a la función de cara a poder almacenar las cosas correctamente. Es engorroso y menos usable que en el caso de arrays en la memoria dinámica (porque esta función no dará resultados buenos si le intentas pasar un array tal que bidi2[2][5])... pero es como hay que usarlo.

Un saludo.