Discussion :

[KaKou87]

Bonjour,

Voici un cas de débutant dont je ne trouve pas la bonne solution:
Il me faut définir une fonction createArray prenant en paramètre un entier. La fonction allouera dynamiquement une variable de type dynIntArray ne contenant aucun élément mais pouvant stocker sans réallocation jusqu’à n entiers . La fonction renverra l'adresse de la zone mémoire nouvellement allouée.

La struct est :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
typedef struct{
    int * tab;
    unsigned int capacity;
    unsigned int size;
} dynIntArray;

Ma fonction :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
dynIntArray* createArray(unsigned int capacity){
 
    if (capacity > 0) // Il faut qu'il ait au moins une case
    {
        dynIntArray dyn;
        dynIntArray* dyn =(dynIntArray*) malloc(sizeof(dynIntArray)); // On alloue de la mémoire pour le tableau
        dyn.tab = (int*) malloc(capacity * sizeof(int));
        return dyn ;
    }else{
        return 0;
 
    }
}

Je ne comprends pas comment à la fois allouer la mémoire pour le tab dynamique et pour la structure elle-même, cela me semble répétitif et je ne sais donc pas quoi vraiment retourner. Il doit me manquer une information.
De même cela m'aidera pour créer une fonction qui elle libérera la mémoire allouée.

Merci d'avance pour les âmes perdues qui m'aideront .

[gerald3d]

Bonjour.

Tout d'abord, il faut essayer tant que faire ce peut d'avoir un code le plus concis possible, sans perdre pour autant la lisibilité de ce dernier.

En partant de ce principe on peut déjà modifier ta fonction ainsi :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
dynIntArray* createArray(unsigned int capacity){
 
    if (capacity == 0) // Retourne NULL si le paramètre transmis n'est pas correcte.
      return NULL;
 
    dynIntArray dyn;
    dynIntArray* dyn =(dynIntArray*) malloc(sizeof(dynIntArray)); // On alloue de la mémoire pour le tableau
    dyn.tab = (int*) malloc(capacity * sizeof(int));
 
    return dyn ;
}

Tu vois déjà qu'on gagne en indentation et en nombre de lignes. La clarté du code reste encore très bonne.

Pour ton souci, lorsque tu alloues il faut allouer la taille de la donnée X le nombre de données que tu désires mémoriser.
Donc on aura plutôt :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
dynIntArray* createArray(unsigned int capacity){
 
    if (capacity == 0) // Retourne NULL si le paramètre transmis n'est pas correcte.
      return NULL;

    dynIntArray* dyn = malloc(sizeof(dynIntArray) * capacity); // On alloue de la mémoire pour le tableau
 
    return dyn ;
}

Comme tu peux le voir j'ai sérieusement simplifié ton code et ajouté la multiplication nécessaire. Ta fonction renverra NULL si l'allocation a causé une erreur ou si capacity=0. D'ailleurs on pourrait aussi supprimer le test de capacity puisque malloc(); renvoie NULL si on cherche à allouer 0 élément.
Pour finir tu remarqueras que j'ai supprimé le cast de malloc();. En C il ne sert à rien.

J'ai modifié ton code car je ne comprends pas cette histoire de structure. Ici tu as une allocation d'un tableau contenant capacity éléments de type dynIntArray. Si tu peux préciser un peu le but final de l'exercice...

[dalfab]

Bonjour,

On pourrait ne faire qu'une allocation en regroupant les 2 zones, mais si on veut agrandir la capacity ça ne marchera plus. Il faut donc conserver les 2 allocations, et il faut penser à bien tout initialiser :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
dynIntArray* createArray( unsigned capacity ) {
    if ( capacity == 0u ) // Retourne NULL si le paramètre transmis n'est pas correct
      return  NULL;
 
    dynIntArray*  dyn = malloc( sizeof(*dyn) ); 
    dyn.tab = malloc( capacity * sizeof(int) );
    dyn.capacity = capacity;          // noter capacité
    dyn.size = 0u;                    // vide pour le moment
 
    return  dyn;
}
 
