Combien de niveaux de pointeurs peut-on avoir?

Combien de pointeurs (*) sont autorisés dans une seule variable?

Considérons l'exemple suivant.

int a = 10;
int *p = &a;

De la même façon que nous pouvons avoir

int **q = &p;
int ***r = &q;

et ainsi de suite.

Par exemple,

int ****************zz;

Si cela devient un réel problème pour vous, vous faites quelque chose de très mal.
Techniquement il n'y a probablement pas de limite (bien que c'est le compilateur spécifique). La véritable limite est celle de votre (et vos collègues de travail') capacité mentale de garder une trace de ce que votre variable représente en fait. Et en respectant le code lisible est généralement plus important que le faible niveau d'optimisation. De ce point de vue, dans le code de production déjà triple indirection (par exemple int***) n'est pas recommandée dans la plupart des cas.
Vous pouvez continuer à ajouter des niveaux de pointeurs jusqu'à ce que votre cerveau explose ou le compilateur fond - selon ce qui se produit en peu de temps.
Depuis un pointeur vers un pointeur est nouveau, eh bien, juste un pointeur, il ne devrait pas y avoir de limite théorique. Peut-être que le compilateur ne pas être en mesure de la traiter au-delà de certains ridiculement haute limite, mais bon...
avec le nouveau c++, vous devez utiliser quelque chose comme std::shared_ptr<shared_ptr<shared_ptr<...shared_ptr<int>...>>>
Peut-être un "décoré commentaire" a obtenu hors de contrôle et a tiré cette question 🙂
Pourquoi ne pas simplement écrire un programme simple pour le tester sur votre compilateur? Quelle que soit répondu par d'autres, est susceptible de ne pas correspondre exactement à votre environnement.
Pourquoi? Ce qui est si destructeur (ou non constructive ) à ce sujet?
les pires conseils possibles, il peut compiler et d'échouer dans la prochaine version ou il peut échouer maintenant à un bug du compilateur. vérifiez la documentation du compilateur, vérifiez la norme et en dernier recours, de vérifier la mise en œuvre actuelle.
il peut faire sens pour les générateurs de code...
cela montre un problème dans la norme C++ - il n'y a aucun moyen pour augmenter les pointeurs intelligents de pouvoirs. Nous devons immédiatement à la demande d'une extension à l'appui par exemple (pow (std::shared_ptr, -0.3))<T> x; pour -0.3 niveaux d'indirection.
Il dépend de la mémoire de votre système. Si elle excède, le système se bloque. Sinon, elle est infinie. Vous pouvez essayer avec while(1).
Mmmm, nah. C'est sur le sujet. Et si l'un de vous reddit les gens veulent aller à travers mes questions/réponses et massivement upvote eux, n'hésitez pas!
le lien que vous avez fourni est de l'or, juste de l'or pur.
J'ai eu la "joie" de maintenir un trois étoiles du programmeur base de code. Il avait aussi une tendance à traiter toutes les conditions d'erreur avec exit(0) (et rien d'autre, pas même un printf).
Assurez-vous que votre réponse appartient ici?
yupe n'êtes-vous pas sûr
semble être la bonne façon de force de code spaghetti au rpc 🙂
bien logiquement, il ne ferait aucun sens de créer des pointeurs à cette n niveau. Le compilateur n'a pas de problèmes, mais votre programme si elle utilise des
jamais entendu parler de la parole, mais reconnaissons donc beaucoup de programmeurs que je l'ai rencontré à travers les années. Merci pour le partage de cette brillante lien.
J'ai été taquiné pour l'écriture de 3-étoiles code de once upon a time. Si c'était en fait un tableau d'adresses de chaînes... qui est (dans mon esprit) très différente de pointeur de pointeur de pointeur de char, comme j'ai été accusé de. [soupir] je serais encore défendre ce code.
Je sais que beaucoup de 3-étoiles programmeurs. Ils sont quantique des chimistes du programme 4D tableaux dans le naïf, mais courants de la mode.
Tu veux dire, comme ça? coliru.stacked-crooked.com/a/92a6666764acbaff 😀
Notez qu'il existe un assez commun pointeur qui est généralement écrit avec trois niveaux: char*** argv (ou souvent écrit en tant que char** argv[]). Par exemple, c'est exactement la façon dont vous call MPI_Init (et d'autres fonctions qui peuvent changer votre argv lors du passage).
Une fois, j'ai dû utiliser un void**** dans un véritable programme de vie.
Tout programme qui nécessite de nombreux niveaux de pointeurs [1] probablement très inefficace et [2] a probablement beaucoup de bugs. Il suffit de coller avec une ou deux couches de pointeurs.
Dire que pour Microsoft 🙂 L'objet en question a été le pointeur vers un pointeur intelligent autour d'un pointeur d'interface COM, qui a effectivement des points à un pointeur vers un tableau de pointeurs de fonction. Avec moi encore? 🙂

InformationsquelleAutor Parag | 2012-04-10

c c++pointers

395

La C norme spécifie la limite inférieure:

5.2.4.1 Traduction limites

276 La mise en œuvre doit être en mesure de traduire et d'exécuter au moins un programme qui contient au moins une occurrence de chacune des limites suivantes: [...]

279 — 12 pointeur de tableau, et la fonction declarators (toutes les combinaisons) la modification d'une
l'arithmétique, de la structure, de l'union, ou de type void dans une déclaration

La limite supérieure est de la mise en œuvre spécifique.
- La norme C++ "recommande" que d'un appui à l'exécution d'au moins 256. (Lisibilité vous recommande de ne pas dépasser 2 ou 3, et même alors: plus on devrait être l'exception.)
- Cette limite est d'environ combien de personnes dans une seule déclaration; elle n'impose pas de limite supérieure sur la façon dont beaucoup d'indirection vous pouvez obtenir par le biais de multiples typedefs.
- oui, c'est vrai. Mais depuis que la norme est (no pun intended) en précisant obligatoirement une limite inférieure, c'est la mise à la limite supérieure de tous conformes aux spécifications des compilateurs sont obligatoire à l'appui. Il pourrait être plus faible que le vendeur, à la limite supérieure, bien sûr. Reformuler différemment (pour l'aligner avec les OP de la question), c'est le maximum autorisé par la spec (tout le reste serait spécifique au fournisseur.) Un peu hors de la tangente, les programmeurs doit (au moins dans le cas général) traiter comme leur limite supérieure (sauf s'ils ont une raison valable de s'appuyer sur un fournisseur spécifique à la limite supérieure)... je pense.
- Sur une autre note, je voudrais commencer à couper moi-même si j'ai eu à travailler avec du code qui avait long-cul déréférencement des chaînes (spécialement lors de la généreusement parsemé de tous sur la place.)
- ok, mais pourquoi exactement 12? Pourquoi pas 5 ou 40. Est-il une explication pour cela?
- Habituellement, ces chiffres proviennent de l'enquête de pré-normalisation du logiciel. Dans ce cas, vraisemblablement, ils ont regardé commun des programmes en C et existants, les compilateurs C, et trouvé au moins un compilateur qui auraient de la difficulté avec plus de 12 et/ou pas de programmes qui a cassé si vous limité à 12.
- Je ne comprends pas pourquoi une réponse d'obtenir plus upvotes juste parce que l'écrivain a plus de réputation. De cette façon, les réponses qui sont réellement bon, mais par une faible réputation sont caché.Cette réponse n'était pas réellement constructif , mais son upvotes sont massives. Au-dessus de Sachin Mhetra Réponse était bonne mais si faible upvotes.
- Lorsque j'ai posté ma réponse, mon rep a été d'environ 1500. Toutes les réponses étaient toutes dans l'erreur à ce moment. Par conséquent, il a eu beaucoup de upvotes. Plus tard, d'autres modifiés leurs réponses et/ou l'amélioration de après j'ai posté ma réponse. Vous pouvez voir ce à partir de l'historique de l'édition et de l'heure des réponses. Voir, par exemple, Alok Enregistrer la réponse initiale à partir de la modifier l'histoire, qui a été competely mal.
- Encore , sachin mehra réponse constructive et j'ai vu son historique d'édition , pas de gros changement, vous avancent posté une norme n'expliquant pas de vos paroles , et il a au-dessus de 300 upvotes .Peut-être parce que l'OP n'a pas demandé pourquoi et il suffit de demander quelle est la limite supérieure et la meilleure façon de le savoir est de montrer le standard , mais il serait encore mieux si vous pouviez expliquer le raisonnement aussi. Comme en Théorie Et en pratique , en baisse de mihai utilisateur vérifié, et a montré ce qui est limite et il est de la mise en œuvre spécifique , toutes ces choses en une seule réponse fait-il digne pour tous ceux upvote ,et pas seulement en se référant à la norme.
- Si il n'est pas jusqu'à ce que votre niveau, vous pouvez poster une meilleure réponse. Si vous êtes inquiet au sujet de "deservedness" de upvotes vous pouvez le signaler à un modérateur et d'expliquer le bon nombre de upvotes ce qui devrait avoir et de voir si elles peuvent vous aider.
InformationsquelleAutor P.P.
149

En fait, les programmes en C font fréquemment usage de l'infini pointeur d'adressage indirect. Un ou deux statique niveaux sont communs. Triple indirection est rare. Mais l'infini est très commun.

Infini pointeur d'adressage est réalisé avec l'aide d'un struct, bien sûr, pas un accès direct à un jugement de nullité, ce qui serait impossible. Et une structure est nécessaire de sorte que vous pouvez inclure d'autres données dans cette structure à différents niveaux où cela peut se terminer.
```
struct list { struct list *next; ... };
```
maintenant vous pouvez avoir list->next->next->next->...->next. C'est vraiment juste plusieurs pointeur indirections: *(*(..(*(*(*list).next).next).next...).next).next. Et le .next est fondamentalement un noop quand il est le premier membre de la structure, de sorte que nous pouvons imaginer ce que ***..***ptr.

Il n'y a vraiment pas de limite sur ce point car les liens peuvent être parcourus avec une boucle plutôt qu'un géant de la manifestation de ce genre, et de plus, la structure peut être facilement fait en circulaire.

Donc, en d'autres termes, les listes liées peut-être l'exemple ultime de l'ajout d'un autre niveau d'indirection pour résoudre un problème, puisque vous le faites de façon dynamique à chaque opération push. 🙂
- C'est une toute autre question, si - une structure contenant un pointeur vers une autre structure est très différente de celle d'un pointeur de pointeur. Un int***** est un type distinct d'un int****.
- Il n'est pas "très" différent. La différence est moelleux. Il est plus proche de la syntaxe de la sémantique. Un pointeur vers un pointeur sur un objet, ou un pointeur vers un objet de structure qui contient un pointeur? C'est le même genre de chose. Arriver à la dixième élément d'une liste est dix niveaux d'aborder l'indirection. (Bien sûr, la capacité d'exprimer une infinité de structure dépend du type struct être capable de pointer vers lui-même par la nature incomplète de type struct, de sorte que list->next et list->next->next sont du même type; sinon, nous avons de construire une infinité de type.)
- Je n'ai pas consciemment remarquez que votre nom est moelleux quand j'ai utilisé le mot "moelleux". Inconscient de l'influence? Mais je suis sûr d'avoir utilisé le mot de cette façon avant.
- Hmmm! Je ne suis pas sûr que c'est vraiment une infinie pointeur d'adressage indirect. Sémantiquement parlant, vous avez affaire à un seul type (struct list *) et un seul pointeur déréférencé à un moment, chaque collier par un "presque aucun op". (Comme cela a déjà été pratiquement souligné, mais bon.)
- En C, un pointeur déréférencé à un moment, peu importe quoi. Vous ne pouvez pas déréférencer la prochaine pointeur jusqu'à ce que vous chargez la précédente. *******x est un à la fois, exactement comme x->next->next->next->next.
- Rappelez-vous aussi qu'en langage machine, vous pouvez simplement effectuer une itération sur quelque chose comme LOAD R1, [R1] tant que R1 est un pointeur valide à chaque étape. Il n'existe pas de types autres que "la parole qui est titulaire d'une adresse". Qu'il existe ou non déclaré types ne détermine pas l'indirection et de la façon dont de nombreux niveaux.
- +1. Mais au sens strict du terme - pour avoir nombre infini de indirections - nous devons avoir infini de l'espace d'adresse, ce qui n'est pas le cas.
- Pas si la structure est circulaire. Si R1 contient l'adresse de l'emplacement qui pointe vers lui-même, puis LOAD R1, [R1] peut être exécutée dans une boucle infinie.
- Cette réponse n'est pas répondre à la question posée, qui est d'environ déclarations.
- c'est certainement le sujet d'un des déclarations. La structure de la déclaration est auto-référentielle ("j'ai contenir un pointeur vers moi-même"), quelque chose qui C minutieusement permet via le incomplète struct type de mécanisme. Cela crée une infinité de niveau d'indirection de pointeur.
- le point est que la traversée d'une longue chaîne de ->next éléments est contrôlée par le programmeur; gérer *****....*****int le compilateur a interne à représenter la profondeur de l'pointeurs (de sorte qu'il peut détecter les erreurs de déréférencement). Certaines façons de stocker cette représentation ne peut être limité par la mémoire (utilisé par le compilateur), mais d'autres méthodes peuvent avoir des limites strictes.
- et *P sont à la fois la syntaxe. Comment profondément que la syntaxe est imbriquée est contrôlée par le programmeur. Le compilateur doit représenter P->memb->memb->memb->memb... et il a de représenter ***..P.
- Il y a une différence, surtout lors de la compilation. Pour P->next qui arrive à point à un autre P, le compilateur ne doit connaître que c'est un pointeur vers la structure mère. À compilation il ne se soucie pas combien de temps une chaîne de liens à des éléments que vous créez lors de l'exécution. Pour *****int, le compilateur au moment de la compilation représente le type pour tous les niveaux ... c'est *****int est un pointeur vers une ****int qui points à ***int ... pour un *int qui enfin des points pour un int. Pour certains compilateurs, en vertu de l' certains conditions, il peut manquer d'espace pour le faire.
- Vous pouvez obtenir d'éviter la construction d'une profondeur de type statique en utilisant quelque chose comme DEREFI(DEREFV(DEREFV...(DEREFV(P)) ...)) où P est un void * pointeur, DEREFV est #define DEREFV(P) (*((void **) (P))) et DEREFI est similaire, mais avec un casting de int *. I. e. arbitrairement une longue chaîne de void * pointeurs qui pointent vers void *, et enfin un int.
InformationsquelleAutor Kaz
80

Théoriquement:

Vous pouvez avoir autant de niveaux d'indirections que vous le souhaitez.

Pratiquement:

Bien sûr, rien de ce qui consomme de la mémoire peut être de durée indéterminée, il y aura des limitations en raison des ressources disponibles sur l'hôte de l'environnement. Donc, pratiquement il y a une limite maximale à ce qu'une mise en œuvre peut prendre en charge et la mise en œuvre du document de manière appropriée. Donc, dans tous ces artefacts, la norme ne précise pas la limite maximale, mais il ne précise pas les limites les plus basses.

Voici la référence:

Standard C99 5.2.4.1 Traduction limites:

— 12 pointeur de tableau, et la fonction declarators (toutes les combinaisons) la modification d'une
l'arithmétique, de la structure, de l'union, ou de type void dans une déclaration.

Spécifie la limite inférieure que chaque mise en œuvre doit de soutien. Notez que dans un footenote la norme dit encore:

18) Implémentations devraient éviter d'imposer fixe les limites de la traduction à chaque fois que possible.
- indirections ne déborde pas les piles!
- Comment fonctionne la pile concernent pointeur d'adressage indirect?
- Corrigé, j'ai eu cette errie sentiment de la lecture & réponse à la q la limite de paramètres passés à la fonction. Je ne sais pas pourquoi?!
- Je m'attends à de la pile de la profondeur à être un problème dans l'analyseur. De nombreux formelle de l'analyse des algorithmes ont une pile comme un élément clé. La plupart des compilateurs C++ probablement utiliser une variante de descente récursive, mais même qui s'appuie sur le processeur de la pile (ou, de manière affectée, sur la langue d'agir comme si il y avait un processeur de la pile). Plus de nidification des règles de grammaire signifie une plus profonde de la pile.
- indirections ne déborde pas les piles!--> Pas de! analyseur de la pile risque de déborder. Comment fonctionne la pile concernent pointeur d'adressage indirect? Analyseur de pile!
- Si * est surchargé pour un nombre de classes dans une rangée, et chaque surcharge retourne un objet d'un autre type dans la ligne, puis il peut être stackoverflow pour ces enchaîné les appels de fonction.
- peut-être la pile, alors compilateur analyser une expression composée de beaucoup de *s
- À partir d'un point de vue pratique, la traduction limites sont, au mieux, des recommandations, étant donné que la Norme ne dit rien sur ce que les combinaisons de limites doivent être prises en charge. Beaucoup de monde réel mourrait si le code tenté d'inclure le nombre maximal de paramètres et automatique d'objets dans une fonction, et ils ont tous pris 32767 octets chacun. D'autre part, rien dans la Norme serait d'interdire à un conforme mais inutile de mise en œuvre de dire qu'aucune fonction ne peut à la fois contenir plus d'un automatique d'objets et d'avoir automatiquement un objet qui est plus grand qu'un octet de la taille.
- Les auteurs de la Norme reconnu la possibilité de se conformer mais inutile implémentations, mais attend à ce que (1) les gens de faire un effort de bonne foi pour produire un produit de mise en œuvre ne sera pas faire des choses stupides, simplement parce que la Norme serait de leur permettre d', et (2) ce n'est pas la peine de s'inquiéter au sujet de quels types de compilateurs pourraient être produits par des gens qui n'ont pas fait un tel effort.
InformationsquelleAutor Alok Save
74

Que les gens ont dit, pas de limite "en théorie". Cependant, l'intérêt, j'ai couru ce avec g++ 4.1.2, et il a travaillé avec la taille jusqu'à 20 000. La compilation est assez lent, donc je n'ai pas essayé plus haut. Donc je suppose g++ n'impose pas de limite non plus. (Essayez de définir size = 10 et à la recherche dans ptr.cpp si elle n'est pas immédiatement évident.)

g++ create.cpp -o create ; ./create > ptr.cpp ; g++ ptr.cpp -o ptr ; ./ptr

create.cpp
```
#include <iostream>

int main()
{
    const int size = 200;
    std::cout << "#include <iostream>\n\n";
    std::cout << "int main()\n{\n";
    std::cout << "    int i0 = " << size << ";";
    for (int i = 1; i < size; ++i)
    {
        std::cout << "    int ";
        for (int j = 0; j < i; ++j) std::cout << "*";
        std::cout << " i" << i << " = &i" << i-1 << ";\n";
    }
    std::cout << "    std::cout << ";
    for (int i = 1; i < size; ++i) std::cout << "*";
    std::cout << "i" << size-1 << " << \"\\n\";\n";
    std::cout << "    return 0;\n}\n";
    return 0;
}
```
- Je ne pouvais pas obtenir plus que 98242 quand je l'ai essayé. (J'ai fait le script en Python, en doublant le nombre de * jusqu'à ce que j'en ai eu un qui a échoué, et la précédente qui se passait; j'ai ensuite fait une recherche binaire sur cet intervalle pour la première celui qui a échoué. L'ensemble de l'essai a duré moins d'une seconde pour fonctionner.)
InformationsquelleAutor BoBTFish
61

Amusant à vérifier.
- Visual Studio 2010 (sur Windows 7), vous pouvez avoir 1011 niveaux avant d'obtenir cette erreur:
  
  erreur fatale C1026: analyseur de dépassement de la pile, programme trop complexe
- gcc (Ubuntu),+ de 100k * sans crash ! Je suppose que le matériel est la limite ici.
(testé avec juste une déclaration de variable)
- En effet, les productions pour les opérateurs unaires sont de droite récursif, ce qui signifie que la variation de réduire l'analyseur va transférer la totalité de la * nœuds sur la pile avant d'être en mesure de faire une réduction.
InformationsquelleAutor mihai
27

Il n'y a pas de limite, vérifier exemple ici.

La réponse dépend de ce que tu veux dire par "niveaux de pointeurs." Si vous voulez dire "Combien de niveaux d'indirection que vous pouvez avoir dans une seule déclaration?", la réponse est "Au moins 12."
```
int i = 0;

int *ip01 = & i;

int **ip02 = & ip01;

int ***ip03 = & ip02;

int ****ip04 = & ip03;

int *****ip05 = & ip04;

int ******ip06 = & ip05;

int *******ip07 = & ip06;

int ********ip08 = & ip07;

int *********ip09 = & ip08;

int **********ip10 = & ip09;

int ***********ip11 = & ip10;

int ************ip12 = & ip11;

************ip12 = 1; /* i = 1 */
```
Si vous voulez dire "Combien de niveaux de pointeur que vous pouvez utiliser avant que le programme devient difficile à lire," c'est une question de goût, mais il y a une limite. Avoir deux niveaux d'indirection (un pointeur vers un pointeur vers quelque chose) est commun. Pas plus que cela devient un peu plus difficile à penser facilement; ne pas le faire à moins que l'alternative serait pire.

Si vous voulez dire "Combien de niveaux d'indirection de pointeur que vous pouvez avoir lors de l'exécution," il n'y a pas de limite. Ce point est particulièrement important pour les circulaires des listes, dans lequel chacun des points de nœud à l'autre. Votre programme peut suivre les pointeurs pour toujours.
- Il y a certainement une limite, puisque le compilateur doit garder une trace de l'information dans une quantité limitée de mémoire. (g++ échoue avec une erreur interne au 98242 sur ma machine. Je pense que la limite réelle dépendra de la machine et de la charge. J'ai aussi ne vous attendez pas à être un problème dans le code réel.)
- Ouais @MatthieuM. : Je viens théoriquement 🙂 Merci James pour compléter la réponse
- Ainsi, les listes liées ne sont pas vraiment un pointeur vers un pointeur, c'est un pointeur vers une structure qui contient un pointeur (ou alors il finit par faire beaucoup d'inutiles casting)
- Ouais! mais ne pensez-vous pas qu'il est bien structuré?
- Nand a dit " Si tu veux dire "Combien de niveaux d'indirection de pointeur que vous pouvez avoir lors de l'exécution," " alors il a été explicitement le retrait de la restriction de parler des pointeurs de pointeurs (*n).
- Je ne reçois pas votre point: "Il n'y a pas de limite, vérifier exemple ici. " L'exemple n'est pas une preuve qu'il n'y a pas de limite. Elle prouve seulement que les 12 étoiles de l'indirection est possible. Ni prouve quoi que ce soit de la circ_list exemple en ce qui concerne l'OP question: Le fait que vous pouvez parcourir une liste de pointeurs ne signifie pas que le compilateur peut compiler un n-étoiles indirection.
- Je veux dire, Il n'y a pas de limite et pour plus d'informations, consultez cet exemple. Pense que sur circ_list exemple.
InformationsquelleAutor Nandkumar Tekale
23

C'est même plus drôle avec le pointeur de fonctions.
```
#include <cstdio>

typedef void (*FuncType)();

static void Print() { std::printf("%s", "Hello, World!\n"); }

int main() {
  FuncType const ft = &Print;
  ft();
  (*ft)();
  (**ft)();
  /* ... */
}
```
Comme illustré ici cela donne:

Bonjour Tout Le Monde!

Bonjour Tout Le Monde!

Bonjour Tout Le Monde!

Et il n'implique pas de gestion d'exécution, de sorte que vous pouvez probablement les empiler autant que vous voulez... jusqu'à ce que votre compilateur étouffe sur le fichier.

InformationsquelleAutor Matthieu M.
19

Il est pas de limite. Un pointeur est une partie de la mémoire dont le contenu est une adresse.

Comme vous l'avez dit
```
int a = 10;
int *p = &a;
```
Un pointeur vers un pointeur est également une variable qui contient une adresse d'un autre pointeur.
```
int **q = &p;
```
Ici q est pointeur de pointeur de la tenue de l'adresse de p qui est déjà en tenant l'adresse de a.

Il n'y a rien de particulier un pointeur vers un pointeur.
Il n'y a pas de limite sur la chaîne de poniters qui sont la tenue de l'adresse d'un autre pointeur.

