Malloc sur pointeur de structure

Version imprimable

Bonjour à tous.

Je suis développeur de base windev, et je me lance dans le C qui est plus prêt de ce qui se passe côté machine.

Je suis en train de suivre un cours et je voudrais réaliser un pendu (classique).

Je voudrais donc essayer de faire au plus propre possible en utilisant des malloc et des struct

voici donc mon code :
Code:

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 #include <ctype.h> #include <stdio.h> #include <stdlib.h> typedef struct Test Test; struct Test { int coupsRestants; int taille; char *motSecret; char *motCache; }; void allocationCHaine(char *tempChar){ tempChar = malloc(6 * sizeof(char)); tempChar[0] = 'S'; tempChar[1] = 'A'; tempChar[2] = 'L'; tempChar[3] = 'U'; tempChar[4] = 'T'; tempChar[5] = '\0'; printf("tempChar : %s\n",tempChar); } void initStruct(Test *tempTest){ tempTest->taille = 0; tempTest->coupsRestants = 0; tempTest->motSecret = NULL; tempTest->motCache = NULL; allocationCHaine(tempTest->motSecret); } int main(int argc, char const *argv[]) { Test mainStruct; initStruct(&mainStruct); printf("mainStruct.motSecret : %s\n",mainStruct.motSecret); return 0; }
Résultats :
tempChar : SALUT
mainStruct.motSecret : (null)

Je tiens à préciser que chez moi ces fonctions sont dans différents fichiers mais je voulais simplifier, le principe est le même
Je cherche donc à affecter ma chaine directement avec un malloc plutôt qu'un tableau fixe.
Le problème ici c'est que forcément on ne modifie pas la chaine de la structure.

Je suis donc dans la logique tenté de faire :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 void allocationCHaine(char *tempChar){ *tempChar = malloc(6 * sizeof(char)); *tempChar[0] = 'S'; *tempChar[1] = 'A'; *tempChar[2] = 'L'; *tempChar[3] = 'U'; *tempChar[4] = 'T'; *tempChar[5] = '\0'; printf("tempChar : %s\n",tempChar); }
Sauf que là, ça ne compile pas.

Pouvez-vous un peu m’éclairer sur tous ces principes et sur la solution à adopter ?

Brody

C'est le truc ultra classique :mrgreen:

Pour simplifier :mrgreen: tous les passages de paramètres en C sont par valeur.
Donc on passe des pointeurs pour modifier cette valeur.
Mais lorsqu'on passe un pointeur, c'est également un passage par valeur de l'adresse (c'est un entier de 32 ou 64 bits).

Or dans ton cas, tu veux également modifier cette adresse. La solution c'est soit un double pointeur soit un retour pointeur.

Code:

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
void create_string01(char** str){
   if (str != NULL) {
        (*str) = malloc(6 /** sizeof(char)*/);
 
        if ((*str) != NULL) {
/*          maybe use strcpy */
            *(*str)     = 'S';
            *(*str + 1) = 'A';
            *(*str + 2) = 'L';
            *(*str + 3) = 'U';
            *(*str + 4) = 'T';
            *(*str + 5) = '\0';
 
            printf("create_string01 - debug : %s\n", (*str));
        }
    }
}
 
 
char* create_string02(void){
    char* str;
 
    str = malloc(6 /** sizeof(char)*/);
 
    if (str != NULL) {
/*      maybe use strcpy */
        str[0] = 'S';
        str[1] = 'A';
        str[2] = 'L';
        str[3] = 'U';
        str[4] = 'T';
        str[5] = '\0';
 
        printf("create_string02 - debug : %s\n", str);
    }
 
    return str;
}
 
 
 
/* ... */
 
char* tab1;
char* tab2;
 
tab1 = NULL;
create_string01(&tab1);
 
tab2 = create_string02();
 
 
/* ... */
 
free(tab1);
free(tab2);

juste pour rigoler

Brody travaille à coté de moi :)

voila ma solution, je n'ai pas fait de C depuis la nuit des temps.

Code:

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
#include <ctype.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
struct Test
{
	int coupsRestants;
	int taille;
	char *motSecret;
  	char *motCache;
};
typedef struct Test Test;
 
void GetWordExt(char** Value)
{
	*(Value) = (char*)malloc(32);
	strcpy(*Value,"SALUT");
}
 
