Pointeur sur les éléments d'une structure

salut à tous et à toutes ;


Tout est dans le titre , j'ai une structure Marley_t et je souhaite y accéder aux éléments de cette structure .

Code:

---

1 2 3 4 5

typedef struct mastructure_s { int x, y, A,B,C,D,E;   }Marley_t;

---

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14

int fonction ( void)   {   Marley_t *pointeur; // je créer un pointeur pour ma structure     BN_set_bit(pointeur->x,64); // ensuite j'essaye de pointer vers x BN_mod_inverse(pointeur->J,pointeur->J,pointeur->y); BN_set_bit(pointeur->J,pointeur->x);     }

---

Lorsque je compile :
<function argument>: implicit cast of non-0 int to pointer


Par contre en utilisant un this ça marche sans probléme .

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12

int fonction ( Marley_t * this )   {   BN_set_bit( &this->x,64); // ensuite j'essaye de pointer vers x BN_mod_inverse(&this->J, &this->J, &this->y); BN_set_bit(&this->J, &this->A, &this->x);     }

---

Lorsque je compile : - 0 error(s), 0 warning(s)

Merci d'apporter vos différents conseils et suggéstions par rapport à l'utilisation d'un this pour pointer vers les éléments d'une structure .

Citation:

---

Envoyé par Marley_T

Tout est dans le titre , j'ai une structure Marley_t et je souhaite y accéder aux éléments de cette structure .
<...>
Merci d'apporter vos différents conseils et suggéstions par rapport à l'utilisation d'un this pour pointer vers les éléments d'une structure .

---

this est un identificateur comme un autre en C. Il n'a pas de propriétés particulières.

Le premier code est faux pour de nombreuses raisons, la plus évidente est que le pointeur n'est pas initialisé. Ensuite, dans le 2 cas, il n'y a pas de membre nommé J...

Il faut le passer en paramètre et utiliser la même syntaxe qu'avec this (seul le nom du pointeur change).

Code:

---

1 2 3 4 5 6 7

int fonction (Marley_t * pointeur) { BN_set_bit (&pointeur->x, 64); // ensuite j'essaye de pointer vers x BN_mod_inverse (&pointeur->x, &pointeur->A, &pointeur->y); BN_set_bit (&pointeur->A, &pointeur->x); }

---

(j'ai mis A au pif, à la place de J qui n'existe pas).

Code:

---

BN_set_bit( &this->x,64);

---

Puisque pas d'erreur => la fonction BN_set_bit, attend un pointeur comme premier argument, or dans

Code:

---

1 2 3 4

int fonction ( void) { Marley_t *pointeur; // je créer un pointeur pour ma structure BN_set_bit(pointeur->x,64); // ensuite j'essaye de pointer vers x

---

on lui donne un entier comme argument! pointeur->x n'est pas un pointeur mais la valeur du champ x de la structure (un int).

idem pour BN_mod_inverse

A noter : dans cette fonction pointeur n'est pas initialisé.

Citation:

---

Envoyé par Emmanuel Delahaye

this est un identificateur comme un autre en C. Il n'a pas de propriétés particulières.

Le premier code est faux pour de nombreuses raisons, la plus évidente est que le pointeur n'est pas initialisé. Ensuite, dans le 2 cas, il n'y a pas de membre nommé J...

Il faut le passer en paramètre et utiliser la même syntaxe qu'avec this (seul le nom du pointeur change).

en cours ...

---

bonjour Emmanuel Delahaye ;


J'ai pris en considération tout ce que vous m'avez dit et voici le nouveau code

Code:

---

1 2 3 4 5 6

typedef struct mastructure_s { int x, y, A,B,C,D,E, J ;   }Marley_t;

---

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

int fonction ( void)   {     Marley_t *pointeur; // Pointeur vers structure Marley_t pointeur = &Marley_t; // j'initialise le pointeur vers la structure     BN_set_bit(pointeur->x,64); // ensuite j'essaye de pointer vers x BN_mod_inverse(pointeur->J,pointeur->J,pointeur->y); BN_set_bit(pointeur->J,pointeur->x);     }

---

Citation:

---

Envoyé par Marley_T

...

Code:

---

1 2 3 4 5 6

typedef struct mastructure_s { int x, y, A,B,C,D,E, J ;   }Marley_t;

---

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12

int fonction ( void) { Marley_t *pointeur; // Pointeur vers structure Marley_t pointeur = &Marley_t; // j'initialise le pointeur vers la structure     BN_set_bit(pointeur->x,64); // ensuite j'essaye de pointer vers x BN_mod_inverse(pointeur->J,pointeur->J,pointeur->y); BN_set_bit(pointeur->J,pointeur->x);   }

---

---

et c'est toujours faux, car ton pointeur ne pointe pas sur une structure, mais sur un pointeur qui est du type Marley_t *, mais pas sur une variable...

Ton typedef ne definit pas une varaible, mais une structure...

Code:

---

1 2 3 4 5 6 7 8 9 10 11

int fonction ( void) { Marley_t *pointeur, MaStruct; // Pointeur vers structure Marley_t pointeur = &MaStruct; // j'initialise le pointeur vers la structure     BN_set_bit(pointeur->x,64); // ensuite j'essaye de pointer vers x BN_mod_inverse(pointeur->J,pointeur->J,pointeur->y); BN_set_bit(pointeur->J,pointeur->x);   }

---

Citation:

---

Envoyé par Marley_T

J'ai pris en considération tout ce que vous m'avez dit et voici le nouveau code
<...>

Code:

---

1 2 3 4 5

int fonction ( void) { Marley_t *pointeur; // Pointeur vers structure Marley_t pointeur = &Marley_t; // j'initialise le pointeur vers la structure

---

---

T'as appris le C en lisant les blagues Caram'bar ? Sans dec' tu crois que prendre l'adresse d'un type, ça a un sens quelconque ? Faut arrêter la fumette... Le C c'est pas pour les bricoleurs. Ca s'apprend et il faut du temps et beaucoup de pratique.

Il y a des références de tutoriels et de livres sur ce site (et le mien).

Merci à vous tous Emmanuel , souviron34 , diogene je vais voir si j'ai plus d'erreurs lorsque je compile .

http://bien-programmer.blogspot.com/
http://emmanuel-delahaye.developpez.com/

RE -

Code:

---

1 2 3 4 5 6 7 8 9

typedef struct Marley_s { int x,y, A ;   }Marley_t;     Marley_t *ptr;

---

Code:

---

1 2 3 4 5 6 7

int fonction (Marley_t * ptr) {   BN_mod_inverse (&ptr->x, &ptr->A, &ptr->y);   }

---

0 error(s), 0 warning(s)

Suite aux différents conseils ce code au dessus est CORRECT est sans erreurs


La Quéstion :
Y'a t'il une autre méthode pour accéder aux éléments de la structure à part un this ?

Citation:

---

Envoyé par Marley_T

Suite aux différents conseils ce code au dessus est CORRECT est sans erreurs

La Quéstion :
Y'a t'il une autre méthode pour accéder aux éléments de la structure à part un this ?

---

C'est quoi un 'this' pour toi ? Je n'en vois pas dans ce code.

Ce qui m'inquiète, c'est de voir un pointeur non initialisé,

Code:

---

Marley_t *ptr;

---

mais bon, on a pas tout le code...

Emmanuel Delahaye ;


La Stucture Marley_t

Code:

---

1 2 3 4 5

typedef struct {   }Marley_t;

---

Les Variables de la structure :

Code:

---

int x,y, A ;

---

Le pointeur vers la structure :

Marley_t * p;


La fonction incluant le pointeur vers la structure Marley_t :

Code:

---

1 2 3 4 5 6

int fonction (Marley_t * p) {     }

---

Fonctions de la bibliothéque BiGNumbers Library qui prends 3 paramétres dans la fonction .

Code:

---

BN_mod_inverse

---

Utilisation de la fonction BN_mod_inverse avec 3 paramétres dans la fonction

Code:

---

1 2	BN_mod_inverse (&p->x, &p->y, &->A);

---

Comme dit précédemment, ton pointeur n'a pas l'air initialisé, de plus, tu as l'air de le déclarer en tant que variable globale (et c'est mal).

Reprenons, tu as ta structure

Code:

---

1 2 3 4 5 6

typedef struct { int x; int y; int A; } Marley_t;

---

Dans une fonction en amont de celle que tu appelles fonction(), tu dois, je pense créer une variable qui est de type Marley_t.

Cela se déclare de la sorte :

Code:

---

1 2	Marley_t var; /* + initialisation des elements de la structure, sans doute */

---

ou bien,

Code:

---

1 2 3 4 5

Marley_t *ptr;   if ((ptr = malloc(1 * sizeof(*ptr))) == NULL) return (-1); /* Par exemple */ /* + initialisation des elements de la structure, sans doute */

---

Ensuite tu passes cette variable a ta fonction fonction() :

Prototypée visiblement de la sorte :

Code:

---

int fonction (Marley_t *p);

---

Tu lui passes (à partir de la fonction en amont) un pointeur sur une structure Marley_t.

Si tu as déclaré ta structure "en dur", tu lui passes comme ceci (avec retour un entier déclaré au préalable) :

Code:

---

retour = fonction(&var);

---

ou bien si tu as déclaré un pointeur (ou par exemple si ta structure a été déclarée plus haut dans ton code), comme ceci :

Code:

---

retour = fonction(ptr);

---

Ensuite, le passage a la fonction BN_mod_inverse (int *, int *, int *) :

Code:

---

1 2 3 4 5

int fonction (Marley_t *ptr) { BN_mod_inverse (&ptr->x, &ptr->y, &ptr->A); return (0); }

---

Voila (c).

Tusbar , Trés Bonne idée .

C'est intéressant parceque si on utilise 150 fonctions il suffit d'ajouter dans les paramétres de la fonctions le pointeur de la structure Marley_t .

Illustration :


Une structure :


typdef struct

{

int A, B,C ;

}Marley_t;

Marley_t *p;

Code:

---

1 2 3 4 5 6

void fonction1 (Marley_t *p)   { BN_mod_inverse (&A->x, &->B, &ptr->C); }

---

Code:

---

1 2 3 4 5 6

void fonction2 (Marley_t *p)   { BN_mod_inverse (&A->x, &->B, &ptr->C); }

---

Code:

---

1 2 3 4 5 6

void fonction3 (Marley_t *p) { BN_mod_inverse (&A->x, &->B, &ptr->C); }

---

Code:

---

1 2 3 4 5 6

void fonction4 (Marley_t *p) { BN_mod_inverse (&A->x, &->B, &ptr->C); }

---

Code:

---

1 2 3 4 5 6

void fonction5 (Marley_t *p) { BN_mod_inverse (&A->x, &->B, &ptr->C); }

---

Code:

---

1 2 3 4 5 6

void fonction6 (Marley_t *p) { BN_mod_inverse (&A->x, &->B, &ptr->C); }

---

Code:

---

1 2 3 4 5 6

void fonction7 (Marley_t *p) { BN_mod_inverse (&A->x, &->B, &ptr->C); }

---

Ca m'as l'air beaucoup plus simple comme ça , et le code est plus présentable comme disait Emmanuel DelaHaye .

Citation:

---

Envoyé par Marley_T

Ca m'as l'air beaucoup plus simple comme ça

---

Euh, c'est quoi l'intérêt de recopier 7 fois le même code ?

Bonsoir Emmanuel Delahaye ,

Il éxiste des projets en langage C qui comporte plus de 50 fonctions
Emmanuel .

Dans l'exemple dont vous parler , j'ai illustrer par un Copier Coller des 7 fonctions pour dire qu'on pourras utiliser autant de fonctions qu'on veut dans un projet en C et suffit d'y ajouter
le pointeur de la structure dans chaque fonction ajouter .


Je pourrais peu étre me tromper , mais c'est à vous de me corriger si je me trompe Emmanuel DelaHaye .

au risque de me repeter, ceci :

Code:

---

1 2 3 4 5 6 7 8 9

typdef struct {   int A, B,C ;   }Marley_t;   Marley_t *p;

---

ne defini pas une structure....

Mais une variable de type "pointeur sur une structure de type Marley_t"..


Ce qui ne t'avance pas beaucoup, tant que tu n'as pas de variable sur laquelle pointer...

Donc, soit tu fais de l'allocation dynamique, soit statique, mais dans ce cas il faut alors le preciser :

soit

Code:

---

p = malloc ( sizeof(Marley_t) );

---

soit

Code:

---

1 2	Marley_t MaStruct ; Marley_t *p = &MaStruct ;

---

Et pour ce qui est de tes 7 exemples, c'est pas complique, c'est le principe meme des pointeurs.

Comme dis Emmanuel, tu ouvrirais un livre de C au lieu du hasard, ca marcherait mieux...

Citation:

---

Envoyé par Marley_T

Il éxiste des projets en langage C qui comporte plus de 50 fonctions

---

Oui, les projets industriels sur lesquels j'ai travaillé pendant 17 ans comportaient des dizaines de blocs fonctionnels, des centaines de fichiers milliers de fonctions et des millions de lignes de code...

Citation:

---

Dans l'exemple dont vous parler , j'ai illustrer par un Copier Coller des 7 fonctions pour dire qu'on pourras utiliser autant de fonctions qu'on veut dans un projet en C et suffit d'y ajouter
le pointeur de la structure dans chaque fonction ajouter .

---

2 fonctions auraient suffit pour illustrer le propos...

Je te conseille de lire ceci, ça devrait concrétiser ta pensée bouillonnante :

http://emmanuel-delahaye.developpez.com/tad.htm

Citation:

---

Envoyé par Emmanuel Delahaye

Je te conseille de lire ceci, ça devrait concrétiser ta pensée bouillonnante :

---

;):chin: