Bonjour,
 
J'ai un petit problème avec l'algorithmique des pointeurs en C.
Je ne sais pas comment "désactiver" temporairement ce comportement...je m'explique :
 

 
Dans ce cas le compilateur va faire pointer "var" vers (var + (sizeof(*var) * 2)) soit (var + 8) !
Alors que je veux le faire pointer vers (var + 2 octets) et non (var + 8 octets)...
 
Aidez moi  

tu fais ( ou tu caste ) un pointeur en void *
 
mais c'est super crade et tres dangereux  

tu peux faire  
char *tmp = (char *) var;
var = (int *) (tmp + 2);
 
Au passage tu perds l'adresse fournie par le malloc.
Quel est l'intérêt ?

Tu veux sans doute dire l'arithmétique des pointeurs...

La confusion règne dans les esprits... La Bête a commencé son Oeuvre, l'Apocalypse est en marche...

Oui l'arithmétique bien sur    
Merci à vous.
 
Entre temps, j'ai aussi trouvé la solution du "cast", je fais maintenant :

 
Mais comme tu dis flo850, la solution semble bien crade. Quelle est donc la solution "propre" ?  

Définit ce que tu veux faire (je parle d'objectif, pas de solution).
 

Je dois calculer le pointeur qui me permet d'aller X octets derrière une structure quelconque.
 
Imaginons que j'ai :

 
Donc là je veux avoir le new_ptr à "t_test + sizeof(t_test) + 3 octets" alors qu'avec l'arithmétique des pointeurs je tombe beaucoup plus loin  

mais acceder au bloc suivant est asssez reiqué
 
a moins que tu n'ai alloué un tableau de données,  tu ne pexu pas etre sur de tomber sur une zone autorisée

Utilise un char *p. Le déplacement sera alors de 1 à chaque incrément.

J'espère que tu sais ce que tu fais, parce que "aller X octets derrière une structure quelconque.
", je le sens mal.

Et si tu exposais plutôt ton vrai problème, parce que là, ça sent la solution vaseuse à un vrai problème non exposé...

Si j'utilise un char *p je ne peux pas acceder aux elements de ma structure quand "je sais" que le pointeur pointe sur une structure valide.
Il n'y a pas de "vrai problème", le "problème" a été exposé.
 
EDIT : Et vous inquiétez pas, je sais exactement où je vais dans le "heap"  

Puis-je te renvoyer à ce que j'ai écrit ce matin ?

t'es à peu près sûr d'avoir une erreur de segmentation si t'es sous Linux en faisant un truc pareil.

Ca revient exactement au même que de le caster directement en (char *)...mais en créant une variable intermédiaire. Donc désolé mais je vois pas "le mieux"

Je pense que je vais rester sur du cast en (char *), sauf si quelqu'un a une meilleur solution.
Merci à vous en tout cas  

Au moins tu gardes l'ancienne adresse, ce qui est utile pour la libération de la zone mémoire allouée par malloc.
D'autre part, j'avais répondu à ceci :

Pas besoin de conserver le pointeur, je suis sur un maillon d'une liste chainees et je peux retrouver ce pointeur à tout instant  

surtout fausse.
 
Et attention aux problèmes d'alignements.

Et donc quelle est la solution "juste" ?  

Définir exactement ce que tu veux faire (spécification) et prendre les moyens de le réaliser correctement (conception).

Tant que tu n'exposes pas le vrai problème, on ne peut que spéculer et bricoler. Je rappelle que l'informatique n'est qu'un outil au service d'un 'métier'. De quel 'métier' s'agit-il ? De quelle application  Quel est le but de la manoeuvre ? Quels sont les entrées, les traitements, les sorties ?

Bref, il faut cesser de bricoler et passer à une attitude professionnelle.

Ben si tu peux !!!
 
Je reprends ton exemple de structure

 
Si tu es certain (je me demande bien comment) que ton "p" est bien sur une structure valide, tu peux accéder à l'élément que tu veux (ex: val1) en demandant "((t_test)*p).val1".
 
Voilà - Ca c'était la façon d'écrire. Mais c'est une façon qu'on n'utilise jamais car généralement on se déplace de structure en structure en utilisant un pointeur sur le type de la structure. Là on est vraiment certain qu'on est bien sur la structure en question et on n'a pas besoin de ce cast. En fait, pour résumer la question que tout le monde se pose: pourquoi as-tu donc besoin de te déplacer en octets pour retomber au final "certainement" sur une structure valide alors que l'arithmétique des pointeurs fait que tu tomberas "toujours" sur une structure valide ???
 
[EDIT]
Je pense qu'il vaut mieux remplacer

par

...

Parceque je (re)code les fonctions d'allocations de mémoire de la libc.  

Ah, on va peut enfin connaitre les vrais raisons de ce bidouillage...
 

Tout le monde est suspendu au forum en attente de la réponse...