ie.
```
 int **************************************************************************z;
```
est autorisé.

InformationsquelleAutor Sachin Mhetre
13

Remarque qu'il y a deux questions: combien de niveaux d'indirection de pointeur, nous pouvons réaliser dans un de type C, et combien de niveaux d'indirection de pointeur, nous pouvons trucs en une seule déclaration.

Le C standard permet un maximum pour être imposé à l'ancienne (et donne une valeur minimale pour que). Mais qui peut être contournée par le biais de multiples typedef déclarations:
```
typedef int *type0;
typedef type0 *type1;
typedef type1 *type2; /* etc */
```
Donc, finalement, c'est une question de mise en œuvre connecté à l'idée de savoir comment grand/complexe peut faire un programme en C avant de est rejetée, ce qui est très compilateur spécifique.

InformationsquelleAutor Kaz
13

Chaque développeur C++ doit avoir entendu parler du fameux Trois étoiles programmeur

Et il semble vraiment y avoir un peu de magie "pointeur de la barrière" qui doit être camouflé

Citation de C2:

Trois Étoiles Programmeur

Un système de notation pour les C-programmeurs. Le plus indirecte vos pointeurs sont (c'est à dire le plus "*" avant de vos variables), plus votre réputation sera. Sans étoile C-programmeurs sont pratiquement inexistants, comme pratiquement tous les non-trivial programmes nécessitent l'utilisation de pointeurs. La plupart sont d'une étoile programmeurs. Dans l'ancien temps (eh bien, je suis jeune, de sorte que ceux-ci regardent comme au bon vieux temps du moins pour moi), l'un serait l'occasion de trouver un morceau de code fait par un trois étoiles programmeur et frissonne de crainte.
Certaines personnes ont même affirmé qu'ils avaient vu trois étoiles de code avec des pointeurs de fonction impliqués, sur plus d'un niveau d'indirection. Sonné comme une véritable Ovni pour moi.
- github.com/psi4/psi4public/blob/master/src/lib/libdpd/... et comme a été écrit par un 4 étoiles programmeur. Il est aussi un ami à moi, et, si vous lisez le code assez, vous comprendrez la raison pour laquelle il est digne d'un 4 étoiles.
InformationsquelleAutor Mare Infinitus
3

Je tiens à souligner que la production d'un type avec un nombre arbitraire de " * " est quelque chose qui peut arriver avec le modèle de la métaprogrammation. J'oublie ce que je faisais exactement, mais il a été suggéré que je pourrais produire de nouveaux types distincts qui ont une sorte de méta de manœuvre entre eux à l'aide de récursive T* types.

Modèle de la Métaprogrammation est une lente descente dans la folie, de sorte qu'il n'est pas nécessaire de faire des excuses lors de la génération d'un type avec plusieurs milliers de niveau d'indirection. C'est juste un moyen pratique pour la carte des entiers de peano, par exemple, sur le modèle de l'expansion comme un langage fonctionnel.
- J'avoue que je ne comprends pas votre réponse entièrement, mais il m'a donné une nouvelle zone à explorer. 🙂
InformationsquelleAutor JDługosz
2

De la règle 17.5 de l'2004 MISRA C norme interdit plus de 2 niveaux d'indirection de pointeur.
- Assez sûr que c'est une recommandation pour les programmeurs, pas pour les compilateurs.
- J'ai lu le document à la règle 17.5 sur plus de 2 niveaux d'indirection de pointeur. Et il n'est pas nécessairement interdire plus de 2 niveaux. Il ne fait état que la décision doit être suivie comme plus de 2 niveaux est "non-compliant" à leurs normes. Le mot ou la phrase dans sa décision, est l'utilisation du mot "should" à partir de cette déclaration: Use of more than 2 levels of indirection can seriously impair the ability to understand the behavior of the code, and should therefore be avoided. ce sont des lignes directrices établies par cette organisation plutôt que sur des règles définies par la norme du langage.
InformationsquelleAutor kostmo
1

Il n'y a pas une telle chose comme véritable limite mais limite existe. Tous les pointeurs sont des variables qui sont généralement le stockage dans la pile pas de tas. La pile est généralement de petite taille (il est possible de changer sa taille au cours de certaines de liaison). Donc, disons que vous avez de 4MO de la pile, ce qui est tout à fait normal de taille. Et disons que nous avons pointeur qui est de 4 octets taille de pointeur (tailles ne sont pas les mêmes en fonction de l'architecture, de la cible et les paramètres du compilateur).

