Interdire l'écriture entre fonctions

Version imprimable

Voir 40 message(s) de cette discussion en une page

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:

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:

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

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:

1 2 3 BYTE * pbyVar1; BYTE * pbyVar2; pbyVar1[0] = 3;
Initialise tes pointeurs à NULL, et ça t'évitera bien des mauvaises surprises:
Code:

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

21/12/2006, 17h33
DaZumba

Citation:

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.

On peut utiliser un type abstrait de donnée:

Code:

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:

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

21/12/2006, 22h25
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) ?
22/12/2006, 00h12
Thierry Chappuis

Citation:

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
22/12/2006, 00h15
Emmanuel Delahaye

Citation:

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.
22/12/2006, 00h26
Thierry Chappuis

Citation:

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
22/12/2006, 08h27
fveysseire

Ok je vais suivre vos conseils merci.
22/12/2006, 09h47
fveysseire

Citation:

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.
22/12/2006, 09h53
Emmanuel Delahaye
Citation:

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:

1 2 3 4 int main (void) { BYTE * const pbyVar2 = init();
Dans ton code original, je vois :
Code:

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.
22/12/2006, 09h57
fveysseire

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.
22/12/2006, 10h00
Emmanuel Delahaye

Citation:

Envoyé par fveysseire

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

Merci d'utiliser http://www.developpez.net/forums/ima...tons/quote.gif, on ne sait pas de quoi tu parles.
22/12/2006, 10h01
fveysseire
Effectivement.
Citation:
Envoyé par Emmanuel Delahaye[B

EDIT:[/B]]

Code:

1 2 3 4 int main (void) { BYTE * const pbyVar2 = init();
Comment forcer l'utilisateur à déclarer var de cette manière?
22/12/2006, 10h01
Emmanuel Delahaye

Citation:

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).
22/12/2006, 10h03
fveysseire

Citation:

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.
22/12/2006, 10h06
Emmanuel Delahaye
Citation:
Envoyé par fveysseire

Citation:

Envoyé par Emmanuel Delahaye

Code:

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:

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...
22/12/2006, 10h25
fveysseire

Citation:

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. :oops:

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.
22/12/2006, 10h33
DaZumba

Citation:

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.
22/12/2006, 10h43
Emmanuel Delahaye

Citation:

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 ?

Citation:

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.

Voir 40 message(s) de cette discussion en une page