Changement de tableau à l'intérieur de la fonction en C

Je suis en train d'apprendre le C et confus pourquoi un tableau créé dans les principaux habitude de changement à l'intérieur de la fonction, je suis en supposant que le tableau passé est un pointeur, et la modification du pointeur devraient ai changer le tableau , à droite ? quelqu'un peut m'expliquer ce qui se passe dans ce cas?

thx pour l'aider.

int main(){
    int i, length = 10;
    int array[length];

    for (i = 0 ; i < length ; i++)
        array[i] = i * 10;
    printf("Before:");
    print(array, length);
    change(array, length);
    printf("After:");
    print(array, length);

    return 0;
}

//Print on console the array of int
void print(int *array,int length)
{
    int i;
    for(i = 0 ; i < length ; i++)
        printf("%d ", array[i]);
    printf("\n");
}

//Change the pointer of the array
void change(int *array,int length)
{
    int *new = (int *) malloc(length * sizeof(int));
    int i;
    for(i = 0 ; i < length ; i++)
        new[i] = 1;
    array = new;
}

J'attend de voir la sortie suivante:

Before:0 10 20 30 40 50 60 70 80 90 
After:1 1 1 1 1 1 1 1 1 1

Ce que je reçois:

Before:0 10 20 30 40 50 60 70 80 90 
After:0 10 20 30 40 50 60 70 80 90

ses juste pour le test
Jamais, pas même pour le test.
u peut donner des conseils alors? thx
Tableau est une variable locale à l'intérieur des deux main et change. Son adresse est passé de main à change. Après cela, change pouvez la redistribuer et elle n'aura aucun effet sur le tableau dans main. Les deux variables sont indépendantes. Maintenant, change peut changer le contenu de array, auquel cas main verrez le changement.
Viens voir ma réponse, et vous comprendrez ce que je veux dire. Pour les compilateurs for(int i=0;i<length;i++) est parfaitement lisible mais pour les humains ... C'est mieux que for (int i = 0 ; i < length ; i++). Aussi, l'écriture de plusieurs instructions sur la même ligne rend encore plus difficile à lire.
Ne pas utiliser malloc pour une telle tâche. Essayez ceci.
Est une bonne habitude d'utiliser "const" chaque fois que vous voulez une fonction à ne pas modifier quelque chose. Donc, juste pour s'assurer que vous êtes réellement l'impression et de ne pas essayer de modifier le tableau à l'intérieur de la fonction d'impression que vous devriez changer votre fonction d'impression pour annuler l'impression(const int *tableau, int longueur){..}.
Je suis confus pourquoi void f(int i) {i = 5;} int main() {int x = 0; f(x); printf("%d\n", x); return 0;} ne pas imprimer sur 5? N'ai-je pas changer de x à l'intérieur de la fonction?

InformationsquelleAutor Victor Ferreira | 2016-01-17

arrays c function pointers

8

Dans c vous ne pouvez pas passer une variable par référence, la array variable que vous attribuez à l'intérieur de la fonction contient initialement la même adresse que le pointeur passé, mais c'est une copie de celui-ci afin de le modifier ne pas modifier le passé pointeur.

