12

我正在尝试编译这段非常简单的代码

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

在不创建更多需要或过于复杂的东西的情况下，我能做些什么来完成这项工作......

4

6 回答 6

15

添加几个构造函数和一个指向父类的指针。

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

您需要 myList() 构造函数，因此它将自身的实例注册到内部类成员变量的实例中。然后，您需要 Items 构造函数来存储指向外部 myList 类实例的指针。最后在 Add 方法中，您需要在存储的 myList 实例中引用 vec。

正如 Catskul 指出的那样，Item 构造函数实际上不能对它接收到的 myList 指针做任何事情。我还想说，虽然这个答案更接近于最初的意图，但 steveth45 的答案更接近于你在真实程序中想要做的事情。

于 2008-10-25T21:52:43.657 回答
11

这样你就不会直接暴露你的班级成员。你的例子似乎有点过度架构。为什么将 std::vector 放入一个类中，然后将其公开？

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");
}
于 2008-10-25T21:52:55.730 回答
5

与 Java 不同，C++ 中的内部对象无法访问外部“this”指针……如果您考虑一下，可能存在没有可引用的情况。

Richard Quirk 的解决方案是您可以在 C++ 中获得的最接近的解决方案

于 2008-10-25T21:58:54.190 回答
2

内部类仅按名称相关。你不能像那样引用基类中的向量。

您要么需要将向量移动到内部类中，要么存储对它的引用。

于 2008-10-25T21:53:13.717 回答
1

虽然这篇文章已经有几年了，但我也许可以添加一些有用的东西。虽然我会说原始帖子中的类设计看起来不太好，但有时让嵌入式类能够访问包含类是很有用的。这可以很容易地完成，而无需存储额外的指针。下面是一个例子。它应该可以工作，因为我从一些现有代码中获取它并更改了一些名称。关键是 EmbeddorOf 宏。奇迹般有效。

/////////////////.h 文件 /////////////////////

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 文件 ///////////////

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

缺口

于 2012-12-28T22:46:17.670 回答
0

您可以通过以下构造来简化它：

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

真的为什么不直接使用 STL 向量呢？通过这种方式，您可以获得所有标准算法与数据一起使用。

于 2009-10-02T11:37:45.787 回答