Discussion :

[beb1982]

Bonjour,

J'ai des diffucltés pour manipuler une structure imbriquée.
Voici mon cas :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
struct st0
{
  struct st1 *ptSt1
};
 
struct st1
{
  struct st2 *ptSt2
};
 
struct st2
{
  char *mot
};

Je souhaiterai affecter à "mot" la chaine de caratère " helloworld "

Comment faire?


Merci d'avance

[Franck.H]

Et c'est quoi le problème ? Ta chaîne se trouve où ? C'est un argument d'une fonction ? Une chaîne dynamique ? Comme tu le vois, un peu plus d'infos et de code ne ferais pas de mal !

[Beldom]

J'ai rien compris, mais voici un exemple de structure imbriquée et d'utilisation.
Je sais pas si ca correspond à ce que tu cherches, mais tu n'aides pas vraiment à t'aider ^^

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
 
 
struct third_level
{
     int i;
};
 
struct second_level
{
     struct third_level thd_lvl;
};
 
struct first_level
{
     struct second_level scd_lvl;
};
 
int main()
{
   struct first_level tmp;
 
   /*Affectons la valeur 4 à l'int dans la structure la plus basse */
 
   tmp.scd_lvl.thd_lvl.i = 4;
 
}

Si tu déclares des pointeurs vers structure (struct st1 *ptSt1), tu dois alors malloc chacune de tes structures, et les liaisons ne sont plus signifiées par des points (tmp.scd_lvl), mais des "flèches" : ->.

J'espère que cela répond à tes questions.

Edit : Vala, pour les pointeurs, tu regardes en dessous, ca doit être ca ^^

[adiekmann]

Ta question manque de clarté.
Tu attend quelque chose du genre ?

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
struct st0
{
  struct st1 *ptSt1;
};
 
struct st1
{
  struct st2 *ptSt2;
};
 
struct st2
{
  char *mot;
};

int main(int argc, char *argv[])
{
	struct st0 mystruct;

	mystruct.ptSt1 = malloc(sizeof(struct st1));
	mystruct.ptSt1->ptSt2 = malloc(sizeof(struct st2));
	mystruct.ptSt1->ptSt2->mot = strdup("helloworld");

	printf("%s\n", mystruct.ptSt1->ptSt2->mot);
	return (0);
}

Sinon attention aux points virgules
Bonne journée,

[beb1982]

merci pour toute vos réponses.

Le dernier post a répondu à ma question. J'ai fait un code similaire sans les malloc. Cela fonctionne.

Est ce que les malloc sont obligatoire?

Merci

[Franck.H]

Le dernier post a répondu à ma question. J'ai fait un code similaire sans les malloc. Cela fonctionne.

Je demande à voir ton code dans ce cas

[PsychoH13]

Si tu l'as fait sans malloc() et avec un simple pointeur, un jour ou l'autre ça va te péter à la figure...

Donc oui, montre-nous ton code stp...

[Emmanuel Delahaye]

Le dernier post a répondu à ma question. J'ai fait un code similaire sans les malloc. Cela fonctionne.

Est ce que les malloc sont obligatoire?

Comme toute variable, un pointeur doit être correctement initialisé avant d'être utilisé. Si il ne l'est pas, le comportement est indéfini. malloc() est une façon propre et cohérente d'initialiser un pointeur. Ne pas oublier que malloc() peut échouer et qu'il faut donc tester la valeur du pointeur (NULL) avant de le déréférencer.

[beb1982]

Voici mon 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
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
 
//####################
//	dans le fichier .h
 
struct _ns10__Security_USCOREAuthenticate
{
	struct _ns10__Security_USCOREAuthenticate_userIdentifier *userIdentifier;	
};
 
 
struct _ns10__Security_USCOREAuthenticate_userIdentifier
{
struct _ns10__Security_USCOREAuthenticate_userIdentifier_originIdentification *originIdentification;
	char *originatorTypeCode;	
	char *originator;	
};
 
 
struct _ns10__Security_USCOREAuthenticate_userIdentifier_originIdentification
{
	char *sourceOffice;	
};
 
 
//###################################################
int AmaOpenConversation(void *Request,void *Response)
{
       char Oid[9+1];
	char originator[30+1];
	char dutycode[2+1];
	int datalength;
	char *password;
 
  [...]
 
	struct _ns10__Security_USCOREAuthenticate ns10;
 
	struct _ns10__Security_USCOREAuthenticate_userIdentifier_originIdentification ns10originIdentification;
  struct _ns10__Security_USCOREAuthenticate_userIdentifier ns10userIdentifier;
 
	ns10originIdentification.sourceOffice=Oid;
	ns10userIdentifier.originIdentification=&ns10originIdentification;
 
	ns10userIdentifier.originatorTypeCode="U";
 
	ns10userIdentifier.originator=originator;
 
	ns10.userIdentifier=&ns10userIdentifier;
 
	printf("\naaaaa : %s", ns10.userIdentifier->originIdentification->sourceOffice);
	printf("\naaaaa : %s", ns10.userIdentifier->originatorTypeCode);
	printf("\naaaaa : %s", ns10.userIdentifier->originator);
	[...]
}

[Emmanuel Delahaye]

Voici mon code

Ce sont donc des adresses de variables locales. Tant que tu restes dans la fonction et dans le même thread, c'est OK. Si tu changes de thread ou que tu quittes la fonction, les données deviennent invalides. Le comportement est indéfini.

[beb1982]

Je n'utilise pas de thread. ouf, je n'ai pas à revoir tout mon code !

Mes donées sont bien en locale sous la forme d'une strucutre imbriqué. La profondeur des la stucutre est de 2 à 3 niveaux.
(exemple: « j'ai une stucutre "st0" qui a un pointeur qui pointe vers une première strucutre "st1". Cette denière a un pointeur qui pointe vers une autre strucure "st2" » )

J'ai encore un peu de mal avec les pointeurs et encore pire les pointeurs dans les strucutres.


Merci, pour votre aide qui m'ont grandement aidée