Discussion :

[Fred.77]

Bonjour à tous et à toutes ,





Je vais faire simple , j'ai des variables défnis dans une structure et je souhaite y accéder :

en C++ ça ressemble a ça :

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
class cFred {
private:
 
 int ,m,y,z;
protected:
  char  A, B, C, D, J;
  int mon_entier;
 
 
  void  stylo (void);
  void table(byte *a, byte *i1, byte *i2);
  bool crayon(int f, unsigned char *d, int m);
public:
  cFred(void);
  };

en C :

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
 
typedef struct Fred
 
{
 
  int ,m,y,z;
  char  A, B, C, D, J;
  int machin;
 
}Fred;
 
 
  void  stylo (void);
  void table(byte *a, byte *i1, byte *i2);
  int crayon(int f, unsigned char *d, int m);

ce que je souhaite faire cest d'accéder aux variables défnis dans la classe Fred .

en C

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
void Fred_table ( )
 
 
{}
 
 
void Fred_stylo ()
{}
 
 
void Fred_crayon ()
 
{}

en C++ c'est sous cette forme :

Code :

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

1
2
3
4
5
6
7
 
void Fred::stylo ()
{}
void Fred::crayon ()
{}
void Fred::table ()
{}

stylo , crayon et table hérite de la structure de Fred , tout ce qui est déclarer dans la structure sera héritée .


je me suis basé sur cet article pour adapter cet éhritage en C
http://chgi.developpez.com/c/heritage/


Merci pour vos différents conseils et suggéstions .

[diogene]

Si tu veux faire un parallèle avec le code C++, tes fonctions C doivent explicitement rétablir le paramètre formel caché this

Code :

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

1
2
3
  void  stylo (Fred * fred);
  void table(Fred * fred,byte *a, byte *i1, byte *i2);
  int crayon(Fred * fred,int f, unsigned char *d, int m);

Les fonctions Fred_table et compagnie n'ont pas lieu d'être ( ou remplacent les premières si tu préfères ces noms)

[Fred.77]

Bonsoir diogene ;

merci pour ton conseil , j'ai longuement lis les différents articles postés sur le site .


Ce que je souhaite c'est d'accéder aux variables sans avoir a les (RE) déclarer

par exemple dans ton code tu cites

Code :

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

1
2
 
int crayon(Fred * fred,int f, unsigned char *d, int m);

la je souhaite utilisé A, B, C, D, J;
et m,y,z; qui sont déja déclaré dans la classe Fred .

Est ce que je pourrais y accéder avec les paramétres indiqués ?

[diogene]

Code :

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

int crayon(Fred * fred,int f, unsigned char *d, int m);

la je souhaite utilisé A, B, C, D, J;
et m,y,z; qui sont déja déclaré dans la classe Fred .

Tu peux utiliser les membres de Fred dans la fonction puique tu passe l'adresse de l'instance de Fred en paramètre :

Code :

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

fred->m = m;

[PsychoH13]

J'ai l'impression que tu n'as pas bien compris ce que signifiait "héritage".
En C++, et dans tous les autres langages objets, une classe hérite d'une autre, donc déjà c'est forcément deux classes, là tu ne parles que d'une seule classe.
Quand on dit qu'une classe hérite d'une autre classe, la classe "fille" hérite de toutes les variables d'instance et de classe ainsi que toutes ses méthodes d'instance et de classe.
La classe "fille" aura accès direct à toutes les variables/méthode d'instance/de classe de la classe mère qui seront protected ou public.

Exemple :

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
class mere
{
private:
    int m1(void);
    int i;
protected:
    int j;
    int m2(void);
public:
    int k;
    int m3(void);
}
 
class fille
{
private:
    void methode_test(void);
public:
    void autre_methode(void);
}
 
fille::methode_test(void)
{
    i = 0; // erreur
    int var = m1(); // erreur
    j = 0; // juste
    var = m2(); // juste
    k = 0; // juste
    var = m3(); // juste
}
 
fille::autre_methode()
{
    methode_test(); // juste
}

En C++, une variable ou une méthode précédé du terme private n'est accessible que depuis les méthodes de la classe elle-même.
Dans le cas de protected, seul les objets de la classe et de ses sous-classes peuvent y accéder.
Dans le cas de public, tout le programme peut accéder aux variables et aux méthodes.

En général, une variable d'instance ou de classe est privée, et une méthode d'instance ou de classe et publique.

En C, toutes les fonctions sont publiques et tous les membres d'une structure sont publique...
Il est cependant possible de rendre privé tous les attributs d'une structure en ne dévoilant pas sa forme dans un .h, ça revient à créer un type opaque avec des fonctions publiques permettant d'allouer et supprimer des objets du type opaque.
De même pour les fonctions, on peut les rendre "privée" si on masque leur prototype.

[Fred.77]

Bonsoir PsychoH13;

Merci beaucoup pour ce complément d'informations et ta disponibilité ,

ce que je vouderais faire c'est à partir d'une classe cFred accéder aux variables déclarées dans cette classe .

