C: ajout d'élément de tableau alloué dynamiquement

J'ai essayé de trouver une solution via Google: je ne pouvais pas trouver quelque chose qui a aidé; il paraît même que si je faisais cela correctement. Les seules pages que j'ai pu trouver concernant l'envoi de mon tableau alloué dynamiquement via une fonction traitées avec la matrice à l'intérieur d'une structure, qui est scalaire, donc se comporte différemment. Je ne veux pas utiliser une structure en ce moment, je suis en train d'apprendre à propos de BARRAGE et de travailler avec des pointeurs et des fonctions.

Cela dit, je suis sûr que c'est très primaire, mais je suis coincé. Le code compile, mais il se fige quand je lance l'exécutable. (Je suis en utilisant minGW gcc, si ce qui compte. Et je ne suis pas clair du tout, dès maintenant, sur la façon d'utiliser gdb.)

Voici le code (finalement, je veux que l'ensemble du code à une liste de tableaux-comme structure de données):

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

void add( int element, int *vector);
void display_vector( int *vector );
void initialize_vector( int *vector );

int elements = 0;
int size = 10;

int main(void)
{
    int *vector = 0; 
    initialize_vector(vector);
    add(1, vector);
    //add(2, vector);
    //add(3, vector);
    //add(4, vector);
    //add(5, vector);
    //add(6, vector);
    //add(7, vector);
    //add(8, vector);
    //add(9, vector);
    //add(10, vector);
    //add(11, vector);
    display_vector(vector); 

    return 0;
}

void add( int element, int *vector)
{
    vector[elements++] = element;
    return;
}

void display_vector( int *vector )
{
    int i;
    for( i = 0; i < elements; i++)
    {
        printf("%2d\t", vector[i]);
        if( (i + 1) % 5 == 0 )
            printf("\n");
    }
    printf("\n");
    return; 
}

void initialize_vector( int *vector )
{
    vector = (int *)malloc(sizeof(int) * size);

}

Pourquoi avez-vous elements et size comme des variables globales, mais vector est une variable locale? Puisque vous ne pouvez pas avoir plus d'un vecteur à cause de la global elements variable, vous pourriez aussi bien faire vector une variable globale ainsi.
Vous affectez l'adresse de la mémoire nouvellement allouée pour le pointeur. L'original pointeur est toujours un NULLPTR.
Très bon point @Barmar.
ne dois-je pas faire l'original pointeur null alors? Il s'exécute de la façon dont il est mis en place maintenant avec dboals modifications de code.

InformationsquelleAutor BWONG | 2014-05-02

arrays c dynamic-memory-allocation pointers

3

Modifié pour le rendre un peu plus clair.

Le problème est votre routine init est de travailler avec une copie de "vecteur" et est malloc qui pratiquent dans cette copie plutôt que l'original de vecteur de pointeur. Vous perdez le pointeur vers le bloc de mémoire sur le retour de l'initialiser.

Changer le paramètre de vecteur à une poignée (pointeur de pointeur) dans cette fonction,
```
void initialize_vector( int **vector )
{
    *vector = (int *)malloc(sizeof(int) * size);
}
```
Ensuite modifier l'appel à init pour ce
```
initialize_vector(&vector);
```
Je n'ai pas le compiler, mais il faut corriger le code.
- Il devrait être *vector = ...
- Oui, Barmar est correct. Je vais changer le correctif
InformationsquelleAutor dboals
2

En C, la fonction, les arguments sont passés par valeur, ce qui signifie qu'il est une copie locale pour tous les arguments passés à une fonction, si vous modifiez un argument dans une fonction, vous modifiez uniquement la copie locale de cet argument. Donc, si vous voulez changer la valeur d'un argument dans une fonction, vous devez passer son adresse à cette fonction, derefer que l'adresse et affecter le résultat de cette fonction.

Assez pour la théorie, voici comment réparer votre code:
```
void initialize_vector( int **vector );

initialize_vector(&vector);

void initialize_vector( int **vector )
{
    *vector = (int *)malloc(sizeof(int) * size);

}
```
- Merci beaucoup @Lee Duhem. Je +1 à vous.
InformationsquelleAutor Lee Duhem

Dans plus d'autres réponses, je voudrais suggérer une autre approche.

En supposant au moins C99 conforme compilateur, je préfère suggérons de garder la taille allouée à un membre d'une structure en terminant par une flexible membre du groupe (voir aussi cette) comme:

 typedef struct vector_st {
    unsigned count; //used length
    unsigned size;  //allocated size, always >= length
    int vectarr[];
 } Vector;

Alors vous construire un tel vecteur avec

 Vector* make_vector (unsigned size) { 
   Vector* v = malloc(sizeof(Vector)+size*sizeof(int));
   if (!v) { perror("malloc vector"); exit (EXIT_FAILURE); };
   memset (v->vectarr, 0, size*sizeof(int));
   v->count = 0;
   v->size = size;
 }

Pour ajouter un élément dans un vecteur, en retournant le vecteur d'origine ou un grand un:

Vector* append_vector (Vector*vec, int elem) {
  assert (vec != NULL);
  unsigned oldcount = vec->count;
  if (oldcount < vec->size) {
     vec->vectarr[vec->count++] = elem;
     return vec;
  } else {
     unsigned newsize = ((4*oldcount/3)|7) + 1;
     Vector* oldvec = vec;
     vec = malloc(sizeof(Vector)+newsize*sizeof(int));
     if (!vec) { perror("vector grow"); exit(EXIT_FAILURE); };
     memcpy (vec->vectarr, oldvec->vectarr, oldcount*sizeof(int));
     memset (vec->vectarr + oldcount, 0, 
             (newsize-oldcount) * sizeof(int));
     vec->vectarr[oldcount] = elem;
     vec->count = oldcount+1;
     vec->size = newsize;
     free (oldvec);
     return vec;
  }
}

et vous pourriez code:

Vector* myvec = make_vector(100);
myvec = append_vector(myvec, 35);
myvec = append_vector(myvec, 17);
for (int i=0; i<150; i++)
   myvec = append_vector(myvec, i*2);

À la libération comme un vecteur, il suffit d'utiliser free(myvec);

Si vraiment vous ne voulez pas utiliser de struct vous devriez garder à l' variables distinctes utilisés pour la longueur du vecteur, la répartition de la taille de votre vecteur, le pointeur de votre allouée dynamiquement tableau:

  unsigned used_count; //useful "length"
  unsigned allocated_size; //allocated size, always not less than used_count
  int *dynamic_array; //the pointer to the dynamically allocated array

Si vous voulez être en mesure de gérer plusieurs vecteurs, puis placez l'ensemble au-dessus de longueur utile, réparti de la taille et tableau dynamique dans certains struct dynamic_array_st (dont le pointeur que vous devez passer à la appropriée des routines comme make_dynamic_vector(struct dynamic_array_st*), append_dynamic_vector(struct dynamic_array_st*, int), etc ....) ou bien les transmettre sous forme de trois formals de routines similaires, puis vous aurez besoin pour passer leur adresse parce que les routines de les changer, par exemple, create_dynamic_vector(unsigned *countptr, unsigned *sizeptr, int**vectarrptr) que vous invoquez comme create_dynamic_vector(&mycount, &mysize, &myvectarr); etc.

Je pense qu'un flexible de membre du groupe est toujours le plus propre approche.

InformationsquelleAutor Basile Starynkevitch

Vous devez vous connecter pour publier un commentaire.