我很困惑为什么我的代码没有产生错误 invalid use of incomplete type ，虽然我对这个错误所做的所有阅读都表明它应该。
_{^{这个问题源于这个错误(正如预期的那样)出现在我的具有类似结构的代码部分，但我无法在小示例中重现它(请参阅 < em="">免责声明在问题的末尾)。}}

我正在尝试做的事情的总结:

• 我有一个结构 ( Tree )，我想分配基类型为 First 的不同对象
• 具体实现First具有不同的返回值，因此使用了两个级别的间接寻址:
• First是一个抽象基类，First *用于处理不同的具体实例。
• template <typename Type> class TypedFirst : public First是一个抽象类型，它定义了返回类型为 Type 的函数.
• 最后 ConcreteFirstX是 TypedFirst<Type> 的具体特化.

在tree.tpp , 为什么会调用 new TF(this) 不产生invalid use of incomplete type错误？ (代码中标记了该点)我认为错误应该在那里，因为 TF是一个模板，当我使用 ConcreteFirstA , tree.tpp不知道它(它不包括 concretefirsta.h 甚至不包括 first.h ，它仅转发声明 First )

此示例的完整、可编译和可运行的代码可以在here on pastebin 中找到。 .在这里，我将排除 #define为简洁起见，守卫和类似的东西。代码如下:

// tree.h
class First;
class Tree{
  public:
    Tree() {}
    ~Tree() {}
    template<class TF> // where TF is a ConcreteFirst
    void addFirstToTree();
  private:
    std::map<std::string, First *> firstCollection; // <- "First"'s here
};
#include "tree.tpp"

// tree.tpp
#include "tree.h"

template <class TF> // where TF is a ConcreteFirst
void Tree::addFirstToTree(){
  this->firstCollection[TF::name] = new TF(this); // <--- Why does this work?
  //                                ^^^^^^^^^^^^^      
}

// first.h
class Tree;
class First{
  public:
    static const std::string name;
    First(const Tree *baseTree) : myTree(baseTree) {}
    virtual ~First();
  protected:
    const Tree *myTree;
};

template <typename Type> class TypedFirst : public First{
  public:
    static const std::string name;
    TypedFirst(const Tree *baseTree) : First(baseTree) {}
    Type &value() {return this->_value;}
  private:
    Type _value;
};
#include "first.tpp"

// first.tpp
#include "first.h"
template <typename Type>
const std::string TypedFirst<Type>::name = "default typed";

// first.cpp
#include "first.h"
First::~First() {}
const std::string First::name = "default";

// concretefirsta.h
#include "first.h"
class ConcreteFirstA : public TypedFirst<int>{
  public:
    static const std::string name;
    ConcreteFirstA(const Tree *baseTree) : TypedFirst<int>(baseTree) {}
    ~ConcreteFirstA() {}
};

// concretefirsta.cpp
#include "concretefirsta.h"
const std::string ConcreteFirstA::name = "firstA";

最后，将所有这些组合在一起并进行(不)适当的函数调用的代码:

// main.cpp
#include "tree.h"
#include "first.h"
#include "concretefirsta.h"

int main(){
  Tree *myTree = new Tree();
  myTree->addFirstToTree<ConcreteFirstA>(); // <-- here! why is this working?
  delete myTree;
  return 0;
}

免责声明 这个问题实际上是由我遇到的一个更大的问题引起的，我认为这个问题在 Stack Overflow 格式中太大且无法回答。尽管我最初尝试问这个问题，但这个问题因为太宽泛而被关闭，我现在试图通过只问问题的一部分来挽救它。

我的问题是，我在一段与这段代码具有相同结构的代码中不断遇到错误:但是，我无法在一个小示例中重现它。

因此，我想问为什么下面的代码没有产生错误 invalid use of incomplete type (如我所料)，我希望这能帮助我理解和解决我的实际问题。

请不要告诉我这是 the XY problem 的情况:我知道我不是在问我的实际问题，因为我(和社区)认为它对于这种格式来说太大了。

最佳答案

main.cpp 包括 tree.h，其中(间接)包含有问题的 addFirstToTree() 模板和 concretefirsta。 h，其中包含ConcreteFirstA的定义。

稍后在 main.cpp 中，addFirstToTree() 被实例化为 ConcreteFirstA 类型:

myTree->addFirstToTree<ConcreteFirstA>(); // <-- here! why is this working?

此时编译器需要足够了解用作模板参数的类型，以便能够编译器 addFirstToTree()。它确实知道得足够多。 ConcreteFirstA 在这里是一个完整的类型，因为 concretefirsta.h 被包含并包含类定义。

早些时候在 tree.tpp 中定义了 addFirstToTree()，ConcreteFirstA 还没有定义，但这并不重要。编译器看到一个模板，但不知道稍后将实例化该模板的模板参数。任何依赖于模板参数(“相关名称”)的函数/...在不知道模板将针对哪些参数实例化的情况下无法解析，因此名称查找/...推迟到以后。

一旦模板被实例化并且编译器解析所有依赖名称并为特定模板参数编译模板。由于 ConcreteFirstA 在这一点上不是不完整的类型，因此可以正常工作。

关于c++ - 不完整类型的无效使用 - 为什么在这种情况下没有错误？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/26040469/