Interdire l'écriture entre fonctions

**fveysseire** · 21/12/2006, 14h47

BOnjour,

Je souhaiterais interdire l'écriture dans telle ou telle variable entre deux fonctions contenu dans deux fichiers différents.

Dans l'un des fichiers :

Code :

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

1
2
3
4
5
6
7
8
9
 
int main (void)
{
  BYTE * pbyVar1;
  BYTE * pbyVar2;
  pbyVar1[0] = 3;
  test (pbyVar1, &pbyVar2);
  pbyVar2[0] = 2;    // Je voudrais interdire cette écriture
}

Dans l'autre fichier :

Code :

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

1
2
3
4
5
6
 
void test (const BYTE * pbyVar3, BYTE ** const ppbyVAr4)
{
  pbyVar3[0] = 1;  // Interdit, normal à cause de la déclaration de pbyVar3
  *ppbyVar4[0] = 0;
}

Au final c'est dans le main que je souhaiterais interdire l'écriture dans *pbyVar2

Merci

**Thierry Chappuis** · 21/12/2006, 17h16

Salut,

Tu voudrais que ta variable pbyVar2 ne soit accessible qu'en lecture dans main et en lecture écriture dans test. Je ne crois pas qu'il y a une façon propre de réaliser cela.

En revanche, ce que je sais, c'est que là, tu écris dans une zone non allouée.

Code :

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

1
2
3
BYTE * pbyVar1;
BYTE * pbyVar2;
pbyVar1[0] = 3;

Initialise tes pointeurs à NULL, et ça t'évitera bien des mauvaises surprises:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
#include <stdlib.h>
/*...*/
BYTE *pbyVar1 = NULL;
/*...*/
pbyVar1 = malloc(TAILLE_DE_TON_TAB * sizeof(*pbyVar1));
if (pbyVar1 == NULL)
{
    fprintf(stderr, "L'allocation a échoué, pas bien!\n");
    exit(EXIT_FAILURE);
}
pbyVar1[0] = 3;

Thierry

**DaZumba** · 21/12/2006, 17h33

Envoyé par fveysseire

Au final c'est dans le main que je souhaiterais interdire l'écriture dans *pbyVar2

C'est impossible. Meme const n'empeche pas quelqu'un de motive de modifier la valeur d'une variable (un pointeur avec le cast-qui-va-bien, et le tour est joue). Si tu dois vraiment faire cela, c'est que tu as un probleme de conception.
La solution typique pour encapsuler les donnees en C, c'est de faire un type abstrait. L'utilisateur ne dispose que d'un pointeur vers une structure dont le contenu lui echappe. Il ne peut donc pas directement modifier la valeur des variables membres de cette structure.

**Thierry Chappuis** · 21/12/2006, 18h11

On peut utiliser un type abstrait de donnée:

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
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
 
/* montableau.h */
#ifndef H_TC_TESTFILE_20062112172233
#define H_TC_TESTFILE_20062112172233
 
typedef struct MonTableau MonTableau_s;
 
BYTE MonTableau_getValueAt(MonTableau_s *this, int index);
BYTE MonTableau_setValueAt(MonTableau_s *this, BYTE val, int index);
 
#endif /* Guard */
 
 
 
/* montableau.c */
#include "testfile.h"
 
struct MonTableau {
    size_t tab_size;
    BYTE *p_val;
};
 
MonTableau_s *MonTableau_new(size_t taille)
{
    MonTableau_s temp;
    temp = malloc(sizeof(*temp));
    if (temp == NULL)
    {
        /* Traitement en cas d'erreur d'allocation */
    }
 
    temp->tab_size = taille;
    temp->p_val = malloc(taille * sizeof(*temp->p_val)):
    if (temp->p_val == NULL)
    {
        /* Erreur d'allocation */
    }
 
    /* En bonus, on initialise toutes les cases du tableau à zéro */
    for (i = 0; i < taille; ++i)
    {
        temp->p_val[i] = 0;
    }
 
    /* On retourne l'adresse de temp */
    return temp;
}
 
/* Permet d'accéder à une valeur du tableau en lecture*/
BYTE MonTableau_getValueAt(MaStructure_s *this, int index)
{
    if (index >= this->tab_size)
    {
        /* Afficher une erreur */
    }
    return this->p_val[index];
}
 
