27

我必须处理一个由许多模板类组成的库,这些类当然都是在头文件中实现的。现在我试图找到一种方法来减少无法忍受的长编译时间,因为我几乎必须将整个库包含在我的每个编译单元中。

尽管有模板,但是否有可能使用前向声明?我正在尝试按照下面示例的方式进行操作,例如,我试图绕过#include <vector>, 但它给了我一个链接器错误,因为push_back它是未定义的。

#include <iostream>

namespace std {
  template<class T>
  class vector {
  public:
    void push_back(const T& t);
  };
}

int main(int argc, char** argv) {
  std::vector<int>* vec = new std::vector<int>();
  vec->push_back(3);
  delete vec;
  return EXIT_SUCCESS;
}

$ g++ fwddecl.cpp
ccuqbCmp.o(.text+0x140): In function `main':
: undefined reference to `std::vector<int>::push_back(int const&)'
collect2: ld returned 1 exit status

我曾经尝试过预编译的头文件,但这根本没有改变编译时间(我确实确保它们确实被加载而不是真正的头文件)。但是如果你们都说预编译的头文件应该是要走的路,那么我会再试一次。

更新:有些人说前向声明 STL 类是不值得的。我要强调的是,vector上面的 STL 只是一个例子。我并没有真正尝试前向声明 STL 类,但它是关于我必须使用的某些库的其他大量模板化的类。

更新2:有没有办法让上面的例子真正编译和链接正确?洛根建议使用-fno-implicit-templates并放在template class std::vector<int>某个地方,大概是一个单独的.cpp文件,用 . 编译-fno-implicit-templates,但我仍然得到链接器错误。同样,我试图了解它是如何工作的,std::vector以便我可以将它应用到我实际使用的模板类中。

4

4 回答 4

38

您不能像这样转发声明类的“部分”。即使可以,您仍然需要在某处实例化代码,以便您可以链接它。有一些方法可以处理它,你可以让自己成为一个带有公共容器(例如vector)实例化的小库并将它们链接起来。然后你只需要编译一次,例如vector<int>。要实现这一点,您需要使用类似的东西-fno-implicit-templates,至少假设您坚持使用 g++ 并使用template class std::vector<int>


所以,一个真实的工作示例。这里我有 2 个文件,a.cp​​p 和 b.cpp

一个.cpp:

#include <vector> // still need to know the interface
#include <cstdlib>

int main(int argc, char **argv) {
  std::vector<int>* vec = new std::vector<int>();
  vec->push_back(3);
  delete vec;
  return EXIT_SUCCESS;
}

所以现在我可以编译 a.cpp 了-fno-implicit-templates

g++ -fno-implicit-templates -c a.cpp

这会给我 ao 如果我然后我尝试链接 ao 我得到:

g++ a.o
/usr/bin/ld: Undefined symbols:
std::vector<int, std::allocator<int> >::_M_insert_aux(__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, int const&)
void std::_Destroy<int*, std::allocator<int> >(int*, int*, std::allocator<int>)
collect2: ld returned 1 exit status

不好。所以我们转向b.cpp:

#include <vector>
template class std::vector<int>;
template void std::_Destroy(int*,int*, std::allocator<int>);
template void std::__uninitialized_fill_n_a(__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, unsigned long, int const&, std::allocator<int>);
template void std::__uninitialized_fill_n_a(int*, unsigned long, int const&, std::allocator<int>);
template void std::fill(__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, int const&);
template __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > > std::fill_n(__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, unsigned long, int const&);
template int* std::fill_n(int*, unsigned long, int const&);
template void std::_Destroy(__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, std::allocator<int>);

现在你对自己说,所有这些额外的模板东西是从哪里来的?我看到了template class std::vector<int>,那很好,但是其余的呢?简短的回答是,这些东西的实现必然有点混乱,当你手动实例化它们时,这些混乱的一部分会泄露出来。您可能想知道我是如何弄清楚我需要实例化什么的。好吧,我使用了链接器错误;)。

所以现在我们编译 b.cpp

g++ -fno-implicit-templates -c b.cpp

我们得到 bo 连接 ao 和 bo 我们可以得到

g++ a.o b.o

万岁,没有链接器错误。

因此,要了解有关您更新的问题的一些详细信息,如果这是一门自酿课程,则不一定要如此混乱。例如,您可以将接口与实现分开,例如,除了 a.cpp 和 b.cpp 之外,我们还有 ch、c.cpp

ch

template<typename T>
class MyExample {
  T m_t;
  MyExample(const T& t);
  T get();
  void set(const T& t);
};

cpp

template<typename T>
MyExample<T>::MyExample(const T& t) : m_t(t) {}
template<typename T>
T MyExample<T>::get() { return m_t; }
template<typename T>
void MyExample<T>::set(const T& t) { m_t = t; }

a.cpp

 #include "c.h" // only need interface
 #include <iostream>
 int main() {
   MyExample<int> x(10);
   std::cout << x.get() << std::endl;
   x.set( 9 );
   std::cout << x.get() << std::endl;
   return EXIT_SUCCESS;
 }

b.cpp,“库”:

 #include "c.h" // need interface
 #include "c.cpp" // need implementation to actually instantiate it
 template class MyExample<int>;

现在您将 b.cpp 编译为 bo 一次。当 a.cpp 更改时,您只需要重新编译它并链接到 bo

于 2009-02-17T02:31:02.150 回答
22

前向声明让您可以这样做:

template <class T> class vector;

然后,您可以在不定义向量的情况下声明对的引用和指针vector<whatever>(不包括vector的头文件)。这与常规(非模板)类的前向声明相同。

特别是模板的问题在于,您通常不仅需要类声明,还需要头文件中的所有方法定义(以便编译器可以实例化所需的模板)。显式模板实例化(您可以强制使用 with -fno-implicit-templates)是一种解决方法;您可以将方法定义放在源文件中(或者,按照Google Style Guide的示例,放在-inl.h您不必包含的头文件中),然后像这样显式实例化它们:

template <class int> class vector;

请注意,您实际上并不需要-fno-implicit-templates从中受益;编译器将默默地避免实例化它没有定义的任何模板,假设链接器稍后会解决它。并且添加-fno-implicit-templates会使所有模板的使用变得更加困难(不仅仅是耗时的模板),所以我不推荐它。

您的示例代码的问题是您没有转发声明真正的std::vector类。通过不包括<vector>,您正在创建自己的非标准vector类,并且您从未定义push_back,因此编译器无需实例化。

我使用预编译的头文件效果很好;我不确定他们为什么不帮助你。您将所有不变的头文件放在一个单独的文件中all.h,对其进行预编译,并使用已加载的strace或类似的文件进行验证,all.h.pch而单个头文件不是?(如何使用strace:而不是运行g++ mytest.cc,运行strace -o strace.out g++ mytest.cc,然后strace.out在文本编辑器中查看并搜索open(调用以查看正在读取哪些文件。)

于 2009-02-17T03:35:56.223 回答
6

使用前向声明,您只能将成员或参数声明为该类型的指针或引用。您不能使用任何方法或其他需要所述类型的内脏的东西。也就是说,我发现前向声明在尝试加快编译时间时确实受到限制。我建议您进一步研究预编译头文件的可能性,因为我发现它们确实有助于缩短编译时间,尽管这是在 Windows 上使用 Visual C++ 而不是 g++。

于 2009-02-17T02:33:53.393 回答
3

<iosfwd>将为您提供 iostream 类的一些前向声明,但一般而言,在前向声明它们方面,您对 stl 模板无能为力。

预编译的标头是要走的路。第一次编译它们时您不会注意到任何速度增加,但是每次修改预编译头(或其中包含的任何内容)时,您应该只支付一次该价格。

有关加快编译的其他想法,请参阅此问题。

于 2009-02-17T02:32:26.673 回答