void initStruct(Test *tempTest)
{
   	tempTest->taille       = 0;
 	tempTest->coupsRestants= 0;
	GetWordExt(&tempTest->motSecret);
}
 
int main(int argc, char *argv[])
{
	Test* mainStruct = malloc(sizeof(Test));
	initStruct(mainStruct);
 
	printf("mainStruct.motSecret : %s\n",mainStruct->motSecret);
	return 0;
}

Bonjour,

Ça ne compile pas. En effet quand on écrit : char * tempChar, ça veut dire "pointeur sur char <=> tempChar", on peut aussi le lire "char <=> *tempChar".
Donc ligne 16, tu veux mettre le pointeur dans *tempChar qui est un char (il sera un peu beaucoup à l'étroit!)
Donc lignes 18 à 23, tempChar[x] est un char, et c'est devant les pointeurs que l'on met une étoile pour les déréférencer, ici * devant un char n'a pas de sens.

Pour commencer et limiter l'utilisation des pointeurs (pour éviter les pointeurs de pointeurs) on peut changer le format de ta fonction. Elle ne va rien recevoir mais retourner le pointeur alloué. Ça devient :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 char *allocationCHaine(void) { char* tempChar = malloc( 6 ); // allocation de 6 char, le pointeur est mémorisé dans le pointeur sur des char appelé tempChar tempChar[0] = 'S'; // le premier char pointé par tempChar reçoit le char 'S'. tempChar[1] = 'A'; // le second char pointé par tempChar reçoit le char 'A'. tempChar[2] = 'L'; tempChar[3] = 'U'; tempChar[4] = 'T'; tempChar[5] = '\0'; printf("tempChar : %s\n",tempChar); return tempChar; }

25/07/2019, 16h36
foetus

Tout le monde a oublié de dire que le type char est le seul type qui a une taille fixé par la norme (donc quelque soit la plateforme) : c'est pour cela que sizeof(char) vaut 1 et peut être oublié (moi je le mets en commentaire :mrgreen:)
Parce que @dvsoft nous fait un malloc(32) à la hussarde :aie: :aie:

Et vos codes sont quand même grades :aie: :aie:

Personne teste le retour du malloc : c'est vrai osef, on a tous 8 gigas de mémoire.
Personne libère la mémoire avec free : c'est vrai osef, à la fermeture du programme, la mémoire est supprimée.

Sans parler qu'en C, on a pas besoin de caster le retour du malloc.
25/07/2019, 19h52
brody

Bonjour à tous,

Merci pour vos réponses qui fonctionnent.

Je ne voulais pas utiliser le return car je voulais surtout pratiquer les pointeurs.

Je vais donc analyser tout ça et bien reprendre le principe de pointeur de pointeur :)

Bonjour

Citation:

Envoyé par brody

Je vais donc analyser tout ça et bien reprendre le principe de pointeur de pointeur :)

En fait, c'est l'application brute du principe "toute fonction qui veut modifier une variable extérieure (à elle) doit recevoir l'adresse de cette variable.
Une fonction veut modifier un int ? elle recevra l'adresse de cet int qu'elle stockera dans un int étoile. Puis tous les accès à cette variable se feront au travers du pointé
Code:

1 2 3 4 5 6 7 8 void init(int *pt, int v) { (*pt)=v; } int main() { int v; init(&v, 100); }
Même exemple avec un float qui sera alors modifié via un float étoile
Code:

1 2 3 4 5 6 7 8 void init(float *pt, float v) { (*pt)=v; } int main() { float v; init(&v, 100.0); }
Donc on voit bien ici le principe général où si une fonction doit modifier un "truc", elle recevra alors l'adresse de ce truc qu'elle stockera dans un "truc étoile".

Si on l'applique maintenant à une fonction qui doit modifier un "char étoile", alors le mécanisme reste exactement le même: elle recevra l'adresse de ce "char étoile" qu'elle stockera dans un "char étoile étoile"
Code:

1 2 3 4 5 6 7 8 9 void init(char **pt, int v) { (*pt)=malloc(v * sizeof(**pt)); // Désolé foetus, je préfère mettre le sizeof pour des raisons d'esthétique et de portabilité ;) strcpy(*pt, "Salut"); } int main() { char *chaine; init(&chaine, 6); }