Empêcher l'accès aux données d'un struct

TSalm <tsalm@free.fr> writes:

Bonjour,

Voici une petite question de noob motivé.
Venant du monde de la POO, j'ai démarrer un pgm en C avec un struct
qui contient les données, et des fonctions qui s'appliquent à ce
struct.
Par exemple, dans le header, j'ai ceci :
/* ---------- HEADER ---------- */
typedef struct
(int data1
,int data2
) MonStruct;

void MonStruct_create();
void MonStruct_free(MonStruct*);
void MonStruct_fait_quelquechose(MonStruct*,int data);
/* -------------------------- */

Mon problème est que les données("data1" et "data2") de "MonStruct"
pourraient être, par inadvertance (ou plutôt feignantise ;-) ),
directement modifiées sans passer par les fonctions.
Est-il possible de pouvoir déclarer les données "data1" et "data2"
dans l'implémentation (le fichier ".c"), de façon à ce que
l'utilisation de MonStruct ne puisse se faire qu'en passant par les
fonctions ?

D'avance merci pour vos avis ou éventuelles remarques.

Non. Et oui.


/* ---------- MonObjet.h ---------- */
#ifndef MonObjet_h
#define MonObjet_h

typedef void* MonObjet;

extern MonObjet MonObjet_new();
extern void MonObjet_free(MonObjet this);
extern void MonObjet_fait_quelquechose(MonObjet this,int data);

#endif
/* -------------------------------- */


/* ---------- MonObjet.c ---------- */
#include <MonObjet.h>

typedef struct {
int slot1;
int slot2;
} MonObjet_implementation;


MonObjet MonObjet_new()
{
MonObjet_implementation* that=malloc(sizeof(*that));
if(that){
that->slot1=0;
that->slot2=0;
return((MonObjet)that);
}else{
perror("malloc");
exit(1);
}
}


void MonObjet_free(MonObjet this)
{
MonObjet_implementation* that=(MonObjet_implementation*)this;
/* (appeler ici les methodes free des slots si nécessaire) */
free(that);
}

void MonObjet_fait_quelquechose(MonObjet this,int data)
MonObjet_implementation* that=(MonObjet_implementation*)this;
that->slot1=that->slot2;
that->slot2Úta;
}

/* -------------------------------- */
--
__Pascal Bourguignon__ http://www.informatimago.com/
A bad day in () is better than a good day in {}.

TSalm <tsalm@free.fr> writes:

Merci pour cette réponse tout à fait intéressante.
Par contre, ça oblige à faire un cast au début de chaques
fonctions. Est-ce que ça ne risque pas de ralentir l'exécution de
cette fonction ?

Non.

Autre question, pourquoi utiliser "extern" pour les prototypes de
fonctions ? Est-ce une recommandation pour garder une compatibilité
avec certains compilateurs ?

Je ne suis pas au courrant des derniers standard. Je ne vois pas
pourquoi ils renonceraient à la déclaration extern.


--
__Pascal Bourguignon__ http://www.informatimago.com/
A bad day in () is better than a good day in {}.

Voici une petite question de noob motivé.
Venant du monde de la POO, j'ai démarrer un pgm en C avec un struct
qui contient les données, et des fonctions qui s'appliquent à ce
struct.
Par exemple, dans le header, j'ai ceci :
/* ---------- HEADER ---------- */
typedef struct
(int data1
,int data2
) MonStruct;

void MonStruct_create();
void MonStruct_free(MonStruct*);
void MonStruct_fait_quelquechose(MonStruct*,int data);
/* -------------------------- */

Mon problème est que les données("data1" et "data2") de "MonStruct"
pourraient être, par inadvertance (ou plutôt feignantise ;-) ),
directement modifiées sans passer par les fonctions.
Est-il possible de pouvoir déclarer les données "data1" et "data2"
dans l'implémentation (le fichier ".c"), de façon à ce que
l'utilisation de MonStruct ne puisse se faire qu'en passant par les
fonctions ?

D'avance merci pour vos avis ou éventuelles remarques.

Non. Et oui.


/* ---------- MonObjet.h ---------- */
#ifndef MonObjet_h
#define MonObjet_h

typedef void* MonObjet;

extern MonObjet MonObjet_new();
extern void MonObjet_free(MonObjet this);
extern void MonObjet_fait_quelquechose(MonObjet this,int data);

#endif
/* -------------------------------- */


/* ---------- MonObjet.c ---------- */
#include <MonObjet.h>