Vous avez besoin de passer l'adresse du pointeur de la souris afin d'être en mesure de le modifier, à l'instar de ce
```
//Change the pointer of the array
void change(int **array, int length)
{
    *array = malloc(length * sizeof(int));
    if (*array == NULL)
        return;
    for (int i = 0 ; i < length ; i++)
        (*array)[i] = 1;
}
```
Puis dans main() vous ne pouvez pas affecter à un tableau, de le faire par le biais de ce genre de fonction est sûrement un comportement indéfini. Le tableau défini dans main() est alloué sur la pile, et vous ne pouvez pas affecter quoi que ce soit à un tableau, car ils sont non-inscriptible lvalues de sorte que vous ne peut pas le faire pointer vers un segment de mémoire emplacement obtenus avec malloc(), vous avez besoin pour passer un pointeur comme ce
```
int *array;
change(&array, length);
free(array);
```
Si vous voulez que la fonction remplacer le tableau précédent, il devra free() la malloc()ed de données (remarque que le passage NULL à free() est bien défini), de sorte
```
//Change the pointer of the array
void change(int **array, int length)
{
    free(*array);

    *array = malloc(length * sizeof(int));
    if (*array == NULL)
        return;
    for (int i = 0 ; i < length ; i++)
        (*array)[i] = 1;
}
```
puis dans main()
```
int *array;
array = NULL;
change(&array, length);
change(&array, length);
change(&array, length);
change(&array, length);
free(array);
```
à faire ce que vous apparemment le souhaitez.

InformationsquelleAutor Iharob Al Asimi
0

