前向声明和模板函数错误

Question

目前，我在前向声明和模板函数方面遇到了令人沮丧的问题。 我一直在尝试谷歌搜索并进行一些修改，但到目前为止没有任何效果。 下面是代码片段：

class TaskScheduler; --> //forward declaration of ‘struct TaskScheduler’
//
//

class TaskEvent {
//
//
};

class HostTask {
//
//
};

template<class T> inline HostTask*
findT(TaskScheduler* tss, T* e)
{
    map<int, HostTask*>::iterator it;
    bool bEq = false;
    for(it = tss->tasks_.begin(); it != tss->tasks_.end(); it++) { --> //error: invalid use of incomplete type ‘struct TaskScheduler’
    if(dynamic_cast<TaskEvent*>(e))
        bEq = dynamic_cast<TaskEvent*>(e)->equal(it->second->ev_);
    else if(dynamic_cast<HostTask*>(e))
        bEq = dynamic_cast<HostTask*>(e)->equal(it->second);
    if(bEq) {
        return it->second;
    }
}
return NULL;
}
//

//class TaskScheduler definition
class TaskScheduler : virtual public HCIEventsHandler {
friend HostTask* findT<TaskEvent>(TaskScheduler* tss, TaskEvent* e); //findT function is used here
//
//
};

这是我收到的错误消息，该消息也显示在代码中： ./bt-taskscheduler.h:159：错误：“struct TaskScheduler”的前向声明 ./bt-taskscheduler.h:229：错误：无效使用不完整类型“struct TaskScheduler”

有人能告诉我这段代码出了什么问题吗？ 任何帮助表示赞赏..

Answer 1

在 findT 的定义中，您使用 tss->tasks_ ，它取消引用指向 TaskScheduler 类型的对象的指针，因此您需要完整的定义结构体的一部分，而不仅仅是程序中此时可见的前向声明。

struct TaskScheduler 的定义需要出现在 findT 函数模板的定义之前。

Answer 2

您正在 for 循环标头“tss->tasks_.begin()”中使用 TaskScheduler 类。 编译器不知道这个类是否有“tasks_”成员。

这不是模板的问题，头文件中内联的任何函数都会导致相同的错误。 类的前向声明仅允许您声明该类的指针（或引用）或将此类对象作为参数传递。 在完全定义类之前，您无法“使用”该类（调用其方法或获取成员数据）。

Answer 3

因为您在 findT 函数中使用 TaskScheduler 的定义，所以您有两个选择：

• 将 TaskScheduler 的定义移至 findT 模板函数上方
• 使 TaskScheduler 成为 findT 函数的第二个模板，

如下所示：

template< class U, class T> 
inline HostTask* findT( U* tss, T* e)
{
   //...
}

Answer 4

除了前向声明的麻烦之外，看起来您的 findT 函数实际上应该是调度程序类的成员函数：它广泛使用调度程序的数据成员。

这些成员是私有的，因此您需要一种方法来发布它们，并依靠 friend 声明。

因此，要么将成员公开，要么更好地将 findT 函数重构为成员函数。

将其设为模板化成员函数也没有问题。 并且您将自动摆脱好友声明。

//class TaskScheduler definition
class TaskScheduler : virtual public HCIEventsHandler {
 public:
  template<class T> inline HostTask* findT(T* e) const
  {
    map<int, HostTask*>::iterator it;
    bool bEq = false;
    for(it = tasks_.begin(); it != tasks_.end(); it++) { 
       if(dynamic_cast<TaskEvent*>(e))
          bEq = dynamic_cast<TaskEvent*>(e)->equal(it->second->ev_);
      else if(dynamic_cast<HostTask*>(e))
          bEq = dynamic_cast<HostTask*>(e)->equal(it->second);
      if(bEq) {
          return it->second;
      }
    }
    return NULL;
  }


};

Answer 5

正如其他发帖者所提到的，您在没有类型定义的情况下取消引用指向 TaskScheduler 的指针，这将导致错误，就像在任何定义中一样。

您可能感到困惑的是，您的代码可能适用于某些编译器，甚至是现代编译器（我知道 MSVC 在这方面是不正确的，但我不知道它是否会接受上述代码*）。 这些编译器没有正确实现所谓的“两阶段名称查找”。

两阶段名称循环是模板中使用的名称查找方法，比某些编译器使用的更简单的形式更可预测。 在更简单的形式中，模板定义仅在实例化时才被解析和存储以供使用，并且从实例化模板时开始对模板中的所有名称执行名称查找。 通过两阶段名称查找，模板中使用的名称将分为从属名称和非从属名称。 非依赖名称是编译器可以立即解析的名称 - 任何不直接或间接依赖模板参数的名称。 当您定义模板时，将立即处理这些名称。 另一方面，从属名称无法立即解析； 它们被存储，然后在执行实例化时，在模板的上下文中查找，而且还在实例化模板的上下文中查找 for 仅限参数相关查找。

这是一个例子：

 void foo (int);
 template <typename T> void bar(T t) {
   foo(1.0);
   foo(t);
 }
 void foo (double);

 struct qux {};
 void foo (qux);

 void baz () {
   bar (1.0);
   qux q;
   bar (q);
 }

注意，我知道我以错误的顺序得到了元句法名称。 我很抱歉，但我最后添加了 qux，并且懒得重写我的评论。

bar 模板的实例化每个调用 foo 两次。 第一个调用是非依赖的，因此编译器一看到它就会解析它。 结果是它调用 foo (int)，应用转换，即使它稍后会找到更好的定义。 这与 C++ 中的任何其他函数调用没有什么不同。 棘手的一点是第二个调用，它是相关的。 baz 中的第一个调用调用 bar，后者调用 bar。 实例化的 bar 尝试使用 T 类型的对象调用 foo。 在 double 场景中，由于基元从不使用依赖参数的查找，因此再次仅从 bar 和 foo(int) 查找结果> 被发现。 然而，当使用 qux 调用时，依赖于参数的查找将同时应用于定义和实例化上下文**，因此 foo(qux)叫做。

它可能有点愚蠢，但它往往会做正确的事。 另外，我希望你能真正理解这一点； 这可能相当令人困惑。 您需要阅读该维基百科链接才能完全理解。

* MSVC 可以实现一种较小形式的两阶段名称查找，它可以正确解析非依赖名称，但它会考虑依赖名称模板之后的定义。 我忘记了它是执行此操作还是完全省略两阶段查找，并且我没有要检查的程序副本。

** 几乎在每种情况下，实例化上下文都包含定义上下文所做的每个声明。 然而，export 关键字可能会导致情况并非如此。 该关键字仅在一个编译器前端中实现 - 我想知道为什么没有其他人实现它？ [/讽刺]