c++ - 类继承——堆叠方法

Question

我见过这个一次，但我不记得如何让它再次工作。假设我有三个课程：

class CRoot { ... };

class CLevelOne { ... };

class CLevelTwo { ... };

现在，我有了 main 函数，我想通过使用以下语法更深入地了解：

int main (void)
{
  CRoot myRoot ("This is root.");
  myroot.AddLevelOne("This is level one.").AddLevelTwo("This is level two.");
}

所以我的类的最终构造如下所示：

+- This is root.
|+- This is level one.
||+- This is level two.

如何实现它以便我可以使用语法something.Method1().Method2().MethodN(). ...;？

Answer 1

尝试这个：

struct Level2
{
    // See class Level1 below
};

struct Level1
{
    std::string               m_name;
    boost::shared_ptr<Level2> p_level2;
    Level1(const std::string name)
        : name(m_name)
    { ; }

    Level2& add_level_two(const std::string& name)
    {
      p_level2 = new Level2(name);
    }
};

struct Root
{
    boost::shared_ptr<Level1> p_level1;
    Level1& add_level_one(const std::string& name)
    {
      p_level1 = new Level1(name);
    }
};

稍加思考，一个基类，可以更通用地创建它。此外，级别编号必须从方法名称中移出。

Answer 2

像这样的东西：

struct CLevelTwo { };

struct CLevelOne {
    CLevelTwo * AddLevelTwo() {
        return new CLevelTwo();
    }
};

struct CRoot {
    CLevelOne * AddLevelOne() {
        return new CLevelOne();
    }
};

int main(){
    CRoot *root = new CRoot();
    root->AddLevelOne()->AddLeveTwo();
}

您可以用引用替换指针，但要注意内存泄漏。请注意，此代码也会泄漏，但它更易于管理，并且管理对象的生命周期应该不是一个大问题。

Answer 3

只需SomeMethod返回一个参考*this：

struct Foo
{
    Foo& Add(SomeOtherThing& thing)
    {
        // Do the "add"...
        return *this;
    }
};

现在你可以这样做：

Foo myFoo;
myFoo.Add(...).Add(...).Add(...);

这就像赋值运算符重载的工作方式一样。

Answer 4

编辑在与 Thibaut 审查后，我提出以下解决方案：

class Node
{
private:
    std::string _name;
    std::list<Node*> _nodes;

public:
    Node(const std::string& name) : _name(name)
    {
    }; // eo ctor

    virtual ~Node()
    {
        for(std::list<Node*>::iterator it(_nodes.begin());
            it != _nodes.end();
            ++it);
            delete *it;
    }; // eo dtor


    Node* Add(const std::string& name)
    {
        Node* newNode = new Node(name);
        _nodes.Add(newNode);
        return newNode;
    }; // eo Add
}; // eo class Node