BYTE MonTableau_setValueAt(MaStructure_s *this, BYTE val, int index)
{
    if (index >= this->tab_size)
    {
        /* Afficher une erreur */
    }
    this->p_val[index] = val;
}
 
void MonTableau_delete(MonTableau_s **this)
{
    /* A implanter */
}

Ici, MonTableau_s est un type opaque. Tu peux créer un objet de type MonTableau_s dans main, mais tu est obligé de passer par les fonctions MonTableau_getValueAt et MonTableau_setValueAt pour accéder aux valeur e ton tableau. Cela te donne une grande flexibilité. C'est la meilleure manière que je connaisse de contrôler l'accès aux variables.

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
/* main.c */
#include "montableau.h"
 
int main(void)
{
    MonTableau_s *tab;
    BYTE val;
 
    tab = MonTableau_new(10);
    /* ... */
    val = MonTableau_getValueAt(tab, 5);
    /* ... */
    MonTableau_delete(&tab);
    return 0;
}

Seules les fonctions dans le fichier montableau.c sont autorisée à modifier directement un objet de type MonTableau_s.

Thierry

**Médinoc** · 21/12/2006, 22h25

void test (const BYTE * pbyVar3, BYTE * const * ppbyVAr4) ne peut-il pas convenir ?
Voire même, void test (const BYTE * pbyVar3, BYTE const * const * ppbyVAr4) ?

**Thierry Chappuis** · 22/12/2006, 00h12

Envoyé par Médinoc

void test (const BYTE * pbyVar3, BYTE * const * ppbyVAr4) ne peut-il pas convenir ?
Voire même, void test (const BYTE * pbyVar3, BYTE const * const * ppbyVAr4) ?

Si j'ai bien compris, il veut que la variable pbyVar2 soit modifiable par l'intermédiaire de la fonction test, mais pas par accès direct dans main. Je ne pense pas que modifier l'interface de la fonction test résoud ici le problème.

Selon la manière dont je comprends le problème, je crois que l'auteur du post désire forcer l'utilisateur à utiliser la fonction test pour modifier une variable donnée. C'est un problème d'encapsulation des données qui trouve une solution élégante dans la conception d'un type abstrait de donnée.

Thierry

**Emmanuel Delahaye** · 22/12/2006, 00h15

Envoyé par mujigka

C'est un problème d'encapsulation des données qui trouve une solution élégante dans la conception d'un type abstrait de donnée.

Je confirme, c'est fait pour.

**Thierry Chappuis** · 22/12/2006, 00h26

Envoyé par Emmanuel Delahaye

Je confirme, c'est fait pour.

Pour un exemple concret et documenté de conception d'un type abstrait de donnée, puisque tu ne l'as pas mentioné: http://emmanuel-delahaye.developpez.com/tad.htm

Thierry

**fveysseire** · 22/12/2006, 08h27

Ok je vais suivre vos conseils merci.

**fveysseire** · 22/12/2006, 09h47

Envoyé par mujigka

Si j'ai bien compris, il veut que la variable pbyVar2 soit modifiable par l'intermédiaire de la fonction test, mais pas par accès direct dans main. Je ne pense pas que modifier l'interface de la fonction test résoud ici le problème.

Selon la manière dont je comprends le problème, je crois que l'auteur du post désire forcer l'utilisateur à utiliser la fonction test pour modifier une variable donnée. C'est un problème d'encapsulation des données qui trouve une solution élégante dans la conception d'un type abstrait de donnée.

Thierry

Le post original n'est pas correct, je souhaite obliger le main à rendre la variable pbyVar2 non modifiable dans le main.

**Emmanuel Delahaye** · 22/12/2006, 09h53

Envoyé par fveysseire

Le post original n'est pas correct, je souhaite obliger le main à rendre la variable pbyVar2 non modifiable dans le main.

EDIT:

Code :

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

1
2
3
4
 
