Pourquoi ne peut-il pas faire fonctionner ici ..
#include<stdio.h> int main(){ int x = 5; float y = 7.0; float *p = &y; int *q = &x; printf("p is %d\nq is %d\np - q is %d", p, q, (p - q)); return 0; }
4 Réponses :
EDIT: Comme il a été signalé dans les commentaires, soustrayer deux points nuls * NOV * n'est pas approprié standard C. Si vous souhaitez soustraire deux pointeurs pour trouver la distance entre eux, la bonne approche consiste à les jeter à un entier de taille appropriée , puis faire de l'arithmétique entier. p>
E.g.: P>
Réponse originale: p>
Cela signifie que l'opérateur moins n'est pas défini pour les types de pointeurs mixtes. Si vous souhaitez soustraire ces deux pointeurs, par exemple pour trouver la quantité d'espace entre eux, la meilleure option serait de les jeter à la fois à En outre, vous devez imprimer des valeurs de pointeur avec le spécificateur E.g.: P>
printf ("P est% p \ nq est% p \ np - q est% ld \ n", p, q, ((intptr_t) p - (intptr_t) q)); code> p>
Void * Code> Pointants. P>
% p code> au lieu de
% d code>. p>
printf ("p est% p \ nq est% p \ np - q est% ld \ n", p, q, (vide *) p - (vide *) q)); Code> p>
La meilleure option serait de les jeter à la fois aux points nuls * Pointeurs. I> NO B>. Vous ne pouvez pas faire du pointeur arithmétique sur void * code> des pointeurs. Certaines implémentations offrent une extension non portable.
Je ne pense pas que vous soyez autorisé à soustraire deux void code> des pointeurs de la norme C, bien que je pense que GCC le permet comme une extension.
Le pointeur arithmétique sur vide * code> est une extension non standard (introduite par GCC), donc
char * code> serait préférable pour le pointeur arithmétique. (Il s'agit toujours d'un comportement techniquement indéfini de soustraire des pointeurs à différents objets, sauf dans le même tableau, mais il est probable qu'il suffit d'afficher la différence de valeurs d'adresse plutôt que d'exploser votre ordinateur sur la plupart des implémentations.)
@Ian Abbott, si l'on veut traiter les pointeurs comme des chiffres, les jeter dans des chiffres ( uintptr_t code>) a plus de sens pour moi que de les jeter dans
char * code>.
Techniquement, l'argument correspondant à % p code> doit être un
vide * code>, plutôt qu'un
int * code> ou un
flotteur * code>.
@ikegami ou plutôt intPTR_T code> puisque le résultat de la soustraction pourrait être négatif.
L'erreur signifie que le compilateur est incapable de déduire le type commun de deux opérandes dont l'un a le type Mais dans tous les cas, le programme a un comportement indéfini car au moins vous ne pouvez pas soustraire deux pointeurs qui ne pointent pas les éléments du même réseau ou à une mémoire après le dernier élément du même tableau. P>
à partir de la norme C (6.5.6 Opérateurs additifs) P>
9 Lorsque deux pointeurs sont soustraits, les deux doivent pointer vers des éléments de
le même objet de tableau, ou un passé le dernier élément de la matrice
objet; Le résultat est la différence des sous-domescents des deux
Éléments de tableau. P>
blockQuote>
et en utilisant des spécificateurs de conversion incorrects (comme par exemple de la norme C (7.21.6.1 la fonction FPRRTINF) P>
9 Si une spécification de conversion n'est pas valide, le comportement est
indéfini.275) Si un argument n'est pas le type correct pour le
Spécification de conversion correspondante, le comportement n'est indéfini. strong> p>
blockQuote> float * code> et d'autres
int * code>. Il n'y a pas de conversion implicite entre ces types. P>
% d code> avec un pointeur) pour les arguments fournis dans la fonction
printf code> invoque également un comportement indéfini. P>
Je suppose que vous souhaitez soustraire les valeurs réelles que vos pointeurs montrent.
C convertit aussi, vous programmez. a des problèmes comme p> n'utilise pas n'utilise pas l'opérateur Voici votre programme, fonctionnant: p> avec les sorties: p> int code> sur
float code> implicitement lorsque vous utilisez
float code> et
int code>.
% f code> Spécificateur de type pour imprimer
float code> Pointeur P> Li>
* code> pour accéder aux valeurs du pointeur. p> li>
ul>
Vous ne pouvez pas soustraire les pointeurs comme ça et obtenir un résultat significatif dans la norme C.
par
Lorsque deux pointeurs sont soustraits, les deux doivent pointer vers des éléments du même objet de tableau, ou un autre élément du dernier élément de l'objet réseau; Le résultat est la différence des indignes des deux éléments de tableau. P> blockquote>
Dans ce cas, un seul
int code> ou
float code> est considéré comme une matrice de taille
1 code>. p>
donné p>
xxx pré> tentative de calcul de la valeur
p - q code> entraîne un comportement non défini. p>
Cela signifie que vous ne pouvez pas soustraire un pointeur sur
int code> à partir d'un pointeur sur
float code> car ils pointent sur différents types. En outre, quel est le point de les soustraire quand même?
Vous n'avez pas de typast
Les comparaisons du pointeur ne sont valides que lorsque les deux pointeurs sont des pointeurs sur le même objet b> ou un élément au-delà de l'extrémité de même objet b>, dans laquelle un objet peut être un tableau.
Qu'essayez-vous de faire?