Discussion :

[fveysseire]

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]

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

[Thierry Chappuis]

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]

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]

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]

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.

[fveysseire]

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.

[DaZumba]

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.