Dans ce cas 4 MB /4 b = 1024 donc possible nombre maximal serait 1048576, mais nous ne devons pas ignorer le fait que quelques autres trucs est dans la pile.

Cependant, certains compilateurs peuvent avoir un nombre maximum de pointeur de la chaîne, mais la limite est la taille de la pile. Donc, si vous augmentez la taille de la pile lors de la liaison avec l'infini et de la machine avec l'infini de la mémoire qui exécute le système d'exploitation qui gère la mémoire de sorte que vous aurez illimité pointeur de la chaîne.

Si vous utilisez int *ptr = new int; et placez votre pointeur dans le tas, ce n'est pas si d'habitude façon dont la limite serait de la taille du segment, pas de pile.

MODIFIER Viens de réaliser que infinity /2 = infinity. Si la machine dispose de plus de mémoire de sorte que le pointeur de la taille augmente. Donc, si la mémoire est l'infini et de la taille du pointeur est l'infini, de sorte qu'il est de mauvaises nouvelles... 🙂
- A) les Pointeurs peuvent être stockées sur le tas (new int*). B) Un int* et un int********** ont la même taille, au moins sur des architectures.
- A) Oui, les pointeurs peuvent être stockés en tas. Mais il serait tout à fait autre chose, comme la création de conteneur qui détiennent des pointeurs quels sont pointant vers le suivant pointeur précédent. B) Des cours int* et un int********** ont la même taille, je n'ai pas dit qu'ils ont de différent.
- Ensuite, je ne vois pas comment la taille de la pile est appropriée même à distance.
- Viens de réaliser new *int, désolé, pour Un, vous avez raison
- J'ai pensé à propos de l'habitude mode de distribution de données lorsque toutes les données sont dans le tas et de la pile c'est juste des pointeurs vers les données. Il serait l'habitude façon, mais je suis d'accord qu'il est possible de mettre des pointeurs de pile.
- "Bien sûr, int* et un int********** ont la même taille" - la norme ne garantit pas que (bien que je ne connais pas de plate-forme où il n'est pas vrai).
InformationsquelleAutor ST3

Cela dépend de l'endroit où vous stocker des pointeurs. Si ils sont dans la pile que vous avez assez faible limite. Si vous les conservez au tas, vous limite est beaucoup, beaucoup beaucoup plus.

Regarder ce programme:

#include <iostream>

const int CBlockSize = 1048576;

int main() 
{
    int number = 0;
    int** ptr = new int*[CBlockSize];

    ptr[0] = &number;

    for (int i = 1; i < CBlockSize; ++i)
        ptr[i] = reinterpret_cast<int *> (&ptr[i - 1]);

    for (int i = CBlockSize-1; i >= 0; --i)
        std::cout << i << " " << (int)ptr[i] << "->" << *ptr[i] << std::endl;

    return 0;
}

Il crée 1M pointeurs et à la montre à quel point, à ce qu'il est facile de remarquer que la chaîne passe à la première variable number.

BTW. Il utilise 92K de RAM alors imaginez à quelle profondeur vous pouvez aller.

InformationsquelleAutor ST3

Vous devez vous connecter pour publier un commentaire.

5.2.4.1 Traduction limites