Question

我坚持使用这种模式，因为仅实例化了我创建的一个派生类。已通过g ++和MSVS检查。具体而言，仅创建我定义的第一个派生类。编译器不会发出任何警告。下面提供了完整的代码。

#include <iostream>

static int nodes = 0;

class TreeNode {
private:
    int m_id;
public:
    TreeNode() : 
        m_id(++nodes)
    {}
    TreeNode(int id) :
        m_id(id)
    {
        ++nodes;
    }
    TreeNode* left;
    TreeNode* right;

    int getId() const {
        return m_id;
    }
};


template<typename T>
//typename std::enable_if<std::is_base_of<TreeParser, T>::value>::type
class TreeParser {
protected:
    TreeParser() {
        ++parsers;
    }
public:
    static uint32_t parsers;
    void preorderTraversal(TreeNode* node) {
        if (node != nullptr) {
            processNode(node);
            preorderTraversal(node->left);
            preorderTraversal(node->right);
        }
    }
    virtual ~TreeParser() = default;

    void processNode(TreeNode* node) {              // 2, 3. the generic algorithm is customized by derived classes
        static_cast<T*>(this)->processNode(node);   // depending on the client's demand - the right function will be called
    }
};

template<class T>
uint32_t TreeParser<T>::parsers = 0;

class SpecializedTreeParser1 : public TreeParser<SpecializedTreeParser1> // 1. is-a relationship
{
public:
    explicit SpecializedTreeParser1() : 
        TreeParser()
    {}
    void processNode(TreeNode* node) {
        std::cout << "Customized (derived - SpecializedTreeParser1) processNode(node) - "
            "id=" << node->getId() << '\n';
    }
};

class SpecializedTreeParser2 : public TreeParser<SpecializedTreeParser2> // 1. is-a relationship
{
public:
    explicit SpecializedTreeParser2() : 
        TreeParser()
    {}
    void processNode(TreeNode* node) {
        std::cout << "Customized (derived - SpecializedTreeParser2) processNode(node) - "
            "id=" << node->getId() << '\n';
    }
};


int main() 
{
    TreeNode root;
    TreeNode leftChild;
    TreeNode rightChild;

    root.left = &leftChild;
    root.right = &rightChild;

    std::cout << "Root id: " << root.getId() << '\n';
    std::cout << "Left child id: " << leftChild.getId() << '\n';
    std::cout << "Right child id: " << rightChild.getId() << '\n';

    SpecializedTreeParser1 _1;
    _1.preorderTraversal(&root);

    SpecializedTreeParser2 _2;
    _2.preorderTraversal(&root);
}

输出为：

Root id: 1
Left child id: 2
Right child id: 3
Customized (derived - SpecializedTreeParser1) preorderTraversal() - id=1
Customized (derived - SpecializedTreeParser1) preorderTraversal() - id=2
Customized (derived - SpecializedTreeParser1) preorderTraversal() - id=1963060099 // what is that?

为什么我不能实例化第二个派生类？

Answer 1

我没记错，您的程序有未定义的行为。 left和right的{{1}}和leftChild指针未初始化，因此一旦rightChild到达那里，程序就会崩溃。这就是为什么最终会得到奇怪的preorderTraversal()的原因：它是从某个随机的内存位置读取的...

要解决此问题，请确保id的{{1}}和left成员始终初始化为right，这与其余代码似乎期望的一样：< / p>

TreeNode

Answer 2

问题是SpecializedTreeParser2 _2;。 TreeParser leftChild和 rightChild已初始化好，其id已打印。检查输出

哦，不确定行为的乐趣...

否，TreeParser leftChild和rightChild初始化没有问题，问题不是SpecializedTreeParser2 _2。

问题是TreeNode::left;和TreeNode* right;的使用未初始化。这将导致您的程序具有未定义的行为，并且美丽的未定义行为是整个程序具有未定义的行为，而不仅仅是未初始化变量的使用。这意味着尽管SpecializedTreeParser1 _1看起来还可以，但实际上并非如此。您看到的输出是行为未定义的行为。分析它的来源毫无意义，为什么_1似乎起作用而_2却没有作用。这是未定义的行为。修复它，不要试图理解为什么这种特定行为。

让我通过一个简短的示例向您展示我的意思：

int main()
{
    int a = 24;
    std::cout << a << std::endl;

    int b; // uninitialized
    std::cout << b << std::endl; // <-- this line makes the WHOLE program to have UB
}

现在上述程序的可能行为是什么？

print "24"
print <garbage>

可能且合理的期望

print "24"
print "0"

也是可能的

print "24"
<crash>

也不足为奇

print <garbage>
print "24"

也可能...等等什么？是！！程序的不确定性质不必在std::cout << b << std::endl行中体现。程序的整个执行是不确定的。 任何事情都可能发生！

所有这些都是可能的：

<crash>

print "0"
print "0"

print "24"
print "24"

print "24"
print "0"
<crash>

print "Here be dragons"

奇怪的重复模板模式-不能创建多个派生类吗？

2 个答案: