Discussion :

[TabrisLeFol]

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

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 ?

(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

[Emmanuel Delahaye]

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 :

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

int f(T const *p);

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.

(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"...

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 :

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

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

Donc, on fait comme ça :

Code :

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

1
2
 
   int const c = 123;

Tu parles de ce cas là :

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

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

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 :

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
#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;
}

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 :

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

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

[TabrisLeFol]

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.

[Emmanuel Delahaye]

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

Oui.

[TabrisLeFol]

Juste une petite confirmation sur la protection des donnees.

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

Code :

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

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

[Emmanuel Delahaye]

Juste une petite confirmation sur la protection des donnees.

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

Code :

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

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 :

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

1
2
3
4
5
6
7
 
   T *p = malloc(sizeof *p)
   if (p != NULL)
   {
      static const z = {0};
      *p = z;
      /* ... */

simple, rapide, portable.

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())...

[TabrisLeFol]

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.)

[Médinoc]

C'est constant, donc aucun conflit possible.

[TabrisLeFol]

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.

[Emmanuel Delahaye]

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

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