int main (void)
{
  BYTE * const pbyVar2 = init();

Dans ton code original, je vois :

Code :

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

1
2
3
4
5
6
 
int main (void)
{
  BYTE * pbyVar1;
<...>
  pbyVar1[0] = 3;

Ce qui est horrible, car pbyVar1 n'est pas initialisé. Comportement indéfini.

**fveysseire** · 22/12/2006, 09h57

Mais comment forcer le main à déclarer var de cette manière ?

Je comprends que le code original correspond à 10 sur l'échelle de goret, mais c'est juste un petit programme de test pour vérifier la possibilité d'écrire de telle ou telle variable.

**Emmanuel Delahaye** · 22/12/2006, 10h00

Envoyé par fveysseire

Mais comment forcer le main à déclarer var de cette manière ?

Merci d'utiliser

, on ne sait pas de quoi tu parles.

**fveysseire** · 22/12/2006, 10h01

Effectivement.

Envoyé par Emmanuel Delahaye[B

EDIT:[/B]]

Code :

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

1
2
3
4
 
int main (void)
{
  BYTE * const pbyVar2 = init();

Comment forcer l'utilisateur à déclarer var de cette manière?

**Emmanuel Delahaye** · 22/12/2006, 10h01

Envoyé par fveysseire

Je comprends que le code original correspond à 10 sur l'échelle de goret, mais c'est juste un petit programme de test pour vérifier la possibilité d'écrire de telle ou telle variable.

Tu ne peux rien vérifier du tout si le code est faux (comportement indéfini).

**fveysseire** · 22/12/2006, 10h03

Envoyé par Emmanuel Delahaye

Tu ne peux rien vérifier du tout si le code est faux (comportement indéfini).

Oui mais je ne cherche pas à vérifier à l'utilisation mais à la compilation.

**Emmanuel Delahaye** · 22/12/2006, 10h06

Envoyé par fveysseire

Envoyé par Emmanuel Delahaye

Code :

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

1
2
3
4
 
int main (void)
{
  BYTE * const pbyVar2 = init();

Comment forcer l'utilisateur à déclarer var de cette manière?

On peut pas. Il faut l'éduquer, c'est tout. Même si tu mets une macro

Code :

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

1
2
3
4
5
6
7
 
#define DEF(var_)\
  BYTE *const var_ = init()
 
int main (void)
{
    DEF (pbyVar2);

Il y aura toujours un tordu pour passer outre...

**fveysseire** · 22/12/2006, 10h25

Envoyé par Emmanuel Delahaye

Il faut l'éduquer, c'est tout.

Je ne suis pas sur que j'arrive pas à me faire comprendre, j'ai un peu de mal à expliquer.

Si un utilisateur fait un appel à une fonction qui demande, en paramètre d'entrée, un pointeur constant (le contenu est constant et ou ce qui est pointé est constant), il n'est pas possible ( a cause des cast ) de forcer cet utilisateur à déclarer la variable (qu'il souhaite utiliser dans l'appel de la fonction) de tel manière à lui interdire l'écriture?

tu me dis si c'est pas clair.

**DaZumba** · 22/12/2006, 10h33

Envoyé par fveysseire

Si un utilisateur fait un appel à une fonction qui demande [...]

Un utilisateur de quoi ? Du code source ? Alors, il suffit d'avertir par un commentaire -- apres, il/elle fait ce qu'il/elle veut, evidemment. Si tu veux tout emballer dans une bibliotheque, alors tu as les types abstraits, et tu es un peu plus tranquille.

**Emmanuel Delahaye** · 22/12/2006, 10h43

Envoyé par fveysseire

Si un utilisateur fait un appel à une fonction qui demande, en paramètre d'entrée, un pointeur constant (le contenu est constant et ou ce qui est pointé est constant), il n'est pas possible ( a cause des cast ) de forcer cet utilisateur à déclarer la variable (qu'il souhaite utiliser dans l'appel de la fonction) de tel manière à lui interdire l'écriture?

Non. On peut concevoir des interfaces cohérentes, mais si un codeur veut passer outre, à coup de cast sauvages, on ne peut rien faire. Tu voudrais quoi ? Qu'on lui envoie une décharge dans le clavier ?

tu me dis si c'est pas clair.

C'est vrai que c'est pas hyper clair. Donne un exemple précis (et réel, pas de comportement indéfini invérifiable) de ce que tu voudrais faire et des cas de mauvaise utilisation qui devraient être détectés.

Interdire l'écriture entre fonctions

Réseau C

Discussions similaires

Partager

Partager