Code :

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

1
2
3
4
5
6
7
 
 void cFred::Stylo (){}
 
stylo hérite de la classe cFred.
 void cFred::crayon (){}
 
crayon hérite de la classe cFred .

Donc ,

Code :

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

1
2
3
4
5
6
7
 
 void cFred:::crayon ()
 
{
m=1:     //on a pas besoin de le (RE) déclarer puisque m est déclaré dans la classe cFred 
 
}

Je souhaite faire ça en langage C .

Créer une STRUCTURE cFred , ensuite déclarer les variables

Code :

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

1
2
3
4
5
6
7
8
 
 
struct cFred
{
int m,y,z;
char  A, B, C, D, J;
 
}cFred;

et y accéder par la suite :

Code :

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

1
2
3
4
5
6
7
8
 
void cFred_stylo ()
 
{ 
  A=1;            // A déclarer dans la structure cFred
 B=2;            // B déclarer dans la structure cFred
 
}

je souhaite que _Stylo, __Crayon, __table héritent de la structure cFred .


j'utilise cFred__stylo au lieu d'utiliser cFred::stylo .



Merci pour vos conseils .

[diogene]

Dans le document que tu cites sur l'héritage en C, tu remarqueras que les "fonctions membres" sont remplacées par des pointeurs sur fonctions (par exemple Stylo) dans la structure initialisés par des adresses de fonctions (ayant un argument représentant this) (par exemple cFred__stylo). L'accès à ces fonctions se fait via les pointeurs par un appel du style

Code :

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

this->Stylo(this,...)

Jusqu'à présent et sauf erreur de ma part, tu ne nous a pas présenté une telle construction.

[PsychoH13]

Déjà on ne parle pas de classe en C, ça n'existe pas.
Ensuite, quand tu veux accéder aux champs d'une structure, dans une fonction, il suffit que la fonction ait connaissance de la structure.
Comment faire cela ?
Deux choses, il faut déjà que la fonction ait accès la définition de la structure, soit la structure est défini dans le même fichier que la fonction, ou alors la structure est définie dans un fichier inclut par celui contenant la fonction.

Deuxième chose, il faut que la fonction ait accès à une variable du type de la structure. Il y a 3 façons : variable globale (déconseillé), variable locale et argument. Donc comme te l'a montré diogene il suffit de mettre ta structure en paramètre.

Voilà ce que ça donne par exemple :

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
typedef struct Point
{
    int x, y;
} Point;
 
typedef struct Taille
{
    int largeur, hauteur;
} Taille;
 
typedef struct Rectangle
{
    Point origine;
    Taille taille;
} Rect;
 
// Cette fonction va vérifier qu'un point se trouve dans un rectangle
int PointInsideRect(Point p, Rect r)
{
    return (p.x >= r.origine.x && p.x <= r.origine.x + r.taille.largeur &&
            p.y >= r.origine.y && p.y <= r.origine.y + r.taille.hauteur);
}

Sachant que l'origine du rectangle est son coin inférieur gauche.
Tu peux voir que la fonction PointInsideRect() a accès aux champs des objets p et r qui sont des types structures. Mais pour cela il faut que tu en donnes l'accès en les passant en paramètre.

[PsychoH13]

Code :

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

1
2
3
4
5
6
7
 
 void cFred::Stylo (){}
 
stylo hérite de la classe cFred.
 void cFred::crayon (){}
 
crayon hérite de la classe cFred .

Ça ce N'est PAS de l'héritage ! L'opérateur :: c'est l'opérateur de résolution de portée. Ça signifie en C++, que Stylo() est une méthode de la classe cFred ou alors se trouve définie dans le namespace cFred. Ce n'est pas de l'héritage

L'héritage c'est ça

Code :

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

1
2
3
4
5
6
class Mere { /*...*/};
 
class Fille: public Mere
{
    // Fille hérite de Mere.
};

[Fred.77]

Merci à vous deux pour vos conseils et votre disponibilité je vais mettre ça en pratique pendant toute la soirée et je vous informerait des résultats demain .

Bonne soirée et merci à vous PsychoH13 et diogene

[Fred.77]

AH d'accord j'ai pensé que s'était de l'héritage !

En langage C , pour qu'une focntion void stylo () bénéficie de la structure cFred

et des variables comment doit on y procéder ?

[diogene]

Passer un pointeur sur la structure en argument (l'équivalent de this)
voir réponse #4

[PsychoH13]

AH d'accord j'ai pensé que s'était de l'héritage !

En langage C , pour qu'une focntion void stylo () bénéficie de la structure cFred

et des variables comment doit on y procéder ?

Ça fait 3 fois qu'on le dit !

Code :

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

1
2
3
4
5
6
7
8
9
10
void maFonction(cFred *ptr)
{
    // modification de ptr
}
 
int main(void)
{
    cFred monFred;
    maFonction(&monFred); // en C++ ça donnerait : monFred.maFonction()
}