Bonjour,

J´utilise des structures de données contenant un pointeur vers un char (destiné à recevoir une chaine de caractère de longueur arbitraire après allocation) de la forme :

typedef struct
{
// ...

char *chaine;
}
Structure;

(Notez que le char* est la dernière variable décla
rée, ce détail a son importance pour la suite)

Comme les instances de cette structure sont elles aussi allouées dynamiquement, l´initialisation complète d´une telle instance nécessite :

1/ L´allocation de la mémoire nécessaire à la structure
2/ L´allocation de la mémoire nécessaire à la chaine

Or je me demandais s´il n´était pas possible de se ramener à une unique allocation de mémoire, pour simplifier les choses et améliorer les performances, en procédant de la sorte :

Structure *instance;

instance =
(Structure*)malloc(sizeof(Structure)+longueurChain
e*sizeof(char));

instance->chaine = &(instance->chaine+sizeof(char*));

Ca me parait valide, mais si quelqu´un pouvait me le confirmer...

Ca me semble bien (sauf que ce n´est pas &(instance->chaine+sizeof(char*)) mais &(instance->chaine)+sizeof(char*)).

Le seul défaut c´est que tu ne sais plus rien sur l´alignement de tes données. Comme les chars font 1 octet ce n´est pas grave, mais je me demande si dans le cas où tu utiliserais des wchar_t ou des trucs comme ça, ce n´est pas un problème qu´il faudrait prendre en compte (mais je ne connais pas assez bien le problème pour en être sûr).

ça me parait bien comme truc !

j´ai déja une remarque :
si tu mets ta chaine a la fin de ta structure, pourquo laisser le char* qui pointe dessus ? a priori tu n´en as plus besoin
(sauf si c´est pour faciliter l´écriture apres)

par pour y accéder, il te suffira de faire :

char* c = (char*)&ma_struct + sizeof(ma_struct);

ce qui est certes un peu plus lourd que :
ma_struct->chaine

Sinon, hormis cela, je dirais que le probleme de décalage de données n´est est pas vraiment un a condition que tu utilises bien sizeof

En effet, imaginons que tu veuilles rajouter des données a une telle structure :

struct test
{
int a;
char b;
}

le sizeof de cette struct est bien 8 et non 5 pour aligner sur la donnée suivante, meme si c´était un tableau de int.

C´est mon avis, bien sur, je peux me tromper.

bref, c´est une bonne idée, le débat est intéressant

dnob700 > Oui en effet, petit problème de parenthesage.
Au fait ca c´est bien passé les concours ?
Moi j´ai été admissible (je passe les oraux la semain prochaine) CCP et quelques écoles du concours Centrale et je pense faire 5/2.

Fvirtman > Concernant la présence d´un char*, c´est principalement pour simplifier les utilisations utltérieures (parce que bon, faut avouer que cette allocation, si elle est pratique, fait un peu "magouille", et j´essaie d´éviter les (char*)&ma_struct + sizeof(ma_struct) pour l´utilisateur par la suite dès qu´il voudra s´en servir)