typedef struct {
int slot1;
int slot2;
} MonObjet_implementation;


MonObjet MonObjet_new()
{
MonObjet_implementation* that=malloc(sizeof(*that));
if(that){
that->slot1=0;
that->slot2=0;
return((MonObjet)that);
}else{
perror("malloc");
exit(1);
}
}


void MonObjet_free(MonObjet this)
{
MonObjet_implementation* that=(MonObjet_implementation*)this;
/* (appeler ici les methodes free des slots si nécessaire) */
free(that);
}

void MonObjet_fait_quelquechose(MonObjet this,int data)
MonObjet_implementation* that=(MonObjet_implementation*)this;
that->slot1=that->slot2;
that->slot2Úta;
}

/* -------------------------------- */

Merci pour cette réponse tout à fait intéressante.
Par contre, ça oblige à faire un cast au début de chaques fonctions.
Est-ce que ça ne risque pas de ralentir l'exécution de cette fonction ?
Autre question, pourquoi utiliser "extern" pour les prototypes de
fonctions ? Est-ce une recommandation pour garder une compatibilité avec
certains compilateurs ?
ps: Je viens de voir que je m'étais planté dans la déclaration de mon
struct, dsl.

"Pascal J. Bourguignon" wrote:

typedef void* MonObjet;

extern MonObjet MonObjet_new();
extern void MonObjet_free(MonObjet this);
extern void MonObjet_fait_quelquechose(MonObjet this,int data);

Y a-t-il une raison particulière de passer par un void*? On peut tout à
fait déclarer une struct sans la définir sur place, et ça n'empêche pas
d'utiliser des pointeurs vers elle.

Le 28/01/2012 17:39, TSalm a écrit :

Bonjour,

Mon problème est que les données("data1" et "data2") de "MonStruct"
pourraient être, par inadvertance (ou plutôt feignantise ;-) ),
directement modifiées sans passer par les fonctions.
Est-il possible de pouvoir déclarer les données "data1" et "data2" dans
l'implémentation (le fichier ".c"), de façon à ce que l'utilisation de
MonStruct ne puisse se faire qu'en passant par les fonctions ?

Tu peux te débrouiller en rendant opaque le contenu de MonStruct pour
l'utilisateur en utilisant la compilation conditionnelle. Je te propose
de faire ainsi (en gros)


Monstruct.h:
----8<-----------------------------------------8<---------------------
#ifndef MONSTRUCT_H
#define MONSTRUCT_H

typedef struct MonStruct_internal {
int data1;
int data2;
}

typedef struct
#ifdef MONSTRUCT_INTERNAL
MonStruct_internal
#else
{const char opaque[sizeof(struct MonStruct_internal)];}
#endif
Monstruct;

#endif //MONSTRUCT_H
MonStruct;

extern Monstruct* MonStruct_create(int data1);
extern void MonStruct_free(MonStruct*);
extern void MonStruct_fait_quelquechose(MonStruct*,int data);
----8<-----------------------------------------8<---------------------

Monstruct.c:
----8<-----------------------------------------8<---------------------
#include <les machins standards>

#define MONSTRUCT_INTERNAL
#include "Monstruct.h"
Monstruct* MonStruct_create(int data1) {
Monstruct* resultat = malloc(sizeof(Monstruct));
if(resultat==NULL) {... traitement "plus de mémoire"...}
resultat->data1 = data1; // accès aux chose interne
resultat->data2 = 0;
}
void MonStruct_fait_quelquechose(MonStruct* ptr,int data) {
ptr->data2 += data - ptr->data1;
}
----8<-----------------------------------------8<---------------------

utilisateur.c:
----8<-----------------------------------------8<---------------------
#include <les machins standard>
#include "Monstruct.h"

void code(Monstruct *p) {
p->opaque = ???? // en fait on ne sait rien de ce
// qu'il y a dans "opaque" Il faut
// passer par les fonctions Monstruct_*()
MonStruct_fait_quelquechose(p, 42);
}
----8<-----------------------------------------8<---------------------

Bon c'est l'idée. Tu peux varier à l'infini ou presque.

sam.

Marc <marc.glisse@gmail.com> writes:

"Pascal J. Bourguignon" wrote:

typedef void* MonObjet;

extern MonObjet MonObjet_new();
extern void MonObjet_free(MonObjet this);
extern void MonObjet_fait_quelquechose(MonObjet this,int data);

