Les classes imbriquées C ++ me rendent fou

je suis en train de compiler ce très simple morceau de code

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");
}

que puis-je faire pour faire ce travail sans créer plus d'objets que nécessaire ou de compliquer à l'excès des choses...

source d'informationauteur SMeyers

c++class nested

15

Ajouter un couple de constructeurs et un pointeur vers la classe parent.
```
#include <string>
#include <vector>
class myList
{
public:
    std::vector<std::string> vec;
    myList(): items(this) {} //Added
    class Items
    {
    public:
        Items(myList *ml): self(ml) {}  //Added
        void Add(std::string str)
        {
                self->vec.push_back(str); //Changed
        };
        myList *self; //Added
    }items;
};

int main()
{
    myList newList;
    newList.items.Add("A");
}
```
Vous avez besoin de la maliste() constructeur, de sorte qu'il enregistre les instances de lui-même avec l'instance de l'intérieur de la variable de membre de classe. Ensuite, vous devez disposer des Éléments constructeur pour stocker le pointeur à l'extérieur maliste instance de classe. Enfin, dans la méthode Add, vous devez référence vec dans stockées maliste instance.

Comme Catskul points, l'Élément constructeur ne doit pas faire quoi que ce soit avec la maliste pointeur qu'il reçoit. Je tiens aussi à dire que même si cette réponse est plus proche de l'intention originale, steveth45 la réponse est plus proche de ce que vous voulez faire dans un programme réel.

De cette façon, vous n'êtes pas exposer vos membres de la classe directement. Votre exemple me semble plus de l'architecture a été un peu. Pourquoi mettre un std::vector dans une classe, puis l'exposer en tant que public?

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");
}

5

Contrairement à Java, à l'intérieur des objets en C++ n'ont pas accès à l'extérieur " ce " pointeur ... si vous pensez à ce sujet, il peut y avoir des cas où il n'y a pas de référence.

Richard Caprice de la solution est le plus proche que vous pouvez obtenir en C++
2

Les classes internes sont liés seulement par son nom. Vous ne pouvez pas consulter le vecteur dans la classe de base comme ça.

Vous avez besoin de déplacer le vecteur à l'intérieur de la classe ou de magasin de référence.

Alors que ce post est vieux de quelques années, je pourrait être en mesure d'ajouter quelque chose d'utile. Alors je vais dire que la conception de la classe dans le post original n'a pas l'air terrible, il y a des moments où il est utile d'avoir intégré la classe de pouvoir accéder à la classe conteneur. Cela peut facilement être fait sans stockage supplémentaire des pointeurs. Ci-dessous est un exemple. Il devrait fonctionner comme je l'ai pris de code existant et changé quelques noms. La clé est la EmbeddorOf macro. Fonctionne comme un charme.

////////////////////.h fichier /////////////////////////

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;
};

////////////////.fichier cpp /////////////////

#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

0

Vous pouvez simplifier cette par la suite de construire:
```
typedef std::vector<std::string> myList;
```
Vraiment pourquoi n'utilisez-vous pas le vecteur STL directement?
De cette façon, vous obtenez tous les algorithmes standards de travail avec le
les données.

Vous devez vous connecter pour publier un commentaire.