Discussion :

[dancingmad]

Bonjour,

est-il possible d'empêcher une structure d'être copiable en C99 ? Mon problème est que j'ai une structure basique de tableau dynamique qui ressemble à ceci :

Code :

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

1
2
3
4
5
6
7
8
9
10
struct DynamicArray
{
    int size;
    int capacity;
    size_t eltsize;
    void* data;
}
 
void DynamicArray_Init(struct DynamicArray* array, size_t eltSize);
void DynamicArray_Add(struct DynamicArray* array, void* value);

et que si quelqu'un a le malheur d'écrire plus tard:

Code :

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

1
2
3
4
5
6
struct DynamicArray arrayA;
DynamicArray_Init(&arrayA, sizeof(int));
 
int i = 3;
struct DynamicArray arrayB = arrayA;
DynamicArray_Add(&arrayB, &i);

Alors dans ce cas là, il se peut que la structure A soir invalidée à cause des opérations de realloc potentielles dans le Add.

J'imagine que la seule solution est de rendre la structure opaque, mais c'est un peu dommage vu que du coup ça n'est plus possible de l'allouer de manière automatique -_-

Merci d'avance.

[droggo]

Loa,

Ta structure s'adresse à des programmeurs suffisamment formés, à eux de prendre leurs responsabilités.

[LittleWhite]

Bonjour,

Vous pouvez faire en sorte que la structure devienne opaque (que le programmeur ne connaisse jamais son contenu réel). Pour cela, il ne faut jamais lui donné le .h où la structure est déclarée et lui donner assez de fonctions pour "jouer" avec la structure.
Lorsqu'il a besoin de l'utiliser, il l'utilise seulement à travers des pointeurs et pour sa déclaration, il utilise un bête :

Code :

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

struct MaStructure;

indiquant que le symbole existe bien, mais que bon, on ne sait pas ce que c'est. Beaucoup de bibliothèque agissent ainsi (SDL 2, libcg, ...)

[ternel]

Et même la bibliothèque standard, avec les FILE* de fopen, fclose, fread etc

[dancingmad]

Ta structure s'adresse à des programmeurs suffisamment formés, à eux de prendre leurs responsabilités.

Certes, mais on est jamais à l'abri d'une inattention

Vous pouvez faire en sorte que la structure devienne opaque

Oui c'est ce que je disais, mais je trouve dommage de devoir utiliser ce mécanisme et perdre en même temps la possibilité d'allouer un tableau dynamique sur la pile, mais bon je n'ai pas trop le choix on dirait !

Sinon je viens d'avoir une idée, qui consisterait à vérifier les erreurs au runtime. Dans le header :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
struct DynamicArray
{
    int size;
    int capacity;
    size_t eltsize;
    void* data;
    int signature;
}
 
void DynamicArray_Init(struct DynamicArray* array, size_t eltSize);
void DynamicArray_Add(struct DynamicArray* array, void* value);

et dans le .c :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
void DynamicArray_Init(struct DynamicArray* array, size_t eltSize)
{
    array->signature = (int) array;
    ...
}
 
void DynamicArray_Add(struct DynamicArray* array, void* value)
{
    assert(array->signature == (int) array);
    ...
}

ainsi si un programmeur a le malheur d'assigner un tableau directement, la signature ne sera plus bonne et on aura un assert au runtime.

Code :

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

1
2
3
4
5
6
struct DynamicArray arrayA;
DynamicArray_Init(&arrayA, sizeof(int));
 
int i = 3;
struct DynamicArray arrayB = arrayA;
DynamicArray_Add(&arrayB, &i);    // assert ici car arrayB.signature != &arrayB

Vous en pensez quoi ?

[Sve@r]

Sinon je viens d'avoir une idée, qui consisterait à vérifier les erreurs au runtime. Dans le header :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
struct DynamicArray
{
    int size;
    int capacity;
    size_t eltsize;
    void* data;
    int signature;
}
 
void DynamicArray_Init(struct DynamicArray* array, size_t eltSize);
void DynamicArray_Add(struct DynamicArray* array, void* value);

et dans le .c :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
void DynamicArray_Init(struct DynamicArray* array, size_t eltSize)
{
    array->signature = (int) array;
    ...
}
 
void DynamicArray_Add(struct DynamicArray* array, void* value)
{
    assert(array->signature == (int) array);
    ...
}

Vous en pensez quoi ?

Bonjour

Pourquoi caster systématiquement en int ? Pourquoi ne pas stocker directement l'adresse elle-même ???

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
typedef struct s_DynamicArray
{
    int size;
    int capacity;
    size_t eltsize;
    void* data;
    struct s_DynamicArray *signature;
} t_DynamicArray;
 
void DynamicArray_Init(t_DynamicArray* array, size_t eltSize)
{
    array->signature = array;
    ...
}
 
void DynamicArray_Add(t_DynamicArray* array, void* value)
{
    assert(array->signature == array);
    ...
}

...