Question

我正在尝试设计一个C ++ Template类，它将包含Tree的所有功能（即appendChild，childCount）。我想从这个模板类extend然后设计具有现有功能的自定义Tree类（读作Methods）以及额外的功能。

到目前为止，我得到了这个。

#include <iostream>
#include <list>

/* TREE TEMPLATE CLASS */
template <class T>
class TreeTemplate
{
    public:
        TreeTemplate();
        void appendChild(T*);
        int getChildCount();
    protected:
        std::list<T*> m_childList;
};

/* Constuctor */
template <class T>
TreeTemplate<T>::TreeTemplate(){}

template <class T>
void TreeTemplate<T>::appendChild(T* t)
{
    m_childList.push_back(t);
}

template <class T>
int TreeTemplate<T>::getChildCount()
{
    return m_childList.size();
}

/* CLASS INHERITTING TEMPLATE */
class TreeItem : public TreeTemplate<TreeItem>
{
    public:
        std::string getTestName();
        TreeItem(std::string, std::string);

    private:
        std::string m_testID;
        std::string m_testName;
};

TreeItem::TreeItem(std::string test_id, std::string test_name)
{
    m_testID = test_id;
    m_testName = test_name;
}

std::string TreeItem::getTestName()
{
    return m_testName;
}

/* MAIN FUNCTION */
int main()
{
    TreeItem *myTree = new TreeItem("9", "10");
    TreeItem *child1 = new TreeItem("9.1", "10.1");
    TreeItem *child2 = new TreeItem();

    std::cout << myTree->getTestName() << std::endl;

    myTree->appendChild(child1);
    std::cout << myTree->getChildCount() << std::endl;
    return 0;
}

现在，如果我不尝试在派生类中添加一些新的构造函数（即构造函数overload），那么一切都很好。但是，如果我添加一个新的构造函数（如代码段所示），我无法访问现有的构造函数（Base Template类）。我在第TreeItem *child2 = new TreeItem();行

中收到以下错误

我在这里做些蠢事吗？我可以重载其他方法，只在构造函数失败。如何重载基本模板类的现有构造函数？

Answer 1

要解决两个问题。第一个是当为类型定义构造函数时，不会隐式生成该类型的默认构造函数。您可以使用= default强制它。这是一个例子。

struct Foo {
    Foo() = default;    // Allows default construction
    Foo(int value) : m_value(value) {}
    int m_value;
};

第二个问题是派生类型不会继承它的父类`＆＃39;构造函数。直观地，在以下示例中，类型Base的构造函数如何构造类型为Derived的实例？ Base未了解Derived个成员。

class Base {
public:
    Base(int x, int y) : m_x(x), m_y(y) {}
private:
    int m_x;
    int m_y;
};

class Derived : public Base {
public:
    Derived(int x, int y, int z) : Base(x, y), m_z(z) {}
private:
    int m_z;
};

void foo()
{
    // If we use Base's constructor, what is m_z?
    // Won't compile
    Derived bar(1, 2);
}

只有实际构建类型的构造函数才符合条件，而不是它的基本类型＆＃39;构造函数。要模拟行为，您必须为要支持的参数集提供新的构造函数。

class Derived : public Base {
public:
    Derived(int x, int y, int z) : Base(x, y), m_z(z) {}
    Derived(int x, int y) : Base(x, y), m_z(0) {}
private:
    int m_z;
};

在某些情况下，您可以通过提供类似以下示例的可变参数模板构造函数来解决此问题。只有在有特殊需要时，才应该这样做。

#include <utility>

class Base {
public:
    Base(int x, int y) : m_x(x), m_y(y) {}
private:
    int m_x;
    int m_y;
};

class Derived : public Base {
public:
    template<class ... Args>
    Derived(Args&&... args) : Base(std::forward<Args>(args)...) {};
};

void foo()
{
    Derived b(1, 2);
}

了解C ++模板类的继承

1 个答案: