Verschachtelte Datenstruktur, in der Kinder Daten von den Eltern erben

Question

Ich versuche, eine verschachtelte Datenstruktur zu schaffen, die viele Ebenen tief ist, wo jedes „Kind“ Daten von ihren Eltern/Großeltern zugreifen können/etc ...

für Beispiel nimmt diese Datenstrukturen:

struct GrandChild { 
    int someGrandChildData; 
}; 
struct Child { 
    int someChildData; 
    std::vector<GrandChild> vgrandChild; 
}; 
struct Parent { 
    int someParentData; 
    std::vector<Child> vchild; 
}; 
struct GrandParent { 
    int someGrandParentData; 
    std::vector<Parent> vparent; 
}; 

die Art und Weise ich mag würde die Daten wie das wäre zuzugreifen:

void main() 
{ 
    // create and fill in the data 
    GrandParent gp; 
    for (int pNum = 0; pNum < 3; pNum++) 
    { 
     gp.vparent.push_back(Parent()); 
     for (int cNum = 0; cNum < 3; cNum++) 
     { 
      gp.vparent[pNum].vchild.push_back(Child()); 
      for (int gcNum = 0; gcNum < 3; gcNum++) 
      { 
       gp.vparent[pNum].vchild[cNum].vgrandChild.push_back(GrandChild()); 

       // call function and ONLY pass a GrandChild 
       func(gp.vparent[pNum].vchild[cNum].vgrandChild[gcNum]); 
      } 
     } 
    } 
} 

void func(GrandChild &gc) 
{ 
    int result = gc.someGrandChildData; 

    // no need to pass GrandParent, Parent, or Child because 
    // GrandChild can access all of the data from them 
    result += gc.someChildData; // <<-- how can I achieve something like this 
    result += gc.someParentData; // <<-- how can I achieve something like this 
    result += gc.someGrandParentData; // <<-- how can I achieve something like this 
} 

ich versuche, dies zu tun, weil ich Strukturen mit ma ny Datenelemente auf jeder Verschachtelungsschicht und wenn ich Funktionen aufruft, ist es extrem ärgerlich, eine große Anzahl von Argumenten in jeden Funktionsaufruf eingeben zu müssen und wird zu einem Durcheinander, um organisiert zu bleiben.

Jede Hilfe würde sehr geschätzt werden.

Answer 1

Sie könnten es tun, indem Sie die Parent von jeder Person verfolgen (nennen wir es Node). Also, für jeden Knoten, erstellen Sie ein Objekt seines direkten Elternteils in ihm und tun Sie das für jede Ebene (GrandChild, Child, Parent .. etc).

So jede GrandChild ein Child Objekt haben wird, wird jeder Child eine Parent Objekt und jeder Parent ein GrandParent Objekt haben.

Dann werden Sie in der Lage sein, so etwas zu tun:

void func(GrandChild &gc) 
{ 
    int DataFromTheGranChild = gc.DataFromGrandChild; 
    int DataFromTheChild  = gc.Child.DataFromChild; 
    int DataFromTheParent  = gc.Child.Parent.DataFromParent; 
    int DataFromTheGradParent = gc.Child.Parent.GrandParent.DataFromGrandParent; 

    //.. 
} 

Answer 2

Sie könnten versuchen, auf nur eine Art von Struktur zu verwenden.

struct Entity{ 
    int Data; 
    Entity* Child; 
    Entity* Parent; 
};