Allocation dynamique, malloc, free

**nl.smart** · 11/10/2019, 10h19

Bonjour,

Est-ce tout simplement correct ?

Code :

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

ptr_prenom_personnes[i] = malloc(30 * sizeof(*ptr_prenom_personnes[i]));

30 caractères sont ainsi alloués et je crains de ne pas être protégé contre le dépassement de mémoire ou autres trucs risqués, vivement le chapitre sur la saisie de texte "sécurisée" avec fgets que je n'ai pas encore abordé, voir poste de proteiforme datant du 7/10

Le code qui suit date d'hier matin, je ne l'ai pas posté à la vue du poste de proteiforme signalant l'erreur mentionnée dans vos 3 derniers postes

Pour ce qui est des structures, les ayant vues, il faudra que je réalise l'allocation dynamique avec une structure, le poste (awesome) de foetus y aidera grandement.

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
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
#include <stdio.h>  // ok linux
#include <stdlib.h> //
#include <time.h>   //
#include <string.h> //

#ifdef __linux__
#define CLEAR system("clear"); // efface l'écran sous linux
#elif _WIN64
#define CLEAR system("cls"); // efface l'écran sous windows
#endif

//#define CLEAR system("clear||cls"); // efface le texte à la console sous linux et windows, risque de ub ou pas ? N'ai pas encore eu de soucis avec.

int main()
{
    unsigned int nbre_personnes; // j'ai des warning si cette variable n'est pas de ce type...

    int main_error_line = 0; // erreur dans le main() ligne...

    size_t i;

    char **ptr_prenom_personnes = NULL;

    int *ptr_age_personnes = NULL;

    printf("\n Combien de personnes sont ici présentes ? ");
    scanf("%d", &nbre_personnes);

    ptr_prenom_personnes = calloc(nbre_personnes, sizeof(*ptr_prenom_personnes));
    if (ptr_prenom_personnes == NULL)
    {
        main_error_line = 20; // j'ai en tête la création automatique d'un fichier (fopen...) reportant la ligne d'où proviendrait l'erreur, ah! les bug report
        goto lol; // goto envoyé ligne 62
    }

    ptr_age_personnes = malloc(nbre_personnes * sizeof(int));
    if (ptr_age_personnes == NULL)
    {
        main_error_line = 27;
        goto lol; // goto envoyé ligne 62
    }

    for (i = 0; i < nbre_personnes ; i++)
    {
        ptr_prenom_personnes[i] = malloc(30 * sizeof(*ptr_prenom_personnes[i])); // en effet, j'ai négligé ce point mentionné dans vos derniers postes, 30 caractères sont alloués et je crains de ne pas être protégé contre le dépassement de mémoire, vivement le chapitre sur la saisie de texte avec fgets...

        if (ptr_prenom_personnes[i] == NULL)
        {
            main_error_line = 37;
            goto lol; // goto envoyé ligne 62
        }

        printf("\n Personne %lu , quel est votre prénom ? ", i + 1);
        scanf("%s", ptr_prenom_personnes[i]);
        // faire se suivre les 2 questions, tellement plus logique, c'est fait
        printf("\n %s quel âge avez-vous ? ", ptr_prenom_personnes[i]);
        scanf("%d", &ptr_age_personnes[i]);
    }

    CLEAR // effacement du texte à la console

    for (i = 0; i < nbre_personnes ; i++)
    {
        printf("\n %s , vous avez %d an%c.", ptr_prenom_personnes[i], ptr_age_personnes[i], ptr_age_personnes[i] > 1 ? 's' : ' ');
    }
    // libération de la mémoire allouée ci-après

    lol:  // goto reçus des lignes 27, 34, 44

    if (ptr_prenom_personnes != NULL)

    for (i = 0; i < nbre_personnes; i++)
    {
        free(ptr_prenom_personnes[i]);
    }

    free(ptr_prenom_personnes);
    free(ptr_age_personnes);

    printf("\n");

    return main_error_line == 0 ? EXIT_SUCCESS : EXIT_FAILURE; // un ternaire + return, waouh !
}

bonne journée,

Nicolas.

**Sve@r** · 11/10/2019, 15h54

Envoyé par nl.smart

Bonjour,

Nan c'est bon, une fois suffit.

Envoyé par nl.smart

Code :

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

