Discussion :

[souviron34]

et non là tu alloues la place pour un pointeur, pas pour la structure...

[Médinoc]

Si, pour la structure (sizeof *pointeur).

[crocodilex]

et non là tu alloues la place pour un pointeur, pas pour la structure...

Une petite révision s'impose. Reprends ton manuel sur le langage C.

[souviron34]

c'est possible (je ne suis pas au courant des dernières révisions)

Cependant je maintiens ma manière de faire...

D'abord ça marche (non négligeable en programmation), ensuite c'est conforme à C avant C99 (et peut-être même avant C90), enfin c'est plus clair..

Quelqu'un qui apprend le C apprend que * désigne un pointeur, et que calloc ou malloc alloue un certain nombre de bytes, fourni par les arguments (N, taille d'un élément).

Il définit une structure Triangle. Donc pour lui la taille d'un élément est sizeof(Triangle)...

Même si cela revient au même, philosophiquement il me semble plus clair de parler de "TAILLE DU TYPE" que de "TAILLE DE LA VARIABLE"..

[Médinoc]

Mais là, on parle de "TAILLE DU TYPE POINTÉ" (sizeof(*pointeur) ou sizeof *pointeur), pas de "taille de la variable"...

Et l'avantage suprême, c'est que c'est plus maintenable (un seul changement à faire si tu changes le type).

[souviron34]

ben non je ne crois pas :

Code :

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

1
2
3
4
5
6
7
 
struct _Triangle *MonTriangle=NULL ;
MonTriangle = calloc ( 1, sizeof *MonTriangle);
 
/* ou */
Triangle *MonTriangle=NULL ;
MonTriangle = calloc ( 1, sizeof *MonTriangle ) ;

sizeof(*MonTriangle) est bien la taille de la variable...

[Thierry Chappuis]

oooopppppssss t'as raison... je devais m'endormir... milles excuses...

Ce que je voulais dire c'est que le nom avant désigne le pointeur sur la structure, et que donc on peut s'en servir directement.. Si il n'y a pas de nom après, ça désigne la structure. Si il y a un nom avant ça désigne donc le pointeur sur la structure, et (contrairement à beaucoup de cours que j'ai vu sur le net) que du coup il vaut mieux lui donner un nom différent... (Ptr_Struct ou _Struct)..

Désolé encore...

???? Là, je ne suis plus du tout ?????

Thierry

[Médinoc]

ben non je ne crois pas :
sizeof(*MonTriangle) est bien la taille de la variable...

Non, c'est la taille du type pointé par MonTriangle.
Donc, la taille d'une structure _Triangle.

[crocodilex]

c'est possible (je ne suis pas au courant des dernières révisions)

Cependant je maintiens ma manière de faire...

D'abord ça marche (non négligeable en programmation), ensuite c'est conforme à C avant C99 (et peut-être même avant C90), enfin c'est plus clair..

Quelqu'un qui apprend le C apprend que * désigne un pointeur, et que calloc ou malloc alloue un certain nombre de bytes, fourni par les arguments (N, taille d'un élément).

Il définit une structure Triangle. Donc pour lui la taille d'un élément est sizeof(Triangle)...

Même si cela revient au même, philosophiquement il me semble plus clair de parler de "TAILLE DU TYPE" que de "TAILLE DE LA VARIABLE"..

Pour ce qui est du sizeof, il y a deux possibilités de faire :

sizeof VARIABLE
ou
sizeof (TYPE)

C’est au choix. Moi personnellement je préfère la première façon.

Mais bon, là n’est pas la question.
Je voulais plûtot mettre l’accent sur la façon de définir et de déclarer ta structure.
Quand tu définis une structure de la sorte :

Code :

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

1
2
3
4
5
6
7
8
 
typedef struct _Triangle { 
   int S1 ;
   int S2 ;
   int S3 ; 
   struct _Triangle *next ;
   struct _Triangle *previous ; 
} Triangle;

Et que tu fais une déclaration comme cela :

Code :

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

1
2
 
struct Triangle *MonTriangle=NULL ;

J’espère que tu es conscient que la structure pointée par MonTriangle n’a rien a voir avec la structure définie plus haut.

[Thierry Chappuis]

ben non je ne crois pas :



sizeof(*MonTriangle) est bien la taille de la variable...

Non, cela correspond à la taille de la structure pointée par la variable MonTriangle. sizeof *MonTriangle est équivalent à sizeof(struct _Triangle) tandis que sizeof(MonTriangle) est équivalent à sizeof(struct _Triangle *).

Thierry

[Thierry Chappuis]

Pour ce qui est du sizeof, il y a deux possibilités de faire :

sizeof VARIABLE
ou
sizeof (TYPE)

C’est au choix. Moi personnellement je préfère la première façon.

Mais bon, là n’est pas la question.
Je voulais plûtot mettre l’accent sur la façon de définir et de déclarer ta structure.
Quand tu définis une structure de la sorte :

Code :

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

1
2
3
4
5
6
7
8
 
typedef struct _Triangle { 
   int S1 ;
   int S2 ;
   int S3 ; 
   struct _Triangle *next ;
   struct _Triangle *previous ; 
} Triangle;

Et que tu fais une déclaration comme cela :

Code :

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

1
2
 
struct Triangle *MonTriangle=NULL ;

J’espère que tu es conscient que la structure pointée par MonTriangle n’a rien a voir avec la structure définie plus haut.

C'est sans doute une faute de frappe.

Code :

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

struct _Triangle *MonTriangle=NULL ;

ou

Code :

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

Triangle *MonTriangle=NULL ;

sont deux manières correctes de définir une variable MonTriangle de type pointeur sur structure _Triangle.

