web-dev-qa-db-fra.com

Changer un tableau avec une fonction en C?

Je veux appeler une fonction et je veux que cette fonction change le contenu d'une chaîne ou d'un tableau dans le programme en une constante.

Psuedocode:

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

Je sais que je dois passer le pointeur vers cette fonction. Voici ce que j'ai écrit,

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;
}

Comment puis-je faire ceci?

carraysfunctionpointers
15
Alex

Vous passez le pointeur vers le tableau par valeur plutôt que par référence. Ça devrait être:

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;
}

Vous avez donné l'adresse de "bonjour" à la fonction changeArray, mais dans la fonction vous avez modifié la valeur transmise, pas le pointeur d'origine. Le changement que j'ai effectué passe l'adresse du pointeur et le pointeur lui-même est modifié dans la fonction.

S'il vous plaît, char *blah = "hello"; Ne définit pas un pointeur vers une chaîne constante, ainsi que *arr = "bingo";, C'est très bien, mais si vous envisagez de changer la chaîne elle-même, vous ne pourrez pas le faire.

MODIFIER:

Lorsque vous passez un argument, même un pointeur, à une fonction, vous le copiez en fait à un endroit où la fonction l'a lu à partir de là (généralement la pile). Vous ne transmettez pas l'argument lui-même, mais une copie de celui-ci. Lorsque la fonction le modifie (comme dans arr = "bingo";), Elle modifie la copie de la variable, pas la variable d'origine. Donc, pour changer la variable elle-même, nous passons l'adresse de la variable à la fonction (changeArray(&blah); - le & Signifie address of-) Et dans la fonction nous modifions le variable stockée dans l'adresse que nous avons passée (*arr = "bingo"; - le * signifie la variable dans l'adresse arr).

En supposant que le pointeur blah d'origine se trouve dans l'adresse 0x00000000 et contient l'adresse de la chaîne "hello" Qui est par exemple 0x00000010. si vous passez blah à la fonction, vous la copiez dans une nouvelle variable, arr, qui se trouve par exemple à l'adresse 0x00000020

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...)

maintenant, si vous modifiez le contenu de arr, vous modifiez la valeur de l'adresse 0x00000020, mais pas la valeur de l'adresse 0x000000000, donc blah contient toujours 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...)

Au lieu de cela, nous copions l'adresse de blah, qui est 0x00000000, dans arr et dans la fonction nous disons - "le conten de arr est un - adresse, allez à cette adresse et changez son contenu pour qu'il pointe vers "bingo" string ". alors maintenant le contenu de l'adresse 0x00000000 (qui est blah) pointe vers "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...)

J'espère que je ne vous ai pas confondu ...

32
MByD

Il n'y a pas de tableaux dans votre code. Si vous essayez réellement de modifier ce vers quoi pointe votre pointeur de caractère blah, vous devez passer un pointeur vers un pointeur dans la fonction. Cependant, si vous voulez faire cela en utilisant des tableaux, vous devez faire quelque chose comme:

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. i.e. 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;
}
7
Ferruccio

Vous devez passer un pointeur vers le tableau et non vers le tableau lui-même.

Autre chose: ajoutez une condition de contrôle à votre fonction. pensez: que se passera-t-il si "bingo" sera plus grand que strlen (some_array)? cela vous donnera une erreur car en C vous devez le mallocer si vous avez besoin que la taille du tableau soit dynamique!

0
Batman