C++ Verschachtelte Klassen mich fahren verrückt

Question

Ich versuche, dieses sehr einfaches Stück Code zu kompilieren

class myList 
{ 
public: 
    std::vector<std::string> vec; 
    class Items 
    { 
    public: 
     void Add(std::string str) 
     { 
      myList::vec.push_back(str); 
     }; 
    }items; 
}; 

int main() 
{ 
    myList newList; 
    newList.items.Add("A"); 
} 

was kann ich tun, um diese Arbeit zu machen, ohne weitere Objekte zu erstellen, die Sachen benötigt oder overcomplicating ...

Answer 1

Fügen Sie ein paar Konstruktoren und einen Zeiger auf die Elternklasse hinzu.

Sie benötigen den Konstruktor myList(), sodass er Instanzen von sich selbst mit der Instanz der inneren Klassenmitgliedsvariablen registriert. Dann benötigen Sie den Items-Konstruktor, um den Zeiger auf die äußere myList-Klasseninstanz zu speichern. Schließlich müssen Sie in der Add-Methode auf vec in der gespeicherten myList-Instanz verweisen.

Wie Catskul darauf hinweist, darf der Item-Konstruktor mit dem empfangenen myList-Zeiger nichts tun. Ich möchte auch sagen, dass, obwohl diese Antwort näher an der ursprünglichen Absicht ist, die Antwort von steveth45 näher an dem liegt, was Sie in einem echten Programm tun möchten.

Answer 2

Auf diese Weise geben Sie Ihre Klassenmitglieder nicht direkt aus. Ihr Beispiel scheint ein wenig überbearbeitet zu sein. Warum sollte man einen std :: vector in eine Klasse einfügen und dann als public ausgeben?

class myList 
{ 
private: 
    std::vector<std::string> vec; 
public: 
    void Add(std::string str) 
    { 
     vec.push_back(str); 
    }; 
}; 

int main() 
{ 
    myList newList; 
    newList.Add("A"); 
} 

Answer 3

Die inneren Klassen sind nur mit Namen verknüpft. Sie können nicht so auf den Vektor in der Basisklasse verweisen.

Sie müssen entweder den Vektor in die innere Klasse verschieben oder einen Verweis darauf speichern.

Answer 4

Im Gegensatz zu Java haben innere Objekte in C++ keinen Zugriff auf einen äußeren "This" -Zeiger ... Wenn Sie darüber nachdenken, kann es Fälle geben, in denen es keinen Verweis gibt.

Richard Quirk-Lösung ist der nächste Sie C++

Answer 5

bekommen können Sie können dies durch das folgende Konstrukt vereinfachen:

typedef std::vector<std::string> myList; 

wirklich, warum Sie die STL-Vektor nicht direkt verwenden? Auf diese Weise erhalten Sie alle Standard-Algorithmen arbeiten mit den Daten.

Answer 6

Während dieser Beitrag ein paar Jahre alt ist, kann ich möglicherweise in der Lage sein, etwas nützliches hinzuzufügen. Während ich sagen werde, dass das Design der Klasse im ursprünglichen Post nicht so gut aussieht, gibt es Zeiten, in denen es nützlich ist, dass eine eingebettete Klasse auf die enthaltene Klasse zugreifen kann. Dies kann leicht durchgeführt werden, ohne zusätzliche Zeiger zu speichern. Unten ist ein Beispiel. Es sollte funktionieren, da ich es aus einem bestehenden Code genommen habe und einige Namen geändert habe. Der Schlüssel ist das EmbeddorOf-Makro. Klappt wunderbar.

///////////////////// .h Datei ///////////////////////// //

struct IReferenceCounted 
{ 
    virtual unsigned long AddRef() = 0; 
    virtual unsigned long Release() = 0; 
}; 

struct IFoo : public IReferenceCounted 
{ 
}; 

class Foo : public IFoo 
{ 
public: 
    static IFoo* Create(); 
    static IFoo* Create(IReferenceCounted* outer, IReferenceCounted** inner); 

private: 
    Foo(); 
    Foo(IReferenceCounted* outer); 
    ~Foo(); 

    // IReferenceCounted 

    unsigned long AddRef(); 
    unsigned long Release(); 

private: 
    struct EIReferenceCounted : IReferenceCounted 
    { 
     // IReferenceCounted 

     unsigned long AddRef(); 
     unsigned long Release(); 
    } _inner; 

    unsigned long _refs; 
    IReferenceCounted* _outer; 
}; 

/////////////////.CPP-Datei /////////////////

#include <stdio.h> 
#include <stddef.h> 
#include "Foo.h" 

#define EmbeddorOf(class, member, this) \ 
    (class *) ((char *) this - offsetof(class, member)) 

// Foo 

Foo::Foo() : _refs(1), _outer(&this->_inner) 
{ 
} 

Foo::Foo(IReferenceCounted* outer) : _refs(1), _outer(outer) 
{ 
} 

Foo::~Foo() 
{ 
    printf("Foo::~Foo()\n"); 
} 

IFoo* Foo::Create() 
{ 
    return new Foo(); 
} 

IFoo* Foo::Create(IReferenceCounted* outer, IReferenceCounted** inner) 
{ 
    Foo* foo = new Foo(outer); 
    *inner = &foo->_inner; 
    return (IFoo*) foo; 
} 

// IReferenceCounted 

unsigned long Foo::AddRef() 
{ 
    printf("Foo::AddRef()\n"); 
    return this->_outer->AddRef(); 
} 

unsigned long Foo::Release() 
{ 
    printf("Foo::Release()\n"); 
    return this->_outer->Release(); 
} 

// Inner IReferenceCounted 

unsigned long Foo::EIReferenceCounted::AddRef() 
{ 
    Foo* pThis = EmbeddorOf(Foo, _inner, this); 
    return ++pThis->_refs; 
} 

unsigned long Foo::EIReferenceCounted::Release() 
{ 
    Foo* pThis = EmbeddorOf(Foo, _inner, this); 
    unsigned long refs = --pThis->_refs; 
    if (refs == 0) 
     { 

     // Artifically increment so that we won't try to destroy multiple 
     // times in the event that our destructor causes AddRef()'s or 
     // Releases(). 

     pThis->_refs = 1; 
     delete pThis; 
     } 
    return refs; 
} 

Nick