Pourquoi est l'adresse zéro utilisé pour le pointeur null?

En C (ou C++ d'ailleurs), les pointeurs sont spéciales si elles ont la valeur zéro: je suis conseillé de définir des pointeurs vers zéro après la libération de leur mémoire, parce qu'il signifie de les libérer à nouveau le pointeur n'est pas dangereux, quand j'ai appeler malloc retourne un pointeur avec la valeur zéro si elle ne peut pas me faire de la mémoire; je l'utilise if (p != 0) tout le temps à assurez-vous passé les pointeurs sont valides, etc.

Mais depuis adressage de mémoire commence à 0, n'est-ce pas 0 comme une adresse valide d'un autre? Comment peut-0 pour la manipulation de pointeurs null si c'est le cas? Pourquoi n'est-il pas un nombre négatif null à la place?

Edit:

Un tas de bonnes réponses. Je vais résumer ce qui a été dit dans les réponses exprimées comme mon propre esprit interprète et j'espère que la communauté va me corriger si j'ai mal compris.

Comme tout le reste dans la programmation, c'est une abstraction. Il suffit d'une constante, pas vraiment lié à l'adresse 0. C++0x souligne ce en ajoutant le mot-clé nullptr.
Il n'est même pas une adresse de l'abstraction, c'est la constante spécifiée par la norme C et le compilateur peut se traduire par un autre nombre, tant qu'il permet de s'assurer à jamais, il équivaut à un "réel" de l'adresse, et est égal à d'autres pointeurs null si 0 n'est pas le meilleur de la valeur à utiliser pour la plate-forme.
Dans le cas où il n'est pas une abstraction, qui a été le cas dans les premiers jours, l'adresse 0 est utilisé par le système et hors des limites du programmeur.
Mon nombre négatif suggestion a été un peu sauvage de remue-méninges, je l'avoue. À l'aide d'un entier signé pour les adresses est un peu du gaspillage si cela signifie que, en dehors de pointeur null (-1 ou quoi que ce soit) la valeur de l'espace est divisé en parts égales entre les entiers positifs qui font des adresses valides et les nombres négatifs qui sont tout simplement perdu.
Si un nombre est toujours représentable par un type de données, c'est 0. (Probablement 1 l'est aussi. Je pense à celui-bit integer qui sera de 0 ou 1 si non signé, ou tout simplement l'signé bits si signé, ou les deux bits entier qui serait [-2, 1]. Mais ensuite, vous pouvez simplement aller de 0 nul et 1 étant le seul accessible octet en mémoire.)

Il y a quand même quelque chose qui est en suspens dans mon esprit. La Pile Overflow question Pointeur à une adresse fixe me dit que même si la valeur 0 pour le pointeur null est une abstraction, d'autres valeurs de pointeur ne sont pas nécessairement. Ce qui m'amène à poster une autre Pile Overflow question, Pourrais-je veux accéder à l'adresse zéro?.

Vous pouvez tout aussi facilement changer if (p != 0) à if (p) qui est une commune de l'idiome en C et C++, bien que vous aurez à sortir de l'habitude, si vous prenez Java.
La suppression de deux fois la même chose signifie que votre code est faux. Je vous déconseille de réglage des pointeurs à null après de sorte que vous pouvez planter et de résoudre le problème, pas la supprimer. En tout cas, vous faites l'erreur de supposer une adresse est certain entier. Ce n'est pas nécessairement vrai, et 0 représente simplement un peu de vraie valeur du pointeur qui est spécifique à l'implémentation. Un "négatif adresse" n'a pas de sens, sur le plan conceptuel.
Peut-être même une bonne idée de définir un pointeur vers une adresse qui va forcer un blocage, comme 0xDEADBEEF.
La question qui ne mourra jamais!
Ne suivez pas GMan conseils. La suppression Multiple peut indiquer un problème théorique, mais ne va jamais à cause d'un problème. Un déréférencement/suppression d'un pointeur non valide sur l'autre main est toujours une question, MAIS la! ne doit pas nécessairement entraîner une panne. Il existe de nombreux cas dans lesquels vous pouvez déréférencement d'un pointeur non valide et simplement les résultats en complet de la folie et peut-être un accident plus tard. La seule fois que vous pouvez réellement pari (et non par le standard) que vous aurez un accident est si vous accédez à l'extérieur de votre programme de l'espace, qui a la valeur null sera certainement. UB peut causer des heures supplémentaires debug temps.
Le point est définie sur null -> masquer les erreurs de programmation, ne définissez pas la valeur null -> trouver les erreurs de programmation. Je ne sais pas vous, mais j'aimerais avoir mon code correct.
Les adresses ne sont pas signés,une valeur négative pourrait représentent simplement une très haute valeur en mémoire, selon la façon dont les OS cartes de mémoire virtuelle.
Depuis que cette question est dans la langue de terre, je vais souligner les adresses ne sont pas nécessairement des entiers non signés.
Depuis la non-char* pointeurs sont pratiquement toujours alignés (souvent sur une limite de 8 octets ces jours-ci), il peut être bénéfique pour les remplir de désallouer la mémoire de déchets octets dont le bit de poids faible jeu. J'utilise 0x61 mais c'est arbitraire. (L'avantage? Il vous donne une erreur/de signal due à des non-alignés d'accès lorsque vous déréférencement d'elle.)
vous n'allez pas faire votre code correct en invoquant nasale démons. La suppression des pointeurs deux fois n'est jamais un code incorrect. Il peut ou peut ne pas être un problème de conception, mais il n'est jamais une erreur.
Roberts: Selon la norme C, free()ing un pointeur deux fois les résultats dans un comportement indéfini. Je ne sais pas vous, mais j'essaie d'éviter que dans mes programmes.
oui, bien sûr j'ai oublié de préciser que c'est uniquement le cas lorsque le pointeur a été fixé à 0 depuis la libération d'un 0 ptr est un nop. Je n'ai pas de considérer qu'il est nécessaire étant donné que la position je suis, argumentant contre, c'est que de ne pas définir un pointeur à null, il fait en quelque sorte plus facile de trouver un code d'erreurs causées par la suppression d'un pointeur deux fois.
Êtes-vous d'accord que la suppression d'un pointeur deux fois, c'est parfois une erreur de logique?
Mon mentionnant des conseils pour définir le pointeur à null après la suppression causé tout un débat. Je n'ai pas vraiment a me reposer, et je certainement ne pas compter ni sur la pratique. Pour les intéressés, cette discussion a sa page ici: stackoverflow.com/questions/1931126/...
gman est correct. Le point entier dans C est pour éviter la surcharge de la vérification des contraintes au moment de l'exécution, sinon vous seriez de codage dans un sane langage comme Java. Il n'y a que quelques rares cas où vous double gratuit quelque chose, surtout depuis qu'elle est NULLE, tout d'abord..
êtes-vous sûr de dire d'accord avec gman->ne pas définir un pointeur à null après la suppression parce que vous voulez bloquer si vous avez accidentellement gratuit il de nouveau... Vos mots des sons autrement.
définir "erreur de logique". Il peut parfois être un pointeur null se faire supprimé est parce qu'il se passe autre chose qui ne devrait pas l'être. Si l'expose lui-même comme un bug dans le programme, alors c'est une erreur. Si la seule chose qui va "mal" c'est pas un pointeur null est passé à free() ou supprimer alors je pense que vous avez besoin de revoir votre définition de "erreur". En outre, l'alternative que gman propose ne garantit rien. La suppression d'un pointeur invalide, UB, pas de "crash". Plus souvent que pas, il exposera lui-même dans fous les moyens.
Roberts, je suis d'accord avec gman que vous ne devriez pas régler le pointeur de quoi que ce soit pour la marque de nullité, sauf si c'est votre "vivant" drapeau... c'est à dire: Si vous avez une structure avec 3 pointeurs, et un drapeau en disant: météo la structure est en vie, vous ne réglez que le drapeau et de laisser le pointeur en tant que-est après leur libération.
Si vous passez un pointeur vers une fonction qui estime que le pointeur est encore vivante, et il n'est pas, alors que c'est une erreur de logique. Même quand ils ne sont pas la cause directe de la plante, de les éviter n'est pas sans mérite. Il a tendance à faire des modifications plus facile si le code fonctionne comme prévu, plutôt que comme promis. Je ne veux pas dire que vous ne devriez pas régler morts pointeurs à null, mais en disant double suppression n'est jamais une erreur est tout simplement faux.
"adressage de mémoire commence à 0" [citation nécessaire]
Un plus pinailleurs détail 😬 Un un bits entier signé est composée de deux valeurs: 0 et -1, représenté sous la forme de 0 et de 1 que la seule valeur du bit, respectivement 🙂
Paramètre un pointeur à null après la libération il peut cacher double-libre d'erreurs de conception. Ne pas le mettre à null peut en cacher utilisé après libéré des erreurs. Ce dernier est un ordre de grandeur plus graves. Si un pointeur n'est plus valide, vous voulez toute tentative de déférence pour résultat bien défini comportement au lieu d'imprévisible de corruption de la mémoire. Ces bugs sont l'enfer de la piste vers le bas et peut-être un trou de sécurité.

InformationsquelleAutor Joel | 2010-05-03

c c++memory pointers

62

2 points:
- seulement la valeur de la constante 0 dans le code source est le pointeur null - la mise en œuvre de compilateur peut utiliser quelle que soit la valeur qu'elle veut ou a besoin dans l'exécution de code. Certaines plates-formes ont une valeur de pointeur qui s 'invalide' que la mise en œuvre pourrait utiliser comme pointeur null. La FAQ C a une question, "Sérieusement, avez-vous des machines réelles vraiment utilisé différente de zéro pointeurs null, ou des représentations différentes pour les pointeurs de types différents?", qui souligne plusieurs plates-formes, qui ont utilisé cette propriété de 0 étant le pointeur null en C source tandis que représentée différemment lors de l'exécution. La norme C++ a une note qui précise que la conversion "intégrante expression constante avec une valeur de zéro donne toujours un pointeur null, mais la conversion d'autres expressions qui ont la valeur zéro n'a pas besoin de donner un pointeur null".
- une valeur négative peut être tout aussi utilisable par la plate-forme comme une adresse - le C standard avait simplement choisi quelque chose à utiliser pour indiquer un pointeur null, et zéro a été choisi. Je suis honnêtement pas sûr si d'autres sentinelles valeurs ont été considérées.
Les seules exigences pour un pointeur null sont:
- c'est la garantie de comparer l'inégalité à un pointeur sur un objet réel
- deux pointeurs null permettra de comparer l'égalité (C++ affine ce que ce ne doit tenir pour les pointeurs de même type)
- +1 je soupçonne 0 a été choisi seulement pour des raisons historiques. (0 étant un point de départ et l'adresse invalide, la plupart du temps.) Bien sûr, en général, une telle hypothèse n'est pas toujours vrai, mais 0 fonctionne assez bien.
- L'espace peut également avoir été un facteur contributif. Dans les jours quand C a été développé d'abord, la mémoire est BEAUCOUP plus cher que maintenant. Le nombre de zéro peut être facilement calculée à l'aide d'une instruction XOR ou sans la nécessité de charger une valeur immédiate. En fonction de l'architecture, ce qui pourrait potentiellement économiser de l'espace.
- Vous êtes correct. Sur le début de l'Uc, de la mémoire de l'adresse zéro était spécial et avait du matériel de protection contre l'accès de l'exécution de logiciel (dans certains cas, c'était le début de l'vecteur de reset, et la modification peut empêcher la CPU de réinitialisation ou de démarrage). Les programmeurs utilisé ce matériel de protection comme une forme de détection d'erreur dans leur logiciel, laissant le CPU adresse de décoder la logique de vérifier la non initialisée ou des pointeurs invalides au lieu d'avoir à passer des instructions du PROCESSEUR pour le faire. La convention reste à ce jour, même si le but de l'adresse zéro peut avoir changé.
- Minix 16 bits compilateur utilisé 0xFFFF pour les NULS.
- Dans de nombreux systèmes embarqués, 0 est une adresse valide. La valeur -1 (tous les bits) est également une adresse valide. Les sommes de contrôle pour les Rom sont difficiles à calculer lorsque les données commence à l'adresse 0. 🙁
- Acceptées sur la combinaison des avantages de posséder le cœur de la plupart des réponses et de décompte des voix.
- Dans certaines machines de test pour 0 est plus rapide que de test pour les autres valeurs. (Test pour l'indicateur de zéro après une opération), Ce qui pourrait avoir été un facteur contribuant également.
- 0 fait un joli pointeur null constante parce que c'est aussi un zéro pour les autres arithmétique types. Si x est un type scalaire, alors x = 0 définit pointeur null, 0.0 ou un entier de 0, en fonction de son type. Aussi, l'initialiseur de {0} pouvez initialiser rien: pointeur, struct, nombre, tableau, ... c'est parce que, même si l'objet en cours d'initialisation est scalaire, il peut y avoir en option des accolades autour de l'initialiseur.
- Ne Processeurs modernes / MMU protéger contre l'accès à la 0x0 ainsi? Ce qui est, est un Anneau 0 noyau autorisé à accéder à 0x0?
- Donc, il n'y a aucune garantie que dans if (p) ..., la condition est évaluée à false si et seulement si p est un pointeur null? Dois-je vraiment le comparer avec nullptr (ou NULL)?
- est bien parce que le standard de dire que "la première substatement est exécutée si l'expression compare inégale à 0". Il y a une langue similaire pour le contrôle de l'expression dans les boucles. La norme C++ cadres en termes de bool expression et une "valeur de pointeur null" convertit à false, sinon true. La valeur de pointeur null est ce que le pointeur null constante convertit lorsqu'il est utilisé comme un type de pointeur.
- "utilisé cette propriété de 0 étant le pointeur null dans le source C" est de trop. 0 n'est pas un pointeur, ni pointeur null. C'est une constante entière avec le type int. Avec #define NULL 0, NULL est le null le pointeur constant, mais il n'est pas un pointeur dans le cas, mais une int. Avec #define NULL ((void*)0), NULL est aussi le null le pointeur constant, et un pointeur dans le cas. En C, NULL, convertis en un type pointeur, est un pointeur null.
- Oui, certains Isa pouvez créer un 0 plus facilement qu'un -1, et un petit entière non nulle constante (qui pourrait s'adapter dans un opérande immédiat sur la plupart des machines) n'aurait pas de sens. Aussi, test pour le zéro a un soutien spécial dans la plupart des Isa. par exemple, pour analyser un littéral entier, vous avez probablement ajouté le dernier chiffre au total avec une instruction set condition de l'UC-codes, aka drapeaux, sur les Processeurs qui utilisent un registre de statut du tout. (La plupart des autres que MIPS). Il y a toujours un indicateur de zéro que de définir si le dernier résultat était nul, de sorte que vous n'avez pas besoin d'un autre comparer instruction, juste jz ou jnz.
InformationsquelleAutor Michael Burr
30

Historiquement, l'adresse de l'espace commençant à 0 a toujours été ROM, utilisé pour certains systèmes d'exploitation ou le faible niveau d'interruption de traitement des routines, de nos jours, puisque tout est virtuel (y compris l'adresse de l'espace), le système d'exploitation permet de mapper tout d'allocation d'adresse, de sorte qu'il peut ne PAS allouer quelque chose à l'adresse 0.
- Ce joli bien est-il. C'est par l'historique de la convention, et la première adresses ont été utilisés pour les gestionnaires d'interruption, sont donc inutilisables pour les programmes normaux. Aussi, 0 est "vide", ce qui peut être interprété comme sans valeur / pas de pointeur.
InformationsquelleAutor Aviad P.
15

IIRC, le "pointeur null" la valeur n'est pas garantie à zéro. Le compilateur traduit de 0 quelle que soit la valeur "null est approprié pour le système (ce qui dans la pratique est probablement toujours à zéro, mais pas nécessairement). La même traduction est appliquée chaque fois que vous comparez un pointeur contre zéro. Parce que vous ne pouvez comparer les pointeurs les uns contre les autres et contre ce spécial-la valeur 0, il isole le programmeur de savoir quoi que ce soit à propos de la représentation de la mémoire du système. Quant à savoir pourquoi ils ont choisi de 0 au lieu de 42 ou somesuch, je suppose que c'est parce que la plupart des programmeurs commencent à compter à partir de 0 🙂 (d'ailleurs, sur la plupart des systèmes, 0 est la première adresse de la mémoire et qu'ils voulaient qu'il soit pratique, car dans la pratique des traductions comme je parle rarement lieu; la langue juste pour eux).
- Vous avez mal compris. La constante 0 est toujours le pointeur null. Ce que @meador est en train de dire, c'est qu'il est possible que le pointeur null (indiqué par la constante 0) ne correspond pas à l'adresse zéro. Sur certaines plates-formes, la création d'un pointeur null (int* p = 0) pourrait créer un pointeur contenant la valeur 0xdeadbeef ou toute autre valeur qu'il préfère. 0 est un pointeur null, mais un pointeur null est pas nécessairement un pointeur vers l'adresse zéro. 🙂
- Un pointeur NULL est une valeur réservée et selon le compilateur pourrait être un motif de bits. Pointeur NULL ne signifie pas qu'il pointe vers l'adresse 0.
- Mais @Jalf.com, la constante 0 n'est pas toujours le pointeur null. C'est ce qu'on écrit quand on veut le compilateur à remplir dans la plate-forme réel pointeur null pour nous. Pratiquement parlant, le pointeur null en général, t correspond à l'adresse de zéro, bien que, et je interpréter Joel est question que de se demander pourquoi ce qui est. Il y a soi-disant un valide octet de mémoire à cette adresse, après tout, alors pourquoi ne pas utiliser une adresse inexistante d'un inexistante octet au lieu de la suppression d'un octet valide de jouer? (Je suis en train d'écrire ce que j'imagine Joël a été pensée, pas une question que je me pose.)
- En quelque sorte. Je sais ce que tu veux dire, et vous avez raison, mais moi aussi.:) La constante de type entier 0 représente le pointeur null dans un code source. La comparaison d'un pointeur null à 0 rendements vrai. L'attribution de 0 à un pointeur de jeux de pointeur null. 0 est le pointeur null. Mais la représentation en mémoire d'un pointeur null peut être différent de zéro séquence de bits. (De toute façon, mon commentaire était en réponse à @Justin est maintenant supprimé de commentaire, pas de @Joel est question. 🙂
- Vous avez besoin de certaines conditions pour être clair, je pense. 🙂 Du §4.10/1: "Un null le pointeur constant est un élément constant de l'expression rvalue de type entier qui prend la valeur de zéro. Un pointeur null constante peut être converti en un type pointeur; le résultat est le valeur de pointeur null de ce type et se distingue de tous les autres de la valeur de pointeur vers l'objet ou le pointeur de fonction type."
- En C, 0 n'est pas un pointeur null - c'est un int. Exemple: printf("%p\n", 0); UB. 0, lorsqu'ils sont convertis en un type pointeur, est un pointeur null.
InformationsquelleAutor rmeador
15

Vous devez être l'incompréhension de la signification de la constante de zéro dans le pointeur de contexte.

Ni en C et en C++ les pointeurs peuvent "ont une valeur de zéro". Les pointeurs ne sont pas arithmétique des objets. Ils canot ont des valeurs numériques comme "zéro" ou "négatif" ou quoi que ce soit de cette nature. Donc votre affirmation à propos de "pointeurs ... ont la valeur zéro" n'a simplement aucun sens.

Dans le C & C++ les pointeurs peuvent avoir réservé de pointeur null valeur. La représentation réelle de pointeur null valeur n'a rien à voir avec une quelconque "zéros". Il peut être absolument n'importe quoi approprié pour une plate-forme donnée. Il est vrai que sur la plupart des plaforms de pointeur null valeur est représentée physiquement par une réelle zéro la valeur de l'adresse. Cependant, si sur certaines plate-forme de l'adresse 0 est en fait utilisé pour un certain but (par exemple, vous pourriez avoir besoin pour créer des objets à l'adresse 0), le pointeur null valeur sur cette plate-forme sera probablement différent. Il pourrait être physiquement représenté par 0xFFFFFFFF la valeur de l'adresse ou de 0xBAADBAAD la valeur de l'adresse, par exemple.

Néanmoins, indépendamment de la façon dont le pointeur null valeur est representee sur une plate-forme donnée, dans votre code, vous pourrez toujours continuer à désigner null-pointeurs en constante 0. Pour affecter un pointeur null valeur à un pointeur, vous pourrez continuer à utiliser des expressions comme p = 0. C'est le compilateur a la responsabilité de réaliser ce que vous voulez et de les traduire dans le bon de pointeur null la valeur de la représentation, c'est à dire à la traduire dans le code qui permettra de mettre la valeur de l'adresse de 0xFFFFFFFF dans le pointeur p, par exemple.

En bref, le fait que vous utilisez 0 dans votre sorce code pour générer de pointeur null valeurs ne signifie pas que le pointeur null valeur est en quelque sorte lié à l'adresse 0. Le 0 que vous utilisez dans votre code source est juste "sucre syntaxique" qui n'a absolument aucun rapport avec la réalité physique de l'adresse de pointeur null valeur est "pointant" à.
- <citation>les Pointeurs ne sont pas arithmétique des objets</citation> l'arithmétique des pointeurs est assez bien défini en C et C++. Une partie de la condition est que les deux pointeurs point dans le même composite. Le pointeur null n'est pas le point de tout composite afin de l'utiliser dans l'arithmétique des pointeurs expressions est illégal. Par exemple, il n'est pas garanti que (p1 - nullptr) - (p2 - nullptr) == (p1 - p2).
- Voigt: Le langage de spécification définit la notion de l'arithmétique type. Tout ce que je dis, c'est que les types pointeur n'appartiennent pas à la catégorie de l'arithmétique types. l'arithmétique des pointeurs est un autre et sans aucun rapport avec l'histoire, un simple linguistiques coïncidence.
- Comment est quelqu'un de lire arithmétique des objets supposé savoir, il signifie "dans le sens de l'arithmétique types" et non pas "dans le sens des opérateurs arithmétiques" (dont plusieurs sont utilisables sur les pointeurs) ou "dans le sens de l'arithmétique des pointeurs". Autant que linguistique, les coïncidences sont concernés, l'arithmétique de l'objet a plus de lettres en commun avec de l'arithmétique des pointeurs que arithmétique types. Dans le même temps, la norme ne parle de la valeur du pointeur. Le posteur d'origine probablement dire integer représentation d'un pointeur plutôt que la valeur du pointeur, et NULL explicitement n'a pas besoin d'être représenté par un 0.
- Ainsi, par exemple, le terme scalaire objets en C/C++ terminologie est juste un raccourci pour objets de types scalaires (comme POD objets, = objets de POD types). J'ai utilisé le terme de l'arithmétique des objets exactement de la même façon, les objets de l'arithmétique types. Je s'attendre à "quelqu'un" pour le comprendre de cette façon. Quelqu'un qui n'a pas toujours la possibilité de demander des éclaircissements.
- j'ai travaillé sur un système où (dans la mesure où le matériel est concerné), la valeur null est 0xffffffff et 0 est parfaitement valide l'adresse
InformationsquelleAutor AnT
8

Mais depuis adressage de mémoire commence à 0, n'est-ce pas 0 comme une adresse valide d'un autre?

Sur certains/beaucoup/tous les systèmes d'exploitation, la mémoire, l'adresse 0 est spécial d'une certaine façon. Par exemple, il est souvent mappés à des invalides/inexistant mémoire, ce qui provoque une exception si vous essayez d'y accéder.

Pourquoi ce n'est pas un nombre négatif null à la place?

Je pense que les valeurs de pointeur sont généralement traités comme des nombres non signés: sinon pour exemple un pointeur 32 bits ne serait en mesure d'adresse 2 GO de mémoire, au lieu de 4 GO.
- J'ai codé sur un appareil où l'adresse zéro est une adresse valide, et il n'y avait pas de protection de la mémoire. Pointeurs Null étaient également tous les bits à zéro; si vous avez accidentellement écrit à un pointeur null, alors vous dynamité sur les paramètres du système d'exploitation à l'adresse zéro; hilarité généralement de ne pas s'ensuivre.
- Oui: non-protégé-mode de CPU x86, par exemple, l'adresse 0 est le vecteur d'interruption de la table.
- Sur la non-protégés en mode x86, l'adresse zéro, en particulier, est la division par zéro vecteur d'interruption, que certains programmes peuvent avoir des raisons tout à fait légitimes pour l'écriture.
- Même sur les plates-formes de stockage utilisable commencerait à l'adresse physique, zéro, un C mise en œuvre pourrait facilement utiliser l'adresse zéro de tenir un objet dont l'adresse n'est jamais prise, ou bien il suffit de laisser le premier mot de la mémoire inutilisée. Sur la plupart des plates-formes, de comparer avec zéro enregistre une instruction contre les comparer avec autre-chose, de sorte que même perdre le premier mot de stockage serait moins cher que l'utilisation d'une adresse zéro pour la valeur null. Notez qu'il n'est pas obligatoire que les adresses de choses ne sont pas couverts par la Norme (par exemple, I/O ports ou des vecteurs d'interruption) comparer l'inégalité null, ni que...
- ...le processus de système de pointeur null accède à tout différemment de tout autre, de sorte que tous les bits à zéro est généralement une amende adresse pour "null" même sur des systèmes où les accès à l'emplacement physique de zéro serait utile et significatif.
InformationsquelleAutor ChrisW
5

J'imagine que la magie de la valeur 0 a été pris pour définir un pointeur non valide, car il pourrait être testée avec moins d'instructions. Certains langages machine automatiquement le zéro et de signer des drapeaux selon les données lors du chargement des registres, de sorte que vous pourraient test pour un pointeur null avec une simple charge, et les instructions de branchement sans faire un distinct comparer instruction.

(La plupart des Isa seulement définir des indicateurs sur ALU instructions, pas de charges, si. Et en général, vous ne produisent pas des pointeurs par calcul, sauf dans le compilateur lors de l'analyse C source. Mais au moins, vous n'avez pas besoin de l'arbitraire d'un pointeur de largeur constante à comparer.)

Sur le Commodore Pet, Vic20, et C64 qui ont été les premières machines, j'ai travaillé sur, la RAM a commencé à l'emplacement 0, donc il était tout à fait valable à lire et à écrire à l'aide d'un pointeur null si vous avez vraiment voulu.

InformationsquelleAutor KPexEA
3

Je pense que c'est juste une convention. Il doit y avoir une valeur d'un pointeur invalide.

Vous venez de perdre un octet de l'adresse de l'espace, c'est rarement un problème.

Il n'y a pas négatif des pointeurs. Les pointeurs sont toujours pas signés. Aussi, si ils pouvaient être négatifs de votre convention signifie que vous perdez la moitié de l'espace d'adressage.
- Remarque: vous n'avez pas perdre de l'espace d'adresse; vous pouvez obtenir un pointeur vers l'adresse 0 par: char *p = (char *)1; --p; . Depuis comportements sur un pointeur null est pas défini par la norme, ce système peut avoir p réellement à lire et écrire l'adresse 0, incrément de donner l'adresse de 1, etc.
- Une mise en œuvre dont l'adresse est égale à zéro est un matériel valide l'adresse peut parfaitement légitimement définir le comportement de char x = ((char*)0); à lire l'adresse zéro et de stocker cette valeur dans x. Ce code donnerait un Comportement Indéfini de toute mise en œuvre, qui n'a pas de définir son comportement, mais le fait qu'une norme dit que quelque chose est un Comportement Indéfini, en aucune façon, interdit implémentations d'offrir à leurs propres spécifications pour ce qu'il va faire.
- ITYM *(char *)0. C'est vrai, mais dans ma suggestion, la mise en œuvre n'a pas besoin de définir le comportement de *(char *)0 ou de tout autre pointeur null opérations.
- Le comportement de char *p = (char*)1; --p; ne serait défini par la norme, si cette séquence a été réalisée après un pointeur vers quelque chose d'autre que le premier octet d'un objet avait été jeté à un intptr_t, et le résultat de cette fonte qui s'est passé pour obtenir la valeur 1, et dans ce cas particulier, le résultat de --p donnerait un pointeur vers l'octet précédent, celui dont la valeur du pointeur, lors de la fonte de intptr_t, avaient donné 1.
InformationsquelleAutor Axel Gneiting
3

Bien que C utilise de 0 à représenter le pointeur null, gardez à l'esprit que la valeur du pointeur lui-même ne peut pas être un zéro. Cependant, la plupart des programmeurs ne jamais utiliser les systèmes où le pointeur null est, en fait, 0.

Mais pourquoi zéro? Eh bien, c'est une adresse que tous les systèmes d'actions. Et bien souvent, le faible adresses sont réservés pour le système d'exploitation fins ainsi la valeur fonctionne bien comme étant hors-limites pour les programmes d'application. Accidentelle d'affectation d'une valeur de nombre entier à un pointeur est susceptible de mettre fin à zéro comme rien d'autre.
- La raison la plus probable derrière tout cela est que: il est bon marché à la main à la mémoire qui est pré-initialisé à zéro et pratique d'avoir des valeurs en mémoire représenter quelque chose de significatif, comme nombre entier 0, point flottant 0.0 et des pointeurs null. Les données statiques en C qui est initialisée à zéro/null n'a pas à occuper tout l'espace dans l'exécutable et correspond à un zéro-rempli à bloc lors de la charge. Zéro peut bénéficier d'un traitement spécial dans la machine langues: facile zéro comparaisons comme "branche si égal à zéro", etc. MIPS a même un mannequin de registre qui est juste une constante de zéro.
InformationsquelleAutor George Phillips
2

Historiquement, la faible mémoire d'une application a été occupé par les ressources système. C'est dans ces jours que zéro est devenu la valeur null par défaut.

Alors que ce n'est pas nécessairement vrai pour les systèmes modernes, il est toujours une mauvaise idée de mettre les valeurs de pointeur à tout sauf à ce que l'allocation de mémoire a vous a remis.

InformationsquelleAutor Fred Haslam
2

Quant à l'argument de la non définition d'un pointeur à null après la suppression de sorte qu'à l'avenir les supprime "exposer les erreurs"...

Si vous êtes vraiment, vraiment inquiet à propos de ce alors une meilleure approche, qui est garanti pour fonctionner, est de tirer parti de la fonction assert():
```
...
assert(ptr && "You're deleting this pointer twice, look for a bug?");
delete ptr;
ptr = 0;
...
```
Cela exige un peu de saisie, et un supplément de vérifier au cours de debug, mais il est certain à vous donner ce que vous voulez: avis quand ptr est supprimé 'double'. L'alternative donnée dans le commentaire la discussion, ne pas fixer le pointeur à null de sorte que vous aurez un accident, est tout simplement de ne pas être couronnée de succès. Pire, contrairement à ce qui précède, il peut provoquer une panne (ou bien pire!) sur un utilisateur si l'un de ces "bugs" se fait grâce à l'étagère. Enfin, cette version vous permet de continuer à exécuter le programme pour voir ce qui se passe réellement.

Je me rends compte ce n'est pas la réponse à la question posée, mais j'étais inquiet que quelqu'un en lisant les commentaires, peut venir à la conclusion qu'il est considéré comme une "bonne pratique" pour ne PAS définir des pointeurs à 0 si il est possible qu'ils obtiennent envoyé à free() ou supprimer deux fois. Dans de rares cas, lorsque c'est possible, il n'est JAMAIS une bonne pratique d'utiliser un Comportement non défini comme un outil de débogage. Personne n'a jamais eu à chasser vers le bas d'un bug qui a finalement été causé par la suppression d'un pointeur non valide serait de proposer cette. Ces types d'erreurs, de prendre des heures à traquer et presque toujours l'effet du programme sur un de totalement inattendu qu'il est difficile, voire impossible, de remonter à l'origine du problème.

InformationsquelleAutor Crazy Eddie
2

Une importante raison pour laquelle de nombreux systèmes d'exploitation utilisent tous les bits à zéro pour le pointeur null représentation, c'est que cela signifie memset(struct_with_pointers, 0, sizeof struct_with_pointers) et similaire sera mis tous les pointeurs à l'intérieur de struct_with_pointers de pointeurs null. Ce n'est pas garanti par la norme, mais beaucoup, beaucoup de programmes de l'assumer.

InformationsquelleAutor zwol
1

Dans l'une des anciennes DÉC machines (PDP-8, je crois), le runtime C la mémoire de protéger la première page de la mémoire, de sorte que toute tentative d'accès à la mémoire dans ce bloc serait la cause d'une exception soulevée.
- Le PDP-8 n'avait pas de compilateur C. Le PDP-11 n'avait pas de protection de la mémoire et de l'VAX était infâme de silence pour le retour de 0 à pointeur NULL déréférence. Je ne suis pas sûr de la machine, elle se réfère.
InformationsquelleAutor Paul Tomblin
1

Le choix de la sentinelle de la valeur est arbitraire, et c'est en fait traitée par la prochaine version de C++ (officieusement connu comme "C++0x", les plus susceptibles d'être connu dans l'avenir que la norme ISO C++ 2011), avec l'introduction de la clé nullptr pour représenter une valeur null évalués pointeur. En C++, la valeur 0 peut être utilisée comme initialisation d'expression pour toute POD et pour n'importe quel objet avec un constructeur par défaut, et il a un sens particulier de l'attribution de la sentinelle de la valeur dans le cas d'un pointeur d'initialisation. Quant à savoir pourquoi une valeur négative n'a pas été choisi, adresses sont habituellement de 0 à 2^N-1 pour une certaine valeur de N. En d'autres termes, les adresses sont généralement traitées comme des valeurs non signées. Si la valeur maximale ont été utilisés comme sentinelles de la valeur, alors il faudrait varier d'un système à l'autre en fonction de la taille de la mémoire alors que 0 est toujours représentable adresse. Il est également utilisé pour des raisons historiques, comme la mémoire de l'adresse 0 est généralement inutilisable dans les programmes, et de nos jours la plupart des OSs ont des parties du noyau chargé dans le bas de page(s) de mémoire, et ces pages sont généralement protégés de telle façon que si touché (déréférencé) par un programme (sauf le noyau) sera la cause d'une anomalie.

InformationsquelleAutor Michael Aaron Safyan
1

Il doit avoir une certaine valeur. Évidemment, vous ne voulez pas marcher sur les valeurs que l'utilisateur peut légitimement souhaitez utiliser. Je présume que, depuis la C runtime fournit le segment BSS pour initialisé à zéro des données, il fait un certain degré de sens à interpréter de zéro, comme une liste non-initialisé la valeur du pointeur.

InformationsquelleAutor JustJeff
0

Rarement d'un système d'exploitation vous permettent d'écrire à l'adresse 0. Il est commun de bâton OS spécifique des choses bas dans la mémoire; à savoir, Idt, les tables de pages, etc. (Les tables sont dans la mémoire RAM, et il est plus facile de coller au fond que d'essayer de déterminer où le haut de RAM.) Et pas d'OS dans son esprit droit vous permettra de modifier les tables système de bon gré mal gré.

Cela peut ne pas avoir été sur le K&R esprits quand ils ont fait le C, mais il (ainsi que le fait que 0==null est assez facile à retenir) fait 0 un choix populaire.
- Ce n'est pas vrai en mode protégé, et en fait, sur certaines configurations Linux, vous peut écrire à l'adresse virtuelle 0.
InformationsquelleAutor cHao
0

La valeur 0 est une valeur spéciale qui prend différentes significations dans des expressions spécifiques. Dans le cas des pointeurs, comme cela a été souligné à plusieurs reprises, il est utilisé probablement parce qu'à l'époque c'était le moyen le plus pratique de dire "insérer la valeur par défaut sentinelle valeur ici." Comme une expression constante, il n'a pas la même signification qu'au niveau du bit à zéro (c'est à dire, tous les bits à zéro) dans le cadre d'un pointeur d'expression. En C++, il existe plusieurs types qui n'ont pas de bit-à-bit zéro de la représentation de NULL comme pointeur de membre, et un pointeur de fonction membre.

Heureusement, C++0x a un nouveau mot clé "expression qui signifie un connu de pointeur non valide qui n'a pas de carte d'or au niveau du bit à zéro pour l'intégrale des expressions": nullptr. Bien qu'il existe quelques systèmes que vous pouvez cibler avec C++ qui permettent de déférence de l'adresse 0 sans barfing, de sorte que programmeur, méfiez-vous.

InformationsquelleAutor MSN
0

Il y a déjà beaucoup de bonnes réponses dans ce fil, il y a probablement plusieurs raisons pour préférer la valeur 0 des pointeurs null, mais je vais en ajouter deux de plus:
- En C++, zéro-initialisation d'un pointeur va le mettre à null.
- Sur de nombreux processeurs, il est plus efficace de définir une valeur à 0 ou à tester égal/pas égal à 0 que pour toute constante.
InformationsquelleAutor Mark Ransom
0

Cela dépend de la mise en œuvre des pointeurs en C/C++. Il n'y a pas de raison particulière pourquoi NULL est équivalent dans les affectations à un pointeur.

InformationsquelleAutor Nagabhushan Baddi
-1

Il y a des raisons historiques à cela, mais il y a aussi des raisons d'optimisation pour elle.

Il est commun pour le système d'exploitation afin d'assurer un processus avec des pages de mémoire initialisé à 0. Si un programme veut interpréter la partie de la page de mémoire comme un pointeur, alors il est de 0, donc il est assez facile pour le programme afin de déterminer que le pointeur n'est pas initialisé. (ceci ne fonctionne pas si bien lorsqu'il est appliqué à initialisée flash pages)

Une autre raison est que le nombre de (nombre de processeurs, il est très très facile de tester une valeur d'équivalence de 0. Il est parfois un gratuit comparaison fait sans toutes les instructions supplémentaires nécessaires, et peuvent généralement être fait sans avoir à fournir une valeur de zéro dans un autre registre, ou comme un littéral dans le volet enseignement de comparer.

Pas cher des comparaisons pour la plupart des processeurs sont signés, à moins de 0, et égale à 0. (signé supérieur à 0 et n'est pas égal à 0 sont sous-entendus par ces deux)

Depuis 1 valeur de toutes les valeurs possibles doit être réservé à de mauvaises ou non initialisé, alors vous pourriez aussi bien le faire celui qui a le moins cher le test d'équivalence de la mauvaise valeur. Cela est également vrai pour le '\0' terminé de chaînes de caractères.

Si vous essayez d'utiliser plus ou moins de 0 pour cet effet, puis vous vous retrouvez à dégainer votre plage d'adresses dans la moitié.

InformationsquelleAutor nategoose
-2

La constante 0 est utilisé à la place de NULL parce que le C a été réalisée par des hommes des cavernes des milliards d'années, NULL, NIL, ZIP, ou NADDA aurait fait beaucoup plus de sens que 0.

Mais depuis adressage de mémoire commence à
0, n'est-ce pas 0 comme une adresse valide
d'un autre?

En effet. Bien que beaucoup de systèmes d'exploitation interdire vous de la cartographie quelque chose à l'adresse de zéro, même dans un espace d'adresse virtuelle (les gens ont réalisé que C est une insécurité linguistique, et qui reflète déréférencement de pointeur null bugs sont très communes, a décidé de les "fixer" par dissallowing l'utilisateur code de la carte à la page 0; Ainsi, si vous appelez une fonction de rappel, mais le rappel pointeur est NULL, vous ne finissent par l'exécution d'un code arbitraire).

Comment peut-0 pour la manipulation de la valeur null
les pointeurs si c'est le cas?

Parce que 0 en comparaison à un pointeur sera remplacé par un de mise en œuvre spécifiques valeur, qui est la valeur de retour de malloc sur un malloc échec.

Pourquoi ce n'est pas un nombre négatif null
au lieu de cela?

Ce serait encore plus de confusion.
- Votre point de vue sur les "hommes des cavernes", etc. sans doute se trouve à la racine de celui-ci, mais je pense que les détails sont différents. Les premières formes de ce qui a évolué dans le C ont été conçus pour fonctionner sur une architecture particulière où un int n'était pas seulement la même taille qu'un pointeur--dans de nombreux contextes, une int et un pointeur peut être utilisé de façon interchangeable. Si une routine attend un pointeur et on est passé dans un entier 57, la routine serait d'utiliser l'adresse avec le même modèle de bits que le nombre de 57. Sur ces machines, le motif de bits pour représenter un pointeur null est 0, donc en passant un int 0 passer un pointeur null.
- Depuis ce temps, le C a évolué de sorte qu'il peut être utilisé pour écrire des programmes pour une grande variété d'autres machines avec différentes représentations des nombres et des pointeurs. Tandis que les non-zéro constantes numériques ont été rarement utilisés comme pointeurs, les constantes numériques zéros ont été largement utilisés pour représenter des pointeurs null. Pour interdire un tel usage aurait brisé le code existant, de sorte que les compilateurs ont été traduit en une valeur numérique zéro en ce que la mise en œuvre utilise pour représenter un pointeur null.
InformationsquelleAutor L̲̳o̲̳̳n̲̳̳g̲̳̳p̲̳o̲̳̳k̲̳̳e̲̳̳
-5

(Veuillez Lire Ce Paragraphe Avant de Lire le Post. Je demande à toute personne intéressée par la lecture de ce post devrait essayer de le lire attentivement, et bien sûr ne pas downvote jusqu'à ce que vous le comprendre complètement, merci.)

Il est maintenant wiki de la communauté, en tant que tel, si quelqu'un n'est pas d'accord avec les concepts, veuillez la modifier, avec une explication claire et détaillée de ce qui est mal et pourquoi, et si possible merci de citer les sources ou fournir la preuve que l'on peut reproduire.

Réponse

Voici quelques autres raisons qui pourraient être les facteurs sous-jacents NULL==0
1. Le fait que le zéro est faux, alors on peut le faire directement if(!my_ptr) au lieu de if(my_ptr==NULL).
2. Le fait que les non-initiés mondiale entiers sont initialisés par défaut à tous les zéros, et en tant que tel un pointeur de tous les zéros serait considéré comme non initialisée.
Ici, je Voudrais Dire Un Mot Sur les Autres Réponses

Pas Parce Que Du Sucre Syntaxique

Dire que NULL est égal à zéro à cause du sucre syntaxique, n'a pas trop de sens, si oui, pourquoi ne pas utiliser l'index 0 du tableau de tenir sa longueur?

En fait C est le langage qui ressemble le plus à la mise en œuvre interne, est-il sensé de dire que C repris de zéro juste parce que du sucre syntaxique? Ils seraient plutôt de fournir un mot-clé null (comme de nombreuses autres langues) plutôt que de la cartographie de zéro à la valeur NULL!

En tant que tel alors qu'aujourd'hui c'est peut-sucre syntaxique, il est clair que l'intention originale du langage C les développeurs n'était pas de sucre syntaxique, comme je le montrerai plus loin.

1) La Spécification

Pourtant, s'il est vrai que le C les spécifications parler de la constante 0 comme pointeur null (section 6.3.2.3), et également définir la valeur NULL à la mise en œuvre définies (article 7.19 dans le C11 spécification, et 7.17 dans le C99 spécification), le fait demeure que, dans le livre "le Langage C", écrit par les inventeurs de C comme indiqué dans la section 5.4:

C garantit que le zéro n'est pas une adresse valide pour les données, une valeur de retour de zéro peut être utilisé pour signaler un événement anormal, dans ce cas, pas d'espace.

Pointeur et les nombres entiers ne sont pas interchangeables, le Zéro est la seule exception: la constante de zéro peut être attribué à un pointeur, et un pointeur peut être comparé avec la constante de zéro. La constante symbolique NULL est souvent utilisé à la place de zéro, comme un mnémonique pour indiquer plus clairement que c'est une valeur spéciale pour un pointeur. NULL est défini . Nous allons utiliser la valeur NULL désormais.

Comme on peut le voir (à part la mention "adresse zéro") au moins à l'origine, l'intention des auteurs de C étaient de l'adresse zéro, et non pas la constante de zéro, en outre, il ressort de cet extrait que la raison pour laquelle la spécification parle de la constante zéro est probablement de ne pas exclure une expression qui est évaluée à zéro, mais au lieu d'inclure la constante entière zéro pour être la seule constante entière autorisés pour une utilisation dans un pointeur de contexte sans casting.

2) Résumé

Tandis que la spécification ne dit pas explicitement qu'une adresse zéro peut être traitée différente de la constante de zéro, il n'est pas dit que non, et le fait lorsque vous traitez avec les de pointeur null constante il n'a pas la prétention d'être mise en œuvre définies comme il le fait par le NULL défini constante, au lieu de le réclamer à zéro, montre qu'il pourrait y avoir une différence entre la constante de zéro et l'adresse zéro.

(Si c'est cependant le cas, je me demande juste pourquoi NULL est définie par l'implémentation, puisque dans un tel cas, la valeur NULL peut être aussi la constante de zéro, comme le compilateur a tout de même de convertir tous les zéro constantes dans la mise en œuvre effective définie NULLE?)

Cependant, je ne vois pas ce en action réelle, et dans les plates-formes de l'adresse zéro et la constante de zéro sont traités de la même façon, et jetez le même message d'erreur.

En outre, le fait est qu'aujourd'hui les systèmes d'exploitation sont en fait la réservation de la totalité de la première page (plage de 0x0000 à 0xFFFF), juste pour empêcher l'accès à l'adresse zéro à cause de C est de pointeur NULL (voir http://en.wikipedia.org/wiki/Zero_page, ainsi que "Windows Via C/C++ par Jeffrey Richter et Christophe Nasarre (publié par Microsoft Press)").

Donc je voudrais demander de quelqu'un qui prétend réellement avoir vu en action, s'il vous plaît spécifier la plate-forme, et le compilateur, et le code exact, effectivement, il l'a fait, (même si en raison de la vague de la définition dans la spécification [comme je l'ai montré] quel que soit le compilateur et de la plate-forme est libre de faire ce qu'il veut).

Cependant apparemment, il semble que les auteurs de C n'a pas eu cela à l'esprit, et ils parlaient de "adresse zéro", et que "C garantit que ce n'est pas une adresse valide", ainsi que "la valeur NULL est juste un mnémonique", montrant clairement qu'il avait initialement l'intention n'était pas de "sucre syntaxique".

Non Pas Parce Que Le Système D'Exploitation

Réclame aussi que le système d'exploitation refuse l'accès à l'adresse zéro, pour quelques raisons:

1) Lorsque C a été écrit il n'y a pas de telles restrictions, comme on peut le voir sur cette wikipage http://en.wikipedia.org/wiki/Zero_page.

2) Le fait est que les compilateurs C n'a accédé à la mémoire de l'adresse zéro.

Cela semble être le fait de l'article par BellLabs (http://www.cs.bell-labs.com/who/dmr/primevalC.html)

Les deux compilateurs diffèrent dans les détails de la façon dont ils faire face. Dans la première, le début est trouvé en nommant une fonction; dans le plus tard, le début est tout simplement pris à 0. Cela indique que le premier compilateur a été écrit avant qu'on ait une machine avec de la mémoire, de sorte que l'origine du programme n'était pas à l'emplacement 0, alors que par le moment de la seconde, nous avons eu un PDP-11 qui a fourni la cartographie.

(En fait, au jour d'aujourd'hui (comme je les références citées ci-dessus à partir de wikipedia et microsoft press), la raison de la restriction de l'accès à l'adresse zéro est à cause de C pointeurs NULS! Ainsi, à la fin il s'avère être dans l'autre sens!)

3) Rappelez-vous que C est aussi utilisé pour écrire des systèmes d'exploitation, et même les compilateurs C!

