[langage] constantes, structures, cast de pointeurs de fonctions

Bonjour,
J'ai plusieur problemes de theorique avec le C. :oops:

Premierement, comment peut on/doit on passer des structures a des fonctions en impliquant que celle ci ne doit pas etre modifiée ?
Pour l'instant, je passe ma structure en copie (donc sans pointeur) ainsi si celle-ci est modifiée, la "vraie" structure ne l'est pas. Est il possible de passer un pointeur vers une structure constante? Et, dans ce cas la, que signifie structure constante ? Cela influence t il les membres et si oui, que ce passe t il si un de ses membres est un pointeur ? :oops:

(Passer la structure en reference est plus econome que la passer en copie, mais peut on interdire toute modification ?)

Deuxièmement, est il possible de definir dans une structure des attributs constants, si oui, comment les initialise t on ? (Car j'imagine que dès que la structure est reservée en memoire, ses attributs constants devraient deja etre definis... )

Troisièmement, est il possible de faire des cast de pointeurs de fonctions ?(J'ai pas reussi a trouve comment).
Par exemple on a , int f(int , long ) mais on souhaite avoir un pointeur sur short f(long short ). Ou alors, est on obligé de creer une fonction intermediaire afin de realiser l'"interface".
De meme, mais je pense que c'est cela est vraiment utoptique, peut on passer un partie des parametres directement ?
C'est a dire en reprenant int f(int, long b) et que je souhaire utiliser une fonction short f(long int), et il possible de faire b=5 (par exemple) ?

D'avance merci

Citation:

---

Envoyé par TabrisLeFol

Premierement, comment peut on doit on passer des structures a des fonctions en impliquant que celle ci ne doit pas etre modifiée ?

---

Pour être efficace, on passe l'adresse avec un qualificateur const qui rend les membres de la structure non modifiables :

Code:

---

int f(T const *p);

---

Citation:

---

que ce passe t il si un de ses membres est un pointeur ?

---

Un membre pointeur devient non modifiable, mais ce qui est pointé reste modifiable, si il l'était, bien sûr.

Citation:

---

(Passer la structure en reference est plus econome que la passer en copie, mais peut on interdire toute modification ?)

---

On ne peut pas 'interdire' à un programmeur de se tirer une balle dans le pied, car un cast suffit à briser la 'constantness'. Mais le comportement devient alors indéterminé. Le C n'est pas un langage de bidouilleurs... Plus que jamais "C is a sharp tool"...

Citation:

---

Deuxièmement, est il possible de definir dans une structure des attributs constants, si oui, comment les initialise t on ? (Car j'imagine que des que la structure est reservée en memoire, ses attributs constants devraient deja etre definis... )

---

C'est quoi un attribut ? Je ne connais que les membres (ou éléments).

Comme pour une variable simple :

Code:

---

1 2 3

int const c; /* non sens */ c = 123; /* bah, non, c'est 'const'... */

---

Donc, on fait comme ça :

Code:

---

1 2	int const c = 123;

---

Tu parles de ce cas là :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

struct data { int const x; int y; };   int main (void) { struct data data;   data.x = 123; /* bug */ data.y = 456;   return 0; }

---

donc on fait comme ça :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14

struct data { int const x; int y; };   int main (void) { struct data data = {123};   data.y = 456;   return 0; }

---

Sil il faut faire une initialisation après définition (allocation dynamique, par exemple), on doit utiliser memcpy() :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

#include <string.h>   struct data { int const x; int y; };   int main (void) { struct data z = {123}; struct data data;   memcpy (&data, &z, sizeof data);   data.y = 456;   return 0; }

---

Citation:

---

Troisièmement, est il possible de faire des cast de pointeurs de fonctions ?(J'ai pas reussi a trouve comment).
Par exemple on a , int f(int a, long b) mais on souhaite avoir un pointeur sur short f(long int, short b). Ou alors, est on obligé de creer une fonction intermediaire afin de realiser l'"interface".

---

C'est techniquement possible, mais peu recommandé, car on se prive des vérifications du compilateur.

Le cast est plutôt gore, alors on passe par un typedef qui allège considérablement l'écriture :

Code:

---

1 2 3 4 5 6 7 8

typedef short fb_f (long int, short b);   int fa(int a, long b);   { fb_f *pf = (fb_f *) fa; }

---

A toi de savoir ce que tu fais, tu travailles sans filet...

Merci beaucoup, effectivement, il s'agit peut etre de "membres" mais j'ai l'habitude d'utiliser attributs pour le membre des objets... (Oui, le C n'est pas un language orienté objet.) Mais j'amalgame objets et struct, meme si je conçoit leur difference.

Pour l'allocation dynamque, c'était effectivement mon problème. (Je dois avouer que je ne connaissais meme pas le static, avec les membres contants.) Dans l'exemple, si j'ai bien compris le struct data data aurait pu etre alloué dynamiquement par un malloc.

Citation:

---

Envoyé par TabrisLeFol

Dans l'exemple, si j'ai bien compris le struct data data aurait pu etre alloué dynamiquement par un malloc.

---

Oui.

Juste une petite confirmation sur la protection des donnees.

Normalement, en l'absence de membres constants, ceci devrait etre legal :

Code:

---

1 2 3

struct data z = {123}; struct data* data = malloc(sizeof(*data)); *data = z;

---

Ce qui signifie que
* lorsqu'il y a un membre constant cela ne marche pas, car une partie de la plage de donnee reservee pour la struct est "read-only"
* memcopy permet de surpasser la protection const

Citation:

---

Envoyé par TabrisLeFol

Juste une petite confirmation sur la protection des donnees.

Normalement, en l'absence de membres constants, ceci devrait etre legal :

Code:

---

1 2 3

struct data z = {123}; struct data* data = malloc(sizeof(*data)); *data = z;

---

---

OK, c'est comme ça que j'initialise les structures dynamiques :

Code:

---

1 2 3 4 5 6 7

T *p = malloc(sizeof *p) if (p != NULL) { static const z = {0}; *p = z; /* ... */

---

simple, rapide, portable.

Citation:

---

Ce qui signifie que
* lorsqu'il y a un membre constant cela ne marche pas, car une partie de la plage de donnee reservee pour la struct est "read-only"
* memcopy permet de surpasser la protection const

---

Oui. (au fait, c'est memcpy())...

Hum, ok.

Par contre, le static, il n'est pas thread safe ? Pour des processus independants, l'espace memoire de la fonction (et donc les variables statiques) seront separées, mais pas pour des threads ? non ?

(memcopy s'était une erreur, oui.)

C'est constant, donc aucun conflit possible.

Ah, oui. J'étais resté sur mon probleme d'allouer dynamiquement un membre constant d'une structure elle-meme allouer dynamiquement. (La solution étant le memcpy.)

Dans ce cas ci, le membre de toutes les structures sera 0. Le static const est donc comme un model d'initialisation pour la structure. Et cet exemple ne concernait pas le cas, ou un membre était 'const'.

Merci beaucoup.

Citation:

---

Envoyé par TabrisLeFol

Par contre, le static, il n'est pas thread safe ?

---

Et ? C'est en lecture seule. Quel est le problème ?