J'ai un problème avec des pointeurs que je ne savais pas comment résoudre. Mon pointeur
5 Réponses :
Utiliser * p = null; // pointeur "P" pointe sur NULL code> c'est mauvais, vous DÉRÉFERENGE
P CODE> ET défini sur
NULL code> VALEUR IT Références à. P>
p = null code>. p>
Le problème est ici: juste un exemple: p> * p = null; // pointeur "P" pointe sur null code>
Vous ne réinitialisez pas lorsque le pointeur indique, vous définissez la valeur à l'emplacement référencé.
Dans votre code, P et Q pointe vers la même mémoire. Vous n'avez pas changé le pointeur sur un emplacement différent, mais écrasez la valeur pointée par P (qui est également pointée par Q) à NULL.
Cela devrait fonctionner. p>
Le problème dans votre code est le suivant:
*q = 5 p = (nil)
* p = null; // pointeur "P" pointe sur null code> p>
Non, ça ne le fait pas. Votre pointeur et définissez le
A code> sur la null converti en
int code> (qui est généralement zéro) p>
si vous souhaitez définir
p code> à null, vous devez
p = null code>; p>
si votre idée était d'avoir
p code> référencer le
q code > Pointeur Vous devez modifier le code à: p>
xxx pré> blockQuote>
Re «non ce n'est pas»: oui ça fait. * p = null code> met
null code> (converti en un
int code>) dans
* p code> et
p < / Code> Points sur
* P code>, donc
p code> est alors pointé vers
null code> (converti en un
int code>). Les gens ne doivent pas utiliser la phrase "pointant vers null". Au contraire, il devrait être "
p code> est un pointeur nul" ou "
p code> points à nulle part / rien".
@Ericpostpischil non, ça ne le fait pas. Il pointe de la valeur entière. Cette valeur peut être convertie en null mais ce n'est plus nul. Considérant #define NULL (VOID *) 0 CODE>. Null n'est pas
0 code> et
0 code> n'est pas null
Pour enseigner, vous devez comprendre ce qui est dans l'esprit d'autres personnes. Il ne suffit pas d'écrire des déclarations techniquement vraies et d'attendre des étudiants de les comprendre quand ils n'ont pas encore les connaissances nécessaires pour les comprendre. Certains étudiants vont raisonner pour dire que "je mets null code> dans
* p code>, donc maintenant
p code> points sur
null code>." Le fait que
null code> est converti en
int code> pendant cette affectation (c'est pourquoi j'ai écrit "
null code> (converti en
int code >) ") Ne peuvent pas les empêcher de penser cela. Donc, vous devez expliquer; Vous devez faire face à ce qui est dans leur esprit, pas seulement ce qui est dans la norme C.
Il suffit d'écrire des réponses qui rendent les déclarations techniquement vraies peuvent montrer vos connaissances, mais elles ne transmettent pas nécessairement que les connaissances aux étudiants ainsi que les réponses qui déterminent comment les élèves pensent et qui expliquent en fonction de cela. Les réponses ne doivent pas simplement simplement présenter une destination; Ils devraient diriger le questionneur de l'endroit où ils sont à la destination.
@EricpostPischil écrit techniquement des réponses ou des commentaires incorrects fait beaucoup plus de confusion. Mais comme je sais que c'est très peu probable ici d'admettre une propre erreur.
Je ne dis pas d'écrire des réponses incorrectes. Je dis à penser à ce qu'un élève pense que c'est faux, puis non seulement indiquer la bonne réponse, mais aussi leur expliquer ce qui est incorrect dans leur pensée et les aider à le réparer.
* p = null; code> ->
p = null; code>
Je suppose que 5 réponses se concentrer exactement la même chose devrait suffire. :-)
Ne laissez pas la syntaxe comme
int * p = null; code> et
* p = 3; code> vous confondre. Dans une déclaration, il peut sembler que le
* code> fait partie de la chose donnée une valeur, mais ce n'est pas le cas. Une déclaration est spéciale et seul l'objet nommé,
p code> est donné une valeur, pas
* p code>. Dans une affectation, l'ensemble de l'expression sur le côté gauche,
* p code> in
* p = 3 code> est donné une valeur. Ainsi, pour définir
p code> sur
null code>, vous voulez
p = null; code>, pas
* p = null; code>.