Thierry

[crocodilex]

C'est sans doute une faute de frappe.

Ce n'est pas une faute de frappe de ma part.
Si tu regarde ce post :
http://www.developpez.net/forums/sho...0&postcount=19
souviron34 met bien l'accent sur cette façon d'écrire (puisque le underscore est surligné en rouge).

[souviron34]

C'est sans doute une faute de frappe.

Code :

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

struct _Triangle *MonTriangle=NULL ;

ou

Code :

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

Triangle *MonTriangle=NULL ;

sont deux manières correctes de définir une variable MonTriangle de type pointeur sur structure _Triangle.

Thierry

Exact Thierry.. Moi c'était la deuxième utilisation...

[crocodilex]

Exact Thierry.. Moi c'était la deuxième utilisation...

C'est ce que j'avais déjà indiqué ici :
http://www.developpez.net/forums/sho...6&postcount=20

[souviron34]

Si tu veux être rassuré, Crocodilex, voici un exemple de code se servant de la structure ci-dessus :

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
 
  Triangle    *Triangles = (Triangle *)NULL ;
  Triangle    *elt = (Triangle *)NULL ;
  Triangle    *next = (Triangle *)NULL ;
 
  ......
 
	    elt = (Triangle *) calloc (1, sizeof(Triangle) );
	    if ( elt == (Triangle *)NULL )
	      {
		if ( next != (Triangle *)NULL )
		  free (next);
		return ERROR ;
	      }
	    elt->next = (Triangle *)NULL ;
	    if ( N_Triangles == 0 )
	      {
		Triangles = elt ;
		elt->previous = (Triangle *)NULL ;
	      }
	    else
	      {
		elt->previous = next ;
		elt->previous->next = elt ;
	      }
 
	    elt->S1 = (i*NAligns) + j ;
	    elt->S2 = (i*NAligns) + (j+1) ;
	    elt->S3 = ((i-1)*NAligns) + (j+1) ;
	    next = elt ;
 ......

[crocodilex]

Si tu veux être rassuré, Crocodilex, voici un exemple de code se servant de la structure ci-dessus :

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
 
  Triangle    *Triangles = (Triangle *)NULL ;
  Triangle    *elt = (Triangle *)NULL ;
  Triangle    *next = (Triangle *)NULL ;
 
  ......
 
	    elt = (Triangle *) calloc (1, sizeof(Triangle) );
	    if ( elt == (Triangle *)NULL )
	      {
		if ( next != (Triangle *)NULL )
		  free (next);
		return ERROR ;
	      }
	    elt->next = (Triangle *)NULL ;
	    if ( N_Triangles == 0 )
	      {
		Triangles = elt ;
		elt->previous = (Triangle *)NULL ;
	      }
	    else
	      {
		elt->previous = next ;
		elt->previous->next = elt ;
	      }
 
	    elt->S1 = (i*NAligns) + j ;
	    elt->S2 = (i*NAligns) + (j+1) ;
	    elt->S3 = ((i-1)*NAligns) + (j+1) ;
	    next = elt ;
 ......

Ouf....me voilà rassuré....je te remercie
J'ai bien cru que tu ne savais point définir et déclarer une structure.

Juste une petite remarque sur ce bout de code. A quoi servent tout ces cast ?

[souviron34]

Ouf....me voilà rassuré....je te remercie
J'ai bien cru que tu ne savais point définir et déclarer une structure.

Juste une petite remarque sur ce bout de code. A quoi servent tout ces cast ?

d'abord une vieille habitude.....

Quand j'ai commencé à faire du C ...euh... il y a 18 ans ... c'était une technique recommandée (car il n'était pas garanti (et je ne reviendrais sur la discussion de l'autre fil avec les très bonnes explications d'Emmanuel) que NULL soit défini de la même manière pour tous les types).

Et je trouve que visuellement, pour quelqu'un qui devra faire de la maintenance sur le code, ça rappelle en permanence de quoi on s'occupe... Bon oui c'est inutile... Mais on se refait pas ...

[Médinoc]

J'ai tendance également à caster NULL pour lui donner un type fort, mais dans ce cas je conseille l'utilisation d'un define :

Code :

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

#define NULL_TRI ((Triangle *)NULL)

[souviron34]

J'ai tendance également à caster NULL pour lui donner un type fort, mais dans ce cas je conseille l'utilisation d'un define :

Code :

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

#define NULL_TRI ((Triangle *)NULL)

Je pense que ça c'est affaire de goût.. Personnellement je ne suis pas trop chaud pour ça pour 2 raisons :

1) le cast existe ... Et comme on ne vas pas refaire des #define CAST_INT etc... ou que dans une opération mathématique on met directement le cast (style " d = a * (double)i "), je préfère garder l'homogénéité et le cast "in line"..

2) j'ai eu affaire il y a une 10 années (et d'ailleurs je vais peut-être me le recolletiner bientôt (maintenance) ) un code assez spaghetti, avec des #define func ( ) dans les .h, et ça m'a pas mal refroidi sur les define.

En gros je ne me sert des define que pour :

1) des constantes "métier" (exemple T_ZERO_KELVIN)
2) définir des zones à compiler différemment suivant les OS
3) éventuellement lors d'un gros DEBUG mettre en commentaires des zones de code.

[Médinoc]

En effet, le cast existe. Mais je préfère les centraliser, car si jamais on décide de changer le type d'un objet, il faut changer tous les casts.
Et ça, ce n'est pas toujours facile, surtout en où les casts ne sont pas introduits par un préfixe immanquable...

D'ailleurs, ce define est juste pour NULL (qui est une constante), pas pour une macro qui agit sur un objet.