Vous passez un pointeur vers le tableau array à la fonction change. Dans cette fonction, vous pouvez créer un autre tableau appelé new (à l'aide de new comme un nom est une mauvaise idée), puis l'affecter à la créés localement les paramètres de la fonction array. Vous ne pas modifier le pointeur de votre main fonction. Si vous souhaitez faire, vous devez utiliser
```
array = change(array,length);
```
dans votre fonction principale et
```
int *change(int *array, int length) {
    int *variable_called_new =(int *)malloc(length*sizeof(int));
    [...]
    return variable_called_new
}
```
dans votre change fonction.
- thx ,il a travaillé, mais il est de toute façon à changer le pointeur de la pile sans avoir à retourner un int pointeur ?
- Vous pouvez le trouver dans iharob réponse. Il suffit de passer un pointeur vers un pointeur vers un tableau 🙂
InformationsquelleAutor nsilent22
0

Votre tableau principal est un tableau. Il se désintègre à un pointeur, pour produire le comportement que vous attendez, mais il est pas un pointeur.
```
int a[10];
int* p = a; //equivalent to &a[0]; create a pointer to the first element
a = p;      //illegal, a is NOT a pointer.
```
Ce que votre code est en train de faire est de copier l'adresse d'une fonction de variable locale. La modification, il aura plus aucune différence à l'extérieur de la modification de la longueur.
```
void change(int* local_ptr, size_t length)
{
    local_ptr = 0;
    length = 0;
}

int main()
{
    int a[10];
    int length = 10;
    printf("before a=%p, length=%d\n", a, length);
    change(a, length);  //we copied 'a' into 'local_ptr'. 
    printf("after a=%p, length=%d\n", a, length);
}
```
Si vous souhaitez modifier un pointeur de l'appelant, vous aurez besoin d'utiliser de pointeur vers le pointeur de la syntaxe:
```
void change(int** ptr, size_t length)
{
    //change the first element:
    **ptr = 0;
    //change the pointer:
    *ptr = 0;
    //but ptr itself is a function-local variable
    ptr = 0;  //local effect
}
```
Cependant: Il y a un problème avec ce que vous essayez de faire qui va au plus profond que cela.

Dans votre code, "int a" est un tableau sur la pile, pas un pointeur alloué; vous ne pouvez pas, et vous devriez éviter de mélanger des tas/pile pointeurs de cette façon parce que vous finirez gratuit la mauvaise chose.

InformationsquelleAutor kfsone

À utiliser le passage par valeur:

Effectuez les modifications suivantes:

En fonction change(...), remplacer:

int i;for(i=0;i<length;i++)new[i] = 1;

À:

int i;for(i=0;i<length;i++)array[i] = 1;
                           ^^^^^

MODIFIER:

Mais pour utiliser le passage par référence:

//To change the contents of a variable via a function call
//the address of that variable has to be passed. So, if you
//want to change the contents of an array of int, i.e. int *array, you 
//need to pass its address, not the variable itself,  using the 
//address of operator, it would look like this &array (read _the address of
//pointer to int "array")
//This requires you to change the prototype of your function:
void change2(int **a, int len)
{
    int i;
    for(i=0;i<len;i++) (*a)[i] = 1;//parenthesis bind * to a to assure 
                                   //array of pointers to int ( *[] )is populated
                                   //
}

Puis, en principal, apportez les modifications suivantes, et il fonctionnera comme vous le dessein:

int main(){
    int i,length=10;
    int *array;

    array = calloc(length, sizeof(int));
    if(!array) return 0;
    //or malloc if preferred.  But note, in C, 
    //casting the output is not required on either.
    //array = malloc(length*sizeof(int));
    //if(!array) return 0;

    for(i=0;i<length;i++)array[i]=i*10;

    printf("Before:");print(array,length);
    change2(&array,length);
    printf("After:");print(array,length);

    free(array);

    return 0;
}

je veux changer le pointeur , pas de valeur par valeur ,mais merci quand même
ensuite, vous devez passer le pointeur à être changé, pas la valeur. Voir mon montage en quelques minutes.
Victor, que voulez-vous dire quand vous dites "vous voulez changer le pointeur"? Vous avez modifié le pointeur. Par la manière, les choses pourraient être moins compliqué si vous avez utilisé un nom différent (autre que le "tableau" pour le pointeur passé à "changer"), donc quand vous dites que vous souhaitez modifier "X", il sera clair ce que tu veux dire.
Je pense que vous devez utiliser le "@Victor Ferreira" dans le commentaire, et il va drapeau Victor...
Merci, je n'étais pas en train de drapeau de lui, je pensais qu'il était en attente de votre commentaire, je ne voulais pas pousser en face de vous. Par ailleurs, si vous allez le lui dire de passer un pointeur vers un pointeur, alors il ne fonctionnera pas. Au moins pas dans le sens de l'évolution "tableau" dans la fonction main (ce qui est impossible).

InformationsquelleAutor ryyker

0

ainsi, lorsque vous passer le tableau, vous obtenez l'adresse de début:

mémoire adresse

|-junk-| 1000

|---0---| 1008 <- début de votre tableau

|---10--| 1012

. .
. .

lorsque vous obtenez le pointeur dans ta fonction, sa valeur est 1008(exemple) afin de changer cela signifie seulement vous maintenant point à un autre endroit. ce n'est pas ce que vous voulez.
vous pouvez modifier les entiers pointé directement par l'opérateur*, donc
*array = 99; va changer le premier élément,
*(array+1) = 98; la deuxième et ainsi de suite.
vous pouvez aussi, plus naturellement utiliser l'opérateur [].
donc, dans votre fonction
array[0] = 99; va effectivement changer le tableau d'origine.

InformationsquelleAutor rustypaper

            #include<stdio.h>
            #include<stdlib.h>

            //Print on console the array of int
            void print(int *array,int length)
            {
                int i;
                for(i = 0 ; i < length ; i++)
                    printf("%d ", array[i]);
                printf("\n");
            }

            //Change the pointer of the array
            void change(int **array,int length)
            {
                int i;
                int *ar;
                ar = (int *)malloc(sizeof(int *) * length);
                for(i = 0 ; i < length ; i++)
                    ar[i] = 1;
                (*array) = ar;
            }

            int main(){
                int i, length = 10;
                int *array;
                array = (int *)malloc(sizeof(int *) * length);

                for (i = 0 ; i < length ; i++)
                    array[i] = i * 10;
                printf("Before:");
                print(array, length);
                change(&array, length);
                printf("After:");
                print(array, length);

                return 0;
            }

Pouvez-vous expliquer en mots ce qui est différent dans votre solution que dans la question d'origine, et pourquoi il résout le problème? Aussi, le code d'origine et votre code d'avoir une fuite de mémoire.

InformationsquelleAutor yogesh

Vous devez vous connecter pour publier un commentaire.