En fait C a été développé dans le but d'écrire le système d'exploitation UNIX avec elle, et comme tel, il semble y avoir aucune raison pourquoi ils devraient se limiter à partir de l'adresse zéro.

(Matériel) Explication Sur La Façon Dont Les Ordinateurs Sont (Physiquement) En Mesure D'Accéder À L'Adresse Zéro

Il y a un autre point que je veux expliquer ici, comment est-il possible d'adresse de référence zéro à tous?

Pensez-y une seconde, les adresses sont extraites par le processeur, puis envoyé comme les tensions sur le bus mémoire, qui est ensuite utilisé par le système de mémoire pour obtenir l'adresse réelle, et encore une adresse de zéro signifie l'absence de tension, alors, comment est le matériel physique de la mémoire système accédant à l'adresse zéro?

La réponse semble être que l'adresse zéro est la valeur par défaut, et dans d'autres mots de l'adresse zéro est toujours accessible par le système de mémoire lorsque le bus mémoire est complètement éteint, et, comme telle, toute demande de lire ou d'écrire sans spécifier une adresse réelle (ce qui est le cas avec l'adresse zéro) est automatiquement accès à l'adresse zéro.
- Je n'ai pas downvote vous, mais votre post a plusieurs inexactitudes factuelles, par exemple. que la mémoire physique à l'offset 0 est impossible d'accéder (en raison de tous les interrupteurs off? vraiment?), 0 et la constante 0 étant interchangeables (ils ne pourraient pas l'être) et d'autres.
- Concernant 0 et la constante de zéro, c'est ce que le livre original est dit, et ce que l'essai réel spectacle, avez-vous constaté une réelle différence entre les deux? Si oui, le compilateur et de la plate-forme? Alors que de nombreuses réponses suggèrent qu'il y a une différence, je n'ai pas trouvé, et ils n'ont pas de référence à montrer une différence. En fait, selon en.wikipedia.org/wiki/Zero_page Et aussi "Windows Via C/C++ par Jeffrey Richter et Christophe Nasarre (publié par Microsoft Press)" l'ensemble de la première page! est protégé dans les ordinateurs modernes, juste pour empêcher le nul (en fait perdre plus d'un octet!)
- Bien sûr, le motif de bits de l'adresse est utilisée pour sélectionner ce qui est en cours de lecture. C'est généralement le cas. de toute façon, je ne veux pas discuter avec vous, j'étais simplement en indiquant pourquoi vous avez été downvoted.
- Je ne suis pas d'accord avec vos réclamations. Je ne suis pas non plus intéressé à poursuivre cette discussion.
- Matériel de réclamation est un non-sens. Pour lire l'adresse zéro, le lecteur !Chip Select faible, !RAS de haut, !CAS faible, !NOUS avons élevé, et toutes les lignes de basse. Lorsque le bus est éteint !CS est élevé.
InformationsquelleAutor

Vous devez vous connecter pour publier un commentaire.