Liste liée en C ++ en utilisant des références au lieu des pointeurs

Comme @vlad dit, le problème des références est que vous aurez besoin d'un objet final. La bonne nouvelle est que, en principe, vous pouvez toujours avoir une liste cyclique si vous avez une utilisation pour cela. C'est une chose fondamentale, si l'élément "Suivant" est une référence non nullable signifie qu'il y a toujours un élément suivant, c'est-à-dire que la liste est infinie ou, plus de manière réaliste, elle se ferme sur elle-même ou dans une autre liste. Pris L'exercice est assez intéressant et étrange fort>. Fondamentalement, la seule chose qui semble être possible est de définir l'équivalent du nœud A (qui représente également la liste). p> xxx pré>

Les éléments doivent vivre dans la pile et la liste est statique forte> (Eh bien, les références ne sont pas rabindables de toute façon) et les liens doivent être const code> références! Finalement, la valeur code> peut être apportée, puis mutable code> apparemment (probablement en sécurité?). (À ce stade, on se demande comment se trouve-t-il différent des références d'une matrice de pile par un indices modulo.) P>

Il n'y a qu'un seul moyen de construire le noeud code> / list> / liste, c'est-à-dire pour le fermer avec lui-même (ou avec un autre nœud préexisant). La liste résultante est donc soit une forme circulaire ou "RHO". P>

circular_list<int> l{1,2,3,4}; // couldn't do this for obscure reasons

Je pourrais être hors de la marque, mais cela fonctionne xxx

les tests habituels xxx

bien sûr, aussi longtemps que tous les nœuds Restez dans la portée, nous sommes tous ok ici. Sinon pas. Étrange et merveilleux. Utilitaire très limité?

C'était assez délicat, mais cela a fonctionné:

#include <iostream>
#include <typeinfo>

class Last {
  public:

    int x;
    int last;

    Last(int i) {
      std::cout << "parent constructor(" << i << ")\n";
      x = i;
      last = 1;
    }
};

struct fourptr {
    int v1, v2;
    void *p1, *p2;
    };

class chain : public Last {
  public:

    chain(int i) : Last(i) {
    std::cout << "child constructor(" << i << ")\n";
    last = 0;
    }

    void viewandnext() {
      struct fourptr *fp = (struct fourptr *) this;
      std::cout << x << ", this = " << this
                << ", sizeof *this = "<< sizeof * this
                << ", * this = {" << fp->v1 << ", " << fp->v2 << ", "
                << fp->p1 << ", " << fp->p2 << "}"
                << "\n";
      if (last == 0) ((chain &)next).viewandnext();
    }

  Last & fn(int x) {
    Last * e = (x>0) ? new chain(x-1) : new Last(x-1);
    return *e;
  }

    Last & next = fn(x); // This is not a pointer but a reference
};



int main(void) {
  chain &l = *(new chain(8));
  std::cout << "sizeof l = "<< sizeof l << "\n";
  l.viewandnext();
}

Un moyen simple d'éviter un problème de poulet-oeuf pour une liste avec des références consiste à rappeler que votre mémoire d'objet est allouée, alors votre constructeur est appelé. De plus, l'accès à Ce pointeur code> est garanti à l'intérieur d'un constructeur par standard C ++.

NEAT WAY de résoudre ce problème: P>

struct node {
    int data;
    node& next;
    node(node& n, int d): next(n), data(d) {}
};

node tl(tl, 69); // tl is already in the scope!