bool changeArrayCapacity( dynIntArray* pdyn , unsigned capacity ) {
    if ( capacity == 0u )
        return  false;                 // erreur paramètre
 
    int*  newTab = realloc( pdyn->tab , capacity * sizeof(int) );
    if ( newTab == NULL )
        return  false;                 // erreur mémoire
 
    pdyn->tab = newTab;
    pdyn->capacity = capacity;         // noter nouvelle capacité
    if ( pdyn->capacity < pdyn->size )
        pdyn->size = pdyn->capacity;   // a pu perdre des éléments
 
    return  true;
}

[Bktero]

C'est moi qui capte rien ou l'allocation d'un dynIntArray ne sert à rien ?

Il suffit de créer une structure en local, allouer une zone d'entiers, mettre l'adresse dans la structure, renvoyer la structure par copie.

[sambia39]

Bonjour,
Je suis d'avis avec @Bktero sur le fait que l'on peut tout simplement avoir une seule fonction qui se charge d'allouer la mémoire nécessaire pour tab et donc pas besoin de consommer davantage de mémoire.
De plus, si l'on veut optimiser les choses, on peut très bien écrire comme dans l'exemple ci-dessous l'allocation de mémoire et donc même si l'on fournie une valeur du genre 0 ou -1. malloc va tous naturellement renvoyer soit NULL ou un pointeur "invalide qui peut être utilisé avec free".

Code C :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
 
int *get_capacity( size_t size ){
    int *dt = NULL;
    return ( (NULL == (dt = malloc(size * sizeof *dt)) ) ? NULL : dt ); 
}
 
 
int main(void) {
    dynIntArray dt;
    if( NULL == (dt.tab = get_capacity(0)) ){
        (void)fprintf(stderr, "Error allocation");
        abort();    //crash si -1
    }
    /*
    *   utilisation 
    */
    /* -- snip --*/
 
    free(dt.tab);
    dt.tab = NULL;
    return EXIT_SUCCESS;
}

À bientôt,

[Sve@r]

Bonjour

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
typedef struct{
    int * tab;
    unsigned int capacity;
    unsigned int size;
} dynIntArray;

Ma fonction :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
dynIntArray* createArray(unsigned int capacity){
 
    if (capacity > 0) // Il faut qu'il ait au moins une case
    {
        dynIntArray dyn;
        dynIntArray* dyn =(dynIntArray*) malloc(sizeof(dynIntArray)); // On alloue de la mémoire pour le tableau
        dyn.tab = (int*) malloc(capacity * sizeof(int));
        return dyn ;
    }else{
        return 0;
 
    }
}

Déjà la ligne 5 dynIntArray dyn; ne sert à rien et nuit à la compréhension.
Et ensuite, quand on a un pointeur de structures et qu'on veut accéder à ses membres, on utilise la flèche => dyn->tab=malloc(...).

Je ne comprends pas comment à la fois allouer la mémoire pour le tab dynamique et pour la structure elle-même, cela me semble répétitif

Oui, répétitif. Mais c'est toi qui veut faire ces deux actions. Donc il faut les faire. Hé oui, le C est très bas niveau.
Dis-toi que ce sont deux actions différentes (allouer de la mémoire pour la structure puis remplir un de ses membres). Sauf que la valeur que tu stockes dans ledit membre c'est (pur hasard) l'adresse d'une zone elle-aussi allouée.

et je ne sais donc pas quoi vraiment retourner. Il doit me manquer une information.

Ben tu l'as dit => la structure allouée => return dyn.

Et le code de gerald3d reprend parfaitement ce que tu veux faire (sauf que lui aussi il a oublié la flèche à cause de ta ligne 5)

Code c :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
dynIntArray* createArray(unsigned int capacity){
 
    if (capacity == 0) // Retourne NULL si le paramètre transmis n'est pas correct.
      return NULL;
 
    dynIntArray* dyn = malloc(sizeof(dynIntArray)); // On alloue de la mémoire pour la structure
    dyn->tab = malloc(capacity * sizeof(int));  // On alloue de la mémoire pour le tableau
 
    return dyn ;
}

De même cela m'aidera pour créer une fonction qui elle libérera la mémoire allouée.

Code c :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
void freeArray(dynIntArray *dyn) {
    free(dyn->tab);
    free(dyn);
}

C'est moi qui capte rien ou l'allocation d'un dynIntArray ne sert à rien ?

Ben peut-être qu'il veut gérer plusieurs structures de façon indépendantes...

[Médinoc]

Attention, penser à régler dyn->capacity, et initialiser dyn->size à zéro.