Passer un tableau par référence en C

Je suis novice en C et j'ai un doute.

Depuis les fonctions C créer des copies de ses arguments, je me demandais pourquoi le code suivant fonctionne comme prévu:

void function(int array[]){

    array[0] = 4;
    array[1] = 5;
    array[2] = 6;   
}

int main(){

    int array[] = {1,2,3};

    function(array);

    printf("%d %d %d",array[0],array[1],array[2]);

    return 0;
}

Avec la ligne de la sortie d'4 5 6.

Pourquoi ce travail tandis que le suivant ne l'est pas?

void function(int integer){

    integer = 2;
}

int main(){

    int integer = 1;

    function(integer);

    printf("%d",integer);

    return 0;
}

La sortie est à 1 dans ce cas.

Version courte: Pourquoi les fonctions de modifier les valeurs de leurs variables parents si elles sont transmises sous forme de tableau?

Merci à vous tous!

source d'informationauteur Costagero

arrays c function reference

Ceci est causé par le fait que les tableaux ont tendance à se désintégrer en pointeurs.

int a[] = { 1, 2, 3 };
int* p = a; //valid: p is now the address of a[0]
a = p;  //NOT valid.

printf("a = %p\n", a);
printf("p = %p\n", p); //prints same address as a

a et p impression sera la même valeur.

Contrairement à ce que d'autres ont dit, a est pas un pointeur, il suffit de se désintègrent en un. http://c-faq.com/aryptr/aryptrequiv.html

Dans votre premier function() ce qui est passé est l'adresse du premier élément du tableau, et le corps de la fonction déréférence. En effet, le compilateur est le traitement le prototype de fonction comme ceci:

void function(int* array /*you wrote int array[]*/){
    array[0] = 4;
    array[1] = 5;
    array[2] = 6;   
}

function(&array[0]);

Ce qui doit arriver parce que vous avez dit "tableau de taille inconnue" (int tableau[]). Le compilateur ne peut pas garantir à déduire le montant de la pile requis pour passer par valeur, de sorte qu'il se désintègre à un pointeur.

---- Edit ----

Permet de combiner à la fois des exemples et des noms distinctifs de rendre les choses plus claires.

#include <stdio.h>

void func1(int dynArray[]) {
    printf("func1: dynArray = %p, &dynArray[0] = %p, dynArray[0] = %d\n",
             dynArray, &dynArray[0], dynArray[0]);
}

void func2(int* intPtr) {
    printf("func2: intPtr = %p, &intPtr[0] = %p, intPtr[0] = %d\n",
             intPtr, &intPtr[0], intPtr[0]);
}

void func3(int intVal) {
    printf("func3: intVal = %d, &intValue = %p\n",
             intVal, &intVal);
}

int main() {
    int mainArray[3] = { 1, 2, 3 };
    int mainInt = 10;

    printf("mainArray = %p, &mainArray[0] = %p, mainArray[0] = %d\n",
             mainArray, &mainArray, mainArray[0]);
    func1(mainArray);
    func2(mainArray);

    printf("mainInt = %d, &mainInt = %p\n",
             mainInt, &mainInt);
    func3(mainInt);

    return 0;
}

Démo en Live à ideone: http://ideone.com/P8C1f4

mainArray = 0xbf806ad4, &mainArray[0] = 0xbf806ad4, mainArray[0] = 1
func1: dynArray = 0xbf806ad4, &dynArray[0] = 0xbf806ad4, dynArray[0] = 1
func2: intPtr = 0xbf806ad4, &intPtr[0] = 0xbf806ad4, intPtr[0] = 1

mainInt = 10, &mainInt = 0xbf806acc
func3: intVal = 10, &intValue = 0xbf806ad0

Dans func1 et func2 "dynArray" et "intPtr" sont des variables locales, mais ils sont variables de pointeur dans lequel ils reçoivent l'adresse de "mainArray" de main.

Ce comportement est spécifique à des tableaux. Si vous avez été de mettre le tableau à l'intérieur d'une structure (struct), alors vous seriez en mesure de passer par valeur.

3

Un tableau passé à une fonction, est converti en un pointeur. Lorsque vous passez un pointeur en argument à une fonction, il vous suffit de donner l'adresse de la variable dans la mémoire. Ainsi, lorsque vous modifiez la valeur de la cellule du tableau, vous modifiez la valeur à l'adresse donnée à la fonction.

Lorsque vous passez un simple entier à une fonction, l'entier est copié dans la pile, lorsque vous modifiez le nombre entier dans la fonction, vous modifiez la copie de l'entier, et non l'original.

Rappel des différents types de mémoire en C

En C, on peut utiliser trois types de mémoire :
- la pile, utilisé pour les variables locales et fonctions des appels: lorsque nous créons une variable dans main(), nous utilisons la pile pour stocker la variable, et quand une fonction est appelée, les paramètres de la méthode sont les inscrire dans la pile. Lorsque nous la sortie d'une fonction, nous "pop" de ces paramètres pour revenir à l'état d'origine, avec la variable utilisée avant l'appel de la fonction. (anecdote: un stackoverflow est quand on hack de la pile à l'utilisation précédente de variables dans une fonction sans passer comme paramètres)
- le tas qui correspond à la dynamicly mémoire allouée: lorsque nous avons besoin d'une grande quantité de données, nous utilisons ce segment parce que la pile est limitée à quelques méga-octets.
- le code dans lequel les instructions de programme sont stockées
Dans le cas de ce tableau passé par une fonction, qui est un pointeur (l'adresse d'une autre variable), il est stocké dans la pile, lorsque nous appelons la fonction, on copie le pointeur dans la pile.

Dans le cas d'un entier, il est également stockée dans la pile, lorsque nous appelons la fonction, nous avons copie de l'entier.

Si nous voulons modifier le nombre entier, on peut passer l'adresse de l'entier de modifier la valeur du pointeur, comme ceci:
```
void function(int *integer)
{
    *integer = 2;
}

int main()
{
    int integer = 1;
    function(&integer);

    printf("%d", integer);

    return 0;
}
```
1

Il y a une différence entre "passer par référence" et de "passage par valeur"

Passer par référence mène à un endroit de la mémoire où le passage par valeur passe directement la valeur, une variable tableau est toujours une refference, de sorte qu'il pointe vers un emplacement dans la mémoire. Entiers sera le passage par valeur par défaut
1

Dans le premier code, vous êtes de passage à l'adresse de la table de pointage vers le haut de l'élément dans le tableau. Ainsi, lorsque vous modifiez la valeur dans la fonction et revenir à la fonction principale vous êtes accédant à la même matrice qui est à la même adresse. Ceci est appelé le passage par référence.

Cependant, dans le second cas, la valeur de l'entier est copié à partir de la fonction principale de la fonction appelée. En d'autres termes, les deux entiers sont à différentes adresses dans la mémoire. Donc, une modification de l'un ne modifie pas les autres.
0

Le nom de tableau est un pointeur vers le premier élément du tableau. Dans le premier exemple de code que vous avez passé un pointeur vers l'emplacement de mémoire contenant le premier élément du tableau. Dans le deuxième exemple de code que vous avez passé un entier par valeur, donc il n'a rien à voir avec la variable locale nommée "integer"

vérifier que le lien

Passage par référence et le passage par valeur

Passage par Référence /Valeur en C++

Vous devez vous connecter pour publier un commentaire.

Rappel des différents types de mémoire en C