ptr_prenom_personnes[i] = malloc(30 * sizeof(*ptr_prenom_personnes[i]));

30 caractères sont ainsi alloués

Ok. N'oublie pas alors que tu n'as droit qu'à 29 (il faut garder une place pour le '\0')

Envoyé par nl.smart

et je crains de ne pas être protégé contre le dépassement de mémoire ou autres trucs risqués

A mon avis pour le moment c'est le cadet de tes soucis. Fais un truc qui fonctionne et qui te fait plaisir, tu auras le temps après pour le renforcer

Envoyé par nl.smart

Le code qui suit date d'hier matin, je ne l'ai pas posté à la vue du poste de proteiforme signalant l'erreur mentionnée dans vos 3 derniers postes

J'aime bien. Tu as réfléchi et mis un nom de variable plus intelligent que "bad" et j'aime bien ceux qui font preuve d'initiative (contrairement à certains boulets que je n'hésite pas à tacler).
Petite astuce: le préprocesseur te donne une macro "__LINE__" qui contient la ligne du code en cours. Donc au lieu d'écrire main_error_line = 20, tu peux écrire main_error_line = __LINE__. Et ça s'adaptera automatiquement si le code évolue. Il te donne aussi la macro "__FILE__" qui contient le nom du fichier source (pour ton log ce sera utile)...

**Proteiforme** · 11/10/2019, 18h34

