¿Cambiar una matriz con una función en C?

Quiero llamar a una función y quiero que esa función cambie el contenido de una cadena o matriz en el progtwig a una constante.

Psuedocode:

some_array = "hello" print some_array #prints "hello" changeArray(some_array) print some_array #prints "bingo" 

Sé que tengo que pasar el puntero a esa función. Esto es lo que escribí,

 void changeArray(char *arr){ arr = "bingo"; } int main(int argc, const char* argv[]){ char *blah = "hello"; printf("Array is %s\n",blah); changeArray(blah); printf("Array is %s\n",blah); return EXIT_SUCCESS; } 

¿Cómo puedo hacer esto?

Usted está pasando el puntero a la matriz por valor en lugar de por referencia. Debería ser:

 void changeArray(char **arr){ *arr = "bingo"; } int main(int argc, const char* argv[]){ char *blah = "hello"; printf("Array is %s\n",blah); changeArray(&blah); printf("Array is %s\n",blah); return EXIT_SUCCESS; } 

Le dio la dirección de “hello” a la función changeArray , pero en la función cambió el valor pasado, no el puntero original. El cambio que realicé pasa la dirección del puntero y el puntero se cambia en la función.

Por favor, no char *blah = "hello"; define un puntero a una cadena constante, así como *arr = "bingo"; , esto está bien, pero si considera cambiar la cadena en sí, no podrá hacerlo.

EDITAR:

Cuando pasa un argumento, incluso un puntero, a una función, en realidad lo copia en un lugar donde la función lo lee desde allí (generalmente la stack). Usted no pasa el argumento en sí, sino una copia de él. Cuando la función la modifica (como en arr = "bingo"; ) modifica la copia de la variable, no la variable original. Entonces, para cambiar la variable, pasamos la dirección de la variable a la función ( changeArray(&blah); – la address of- medios de & ) y en la función modificamos la variable almacenada en la dirección que pasamos ( *arr = "bingo"; – el * significa la variable en la dirección arr ).

Suponiendo que el puntero blah original se encuentra en la dirección 0x00000000 y contiene la dirección de la cadena de "hello" que es, por ejemplo, 0x00000010. si pasa blah a la función, cópielo a una nueva variable, arr , que se encuentra en la dirección 0x00000020 por ejemplo

 Variable Address content ------------------------------- blah 00000000 00000010 (points to hello) "hello" 00000010 "hello" (this is just an example, so don't be hard on me :) ) arr 00000020 00000010 "bingo" 00000030 "bingo" (and again...) 

ahora, si cambia el contenido de arr , cambia el valor en la dirección 0x00000020, pero no el valor en la dirección 0x000000000, por lo que blah aún contiene 00000010.

 Variable Address content ------------------------------- blah 00000000 00000010 (points to hello) "hello" 00000010 "hello" (this is just an example, so don't be hard on me :) ) arr 00000020 00000030 (points to "bingo") "bingo" 00000030 "bingo" (and again...) 

En su lugar, lo que hacemos es copiar la dirección de blah , que es 0x00000000, para arr y en la función que decimos: “el contenido de arr es una dirección , vaya a esta dirección y cambie su contenido para que apunte a” cadena de bingo “. así que ahora el contenido en la dirección 0x00000000 (que es blah ) apunta a “bingo”.

 Variable Address content ------------------------------- blah 00000000 00000030 (points to "bingo") "hello" 00000010 "hello" (this is just an example, so don't be hard on me :) ) arr 00000020 00000000 (points to `blah`) "bingo" 00000030 "bingo" (and again...) 

Espero no haberte confundido …

No hay matrices en su código. Si en realidad estás intentando modificar a qué apuntan los punteros de tu blah carácter, debes pasar un puntero a un puntero a la función. Sin embargo, si desea hacer esto utilizando matrices, necesita hacer algo como:

 void changeArray(char arr[]) { // or you can use char *arr, it's the same thing from // the C compiler's point of view strcpy(arr, "blah"); // alternatively, you could set each element. ie arr[0] = 'b'; } int main (int argc, char** argv) { char blah[100] = "hello"; // this is an array printf("Array is %s\n", blah); changeArray(blah); // array decays to pointer printf("Array is %s\n", blah); return EXIT_SUCCESS; } 

Debe pasar un puntero a la matriz, no a la propia matriz.

Otra cosa: agrega una condición de control a tu función. piensa: ¿qué pasará si “bingo” será más grande que strlen (some_array)? le dará un error porque en C debe malloc it si necesita que el tamaño del arreglo sea dynamic!