Y a-t-il une raison particulière de passer par un void*? On peut tout à
fait déclarer une struct sans la définir sur place, et ça n'empêche pas
d'utiliser des pointeurs vers elle.

Pour ce que j'en sais, il faut finir par définir ces structures. C'est
ce que l'on veut éviter.


--
__Pascal Bourguignon__ http://www.informatimago.com/
A bad day in () is better than a good day in {}.

"Pascal J. Bourguignon" wrote:

Marc <marc.glisse@gmail.com> writes:

"Pascal J. Bourguignon" wrote:

typedef void* MonObjet;

extern MonObjet MonObjet_new();
extern void MonObjet_free(MonObjet this);
extern void MonObjet_fait_quelquechose(MonObjet this,int data);

Y a-t-il une raison particulière de passer par un void*? On peut tout à
fait déclarer une struct sans la définir sur place, et ça n'empêche pas
d'utiliser des pointeurs vers elle.

Pour ce que j'en sais, il faut finir par définir ces structures. C'est
ce que l'on veut éviter.

On la définit dans le fichier .c, qui n'est pas visible par l'utilisateur.

Enfin en tout cas j'ai l'impression que "pimpl" est la réponse à la
question d'origine.

Une typo s'est glissée... un détail mineur qui n'entache pas le principe.

Monstruct.h:
----8<-----------------------------------------8<---------------------
#ifndef MONSTRUCT_H
#define MONSTRUCT_H

typedef struct MonStruct_internal {
int data1;
int data2;
}

typedef struct
#ifdef MONSTRUCT_INTERNAL
MonStruct_internal
#else
{const char opaque[sizeof(struct MonStruct_internal)];}
#endif
Monstruct;

Il faut déplacer cette ligne à la fin:

#endif //MONSTRUCT_H

Et celle là n'a rien à faire dans le fichier (elle est déjà présente au
dessus):

MonStruct;

extern Monstruct* MonStruct_create(int data1);
extern void MonStruct_free(MonStruct*);
extern void MonStruct_fait_quelquechose(MonStruct*,int data);
----8<-----------------------------------------8<---------------------

L'idée est que si MONSTRUCT_INTERNAL est défini ou pas on a pas la
même définiton de MonStruct.

- pour l'utilisateur:
typedef struct {const char opaque[la taille de la struct];} MonStruct;

- pour le developpeur:
typedef struct MonStruct_internal MonStruct;

sam.

Bonjour,

TSalm scripsit :

Venant du monde de la POO, j'ai démarrer un pgm en C avec un struct qui
contient les données, et des fonctions qui s'appliquent à ce struct.
Par exemple, dans le header, j'ai ceci :
/* ---------- HEADER ---------- */
typedef struct
(int data1
,int data2
) MonStruct;

void MonStruct_create();
void MonStruct_free(MonStruct*);
void MonStruct_fait_quelquechose(MonStruct*,int data);
/* -------------------------- */

Mon problème est que les données("data1" et "data2") de "MonStruct"
pourraient être, par inadvertance (ou plutôt feignantise ;-) ),
directement modifiées sans passer par les fonctions.
Est-il possible de pouvoir déclarer les données "data1" et "data2" dans
l'implémentation (le fichier ".c"), de façon à ce que l'utilisation de
MonStruct ne puisse se faire qu'en passant par les fonctions ?

Oui, il n'y a que peu de choses à changer à ton code.

/* ---------- HEADER ---------- */
typedef struct MonStruct MonStruct; /* hop */

void MonStruct_create();
void MonStruct_free(MonStruct*);
void MonStruct_fait_quelquechose(MonStruct*,int data);
/* -------------------------- */

/* ----- implémentation ----- */
struct MonStruct {
int data1;
int data2;
};

/* définitions de fonctions inchangées */
/* -------------------------- */

C'est ce qu'on appelle une structure opaque il me semble. J'imagine que
c'est pour permettre ce genre de choses que le standard spécifie que
« All pointers to structure types shall have the same representation and
alignment requirements as each other. »

--
Manuel Pégourié-Gonnard - http://people.math.jussieu.fr/~mpg/

Marc scripsit :

Enfin en tout cas j'ai l'impression que "pimpl" est la réponse à la
question d'origine.

Ah bah voilà, du coup mon message est redondant. Je savais pas qu'on
disait aussi "pimpl".

--
Manuel Pégourié-Gonnard - http://people.math.jussieu.fr/~mpg/