Correcte oui, optimal non. ( En admettant qu'un char fasse 1 octet, tu auras des allocations de 30 octets même pour un prénom comme Anne qui aurait besoin de seulement 4 + 1 octets, 25 octets de perdu )

Mais tu t'en rendras compte plus tard quand tu attaqueras, et si tu le fais, la gestion des chaines de caractères.

Bonne continuation dans ton apprentissage

Pour la saisie, il y a un sujet qui pourrait t’intéresser quelques lignes plus bas, "Le vilain scanf (C)"

**nl.smart** · 13/10/2019, 18h12

#include "Politesse.h"

Merci pour vos derniers postes, j'en prends bonne note.

Le sujet passe en résolu même si l'allocation dynamique avec une structure n'est pas encore réalisée.

**nl.smart** · 15/10/2019, 21h43

#include "Politesse.h"

Voilà l'allocation dynamique de structures, les 3 premiers codes ci-dessous montrent le cheminement pour y parvenir au 4 ^ème code:

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
#include <stdio.h>  // ok linux
#include <stdlib.h> //
#include <time.h>   //
#include <string.h> //
 
struct personne
{
    char prenom_personnes[30]; //
    int age;
};
 
int main()
{
    struct personne joueurs  = {"", 0};
 
    printf("\n Quel est votre prénom ? ");
    scanf("%s", joueurs.prenom_personnes);
 
    printf("\n Quel âge avez-vous ? ");
    scanf("%d", &joueurs.age);
 
    printf("\n %s , vous avez %d an%c.", joueurs.prenom_personnes, joueurs.age, (joueurs.age > 1 ) ? 's' : ' ');
 
    printf("\n");
 
    return EXIT_SUCCESS;
}

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
28
#include <stdio.h>  // ok linux
#include <stdlib.h> //
#include <time.h>   //
#include <string.h> //
 
typedef struct personne
struct personne
{
    char prenom_personnes[30]; //
    int age;
}personne;
 
int main()
{
    personne joueurs  = {"", 0};
 
    printf("\n Quel est votre prénom ? ");
    scanf("%s", joueurs.prenom_personnes);
 
    printf("\n Quel âge avez-vous ? ");
    scanf("%d", &joueurs.age);
 
    printf("\n %s , vous avez %d an%c.", joueurs.prenom_personnes, joueurs.age, (joueurs.age > 1 ) ? 's' : ' ');
 
    printf("\n");
 
    return EXIT_SUCCESS;
}

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
28
29
30
31
32
33
34
#include <stdio.h>  // ok linux
#include <stdlib.h> //
#include <time.h>   //
#include <string.h> //
 
typedef struct personne
{
    char prenom_personnes[30]; //
    int age;
}personne;
 
int main()
{
    personne joueurs[2]  = {{"", 0}};
 
    size_t i = 0;
 
    for (i = 0; i < 2; i++)
    {
        printf("\n Personne %lu , quel est votre prénom ? ", i + 1);
        scanf("%s", joueurs[i].prenom_personnes);
 
        printf("\n %s quel âge avez-vous ? ", joueurs[i].prenom_personnes);
        scanf("%d", &joueurs[i].age);
    }
    for(i = 0; i < 2; i++)
    {
        printf("\n %s , vous avez %d an%c.", joueurs[i].prenom_personnes, joueurs[i].age, joueurs[i].age  > 1 ? 's' : ' ');
    }
 
    printf("\n");
 
    return EXIT_SUCCESS;
}

Allocation dynamique dans une structure :

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
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
#include <stdio.h>  // ok linux
#include <stdlib.h> //
#include <time.h>   //
#include <string.h> //

#ifdef __linux__
#define CLEAR system("clear"); // efface l'écran sous linux
#elif _WIN64
#define CLEAR system("cls"); // efface l'écran sous windows
#endif

// #define CLEAR system("clear||cls"); // efface la console sous linux et windows

typedef struct personne
{
    char prenom_personnes[30]; //
    int age;
}personne;

int main()
{
    unsigned nbre_personnes;

    size_t i;

    personne *joueurs = (personne *)calloc(30, sizeof(personne)); // Initialisation de la structure manquante ?
    // personne *joueurs = (personne *)malloc(30 * sizeof(personne));

    if (joueurs == NULL) // vérification de l'allocation ?
    {
        return EXIT_FAILURE;
    }

    printf("\n Combien de personnes sont ici présentes ? ");
    scanf("%d", &nbre_personnes);

    for(i = 0; i < nbre_personnes; i++)
    {
        printf("\n Personne %lu , quel est votre prénom ? ", i + 1);
        scanf("%s", &joueurs[i].prenom_personnes[i]);

        printf("\n %s quel âge avez-vous ? ", &joueurs[i].prenom_personnes[i]);
        scanf("%d", &joueurs[i].age);
    }
        for(i = 0; i < nbre_personnes; i++)
    {
        CLEAR // effacement de la console
        printf("\n %s , vous avez %d an%c.", &joueurs[i].prenom_personnes[i], joueurs[i].age, joueurs[i].age  > 1 ? 's' : ' ');
    }

    free(joueurs); // libération de mémoire suffisante ?

    printf("\n");

    return EXIT_SUCCESS;
}

Dans le dernier code, est-ce que les points suivants (en rouge dans le code) sont corrects en comparaison des 3 codes précédents ?

_ l'initialisation de la structure ?
_ la vérification de l'allocation de mémoire ?
_ la libération de mémoire?

En comparaison des postes précédents, je pense être loin du compte dans le dernier code...

Merci pour vos lumières.

**Sve@r** · 15/10/2019, 22h23

Envoyé par nl.smart

Dans le dernier code, est-ce que les points suivants (en rouge dans le code) sont corrects en comparaison des 3 codes précédents ?
_ l'initialisation de la structure ?
_ la vérification de l'allocation de mémoire ?
_ la libération de mémoire?

Tout ce qui est allocation c'est bon. Sauf que le cast est inutile (enfin il y a un énorme débat la dessus avec de très bons arguments dans les deux sens mais perso je ne caste pas).
En revanche là où ça pêche, c'est sur le fait que tu alloues 30 joueurs avant de savoir combien l'utilisateur en veut (s'il en veut que 10 ok mais s'il en veut 500...).
Et ces deux lignes scanf("%s", &joueurs[i].prenom_personnes[i]) et printf("%s\n", &joueurs[i].prenom_personnes[i]) ça c'est clairement raté (scanf("%s", joueurs[i].prenom_personnes) et printf("%s\n", joueurs[i].prenom_personnes). Et le plus triste, c'est que dans les autres codes c'est bon (même le second avec 2 joueurs).
Dond dis-toi bien qu'un truc alloué s'utilise exactement comme un tableau.

Et le sujet de ton code ce n'est pas "Allocation dynamique dans une structure" mais "Allocation dynamique de structures"

Accessoirement initialiser la structure avant de la remplir est inutile (pourquoi remplir un truc qu'on va re-remplir dans la foulée ?) bien que Medinoc (qui est très très bon aussi) préfère initialiser "pour être sûr". Donc bon...

Truc en plus: un type se préfixe généralement par "t_" pour justement ne pas confondre un identificateur de type avec un identificateur de variable (regarde le "size_t", ce n'est pas un "size" !!!) et le préfixe justement pour ne pas entrer en conflit avec des types "officiels" qui, eux, sont suffixés "_t". Et si tu crées un type sur une structure, alors tu n'es pas obligé de nommer la structure => typedef struct {...} t_xxx et non typedef struct nom_inutile {...} t_xxx (excepté pour les structures qui incluent un pointeur vers elles-même mais tu verras ça plus tard avec les listes chainées).

**nl.smart** · 16/10/2019, 21h30

Aie, aie, aie, j'ai à nouveau alloué 30 joueurs, erreur déjà faite précédemment, c'est corrigé.

Le sujet du poste précédent a été modifié, ça ne fera plus saigner vos yeux

Code :

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

1
2
3
4
5
6
typedef struct // ok, je veillerai à distinguer ainsi les identificateurs
{
int ceci;
char cela;
}
t_lol;

Par contre maintenant j'ai ce warning avant la compilation à la ligne 17

int age; // .../main.c:17: avertissement : padding struct 't_personne' with 2 bytes to align 'age'

Ci-dessous le code en ayant tenu compte de vos remarques :

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
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
#include <stdio.h>  // ok linux
#include <stdlib.h> //
#include <time.h>   //
#include <string.h> //
 
#ifdef __linux__
#define CLEAR system("clear"); // efface l'écran sous linux
#elif _WIN64
#define CLEAR system("cls"); // efface l'écran sous windows
#endif
 
// #define CLEAR system("clear||cls"); // efface la console sous linux et windows
 
typedef struct
{
    char prenom_personnes[30]; //
    int age; // avertissement : padding struct 't_personne' with 2 bytes to align 'age'
}t_personne;
 
int main()
{
    unsigned nbre_personnes;
 
    size_t i;
 
    printf("\n Combien de personnes sont ici présentes ? "); // ici c'est mieux
    scanf("%d", &nbre_personnes);
 
    t_personne *joueurs = (t_personne *)calloc(nbre_personnes, sizeof(t_personne)); //
    // t_personne *joueurs = (t_personne *)malloc(nbre_personnes * sizeof(t_personne));
 
    if (joueurs == NULL) //
    {
        return EXIT_FAILURE;
    }
 
    for(i = 0; i < nbre_personnes; i++)
    {
        printf("\n Personne %lu , quel est votre prénom ? ", i + 1);
        scanf("%s", joueurs[i].prenom_personnes);
 
        printf("\n %s quel âge avez-vous ? ", joueurs[i].prenom_personnes);
        scanf("%d", &joueurs[i].age);
    }
 
    CLEAR // effacement de la console avant la boucle for !
 
        for(i = 0; i < nbre_personnes; i++)
    {
        printf("\n %s , vous avez %d an%c.", joueurs[i].prenom_personnes, joueurs[i].age, joueurs[i].age  > 1 ? 's' : ' ');
    }
 
    free(joueurs); // libération de mémoire
 
    printf("\n");
 
    return EXIT_SUCCESS;
}

**Sve@r** · 16/10/2019, 22h30

Envoyé par nl.smart

Par contre maintenant j'ai ce warning avant la compilation à la ligne 17

Pas chez-moi. Mais ça dit juste qu'il rajoute des octets pour aligner la taille de la structure (la faire coincider avec un mot machine ou un truc du genre).

Envoyé par nl.smart

Ci-dessous le code en ayant tenu compte de vos remarques :

Ok.
Attention aux affichages car ils sont bufferisés et donc tu n'as pas forcément la chaine à l'écran au moment où le code exécute l'instruction.
Un buffer n'est vidé que

s'il est plein
s'il rencontre un '\n' (et il vide jusqu'au '\n')
si c'est demandé via fflush()

C'est pour ça que généralement on met les '\n' en fin d'affichage et pas au début. Mais si c'est pas possible (si par exemple comme ici tu veux afficher un prompt et attendre la réponse) alors tu dois demander le fflush() manuellement

Code c :

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

1
2
3
printf("\n Personne %lu , quel est votre prénom ? ", i + 1);
fflush(stdout);
scanf("%s", joueurs[i].prenom_personnes);

**nl.smart** · 18/10/2019, 22h08

Merci à tous pour vos interventions lors de cette discussion, les choses ont ainsi bien avancées.

Allocation dynamique, malloc, free

C

Discussions similaires

Partager

Partager