链接错误

  • 不同于一般代码的是，对模板使用头文件声明、源文件定义的组织方式，编译器会接受，但链接器会产生无法找到函数定义的错误 ```cpp // basics/myfirst.hpp

ifndef MYFIRST_HPP

define MYFIRST_HPP

template void printTypeof(const T&);

endif // MYFIRST_HPP

// basics/myfirst.cpp

include “myfirst.hpp”

include

template void printTypeof(const T& x) { std::cout << typeid(x).name() << ‘\n’; }

// basics/myfirstmain.cpp

include “myfirst.hpp”

int main() { double pi = 3.14; print_typeof(pi); // 为double类型调用函数模板 }

  2. - 原因是编译器看到函数调用时，还没看到基于double实例化的函数定义，只是假设在别处提供了定义，并产生一个指向该定义的引用，并让链接器利用该引用解决此问题
  4. <a name="332a23ad"></a>
  5. ## 包含模型
  7. - 对于头文件中声明模板导致链接错误的问题有三个解决方案：一是在模板头文件中包含源文件，二是在每个使用模板的地方包含源文件，三是删掉源文件，直接在头文件中同时包含模板的声明和定义
  8. ```cpp
  9. // basics/myfirst2.hpp
  11. #ifndef MYFIRST_HPP
  12. #define MYFIRST_HPP
  14. #include <iostream>
  16. template<typename T>
  17. void printTypeof(const T&);
  19. template<typename T>
  20. void printTypeof(const T& x)
  21. {
  22.   std::cout << typeid(x).name() << '\n';
  23. }
  25. #endif   //MYFIRST_HPP
  • 模板的这种组织方式称为包含模型，包含模型最大的缺点是增加了包含头文件的开销。主要的开销不是模板定义本身大小，而是其中包含的头文件的大小，中包含了许多类似的模板定义，这样会带来成千上万行代码

显式实例化

  • 函数模板自身不是类型或函数或任何实体。从仅包含模板定义的源文件不生成代码。为使得代码出现，必须实例化模板，除了隐式实例化，还可以显式实例化 ```cpp template void f(T) {}

template void f(int); // 实例化f(int)，无实参推断 template void f<>(float); // 实例化f(float)，有实参推断 template void f(long); // 实例化f(long)，有实参推断

  2. - C++11中在显式实例化中可以使用extern关键字来表示声明而不定义，显式实例化声明将阻止函数模板的隐式实例化。编译器遇到extern模板声明不会在本文件中生成实例化代码，extern表示承诺在程序其他位置有该实例化的一个非extern声明（定义）。对一个给定的实例化版本可能有多个extern声明，但只能有一个定义
  3. ```cpp
  4. extern template void f<int>(int); // 声明但不定义
  • 同理，类模板也能显式实例化，C++11中也可以使用extern关键字修饰。显式实例化一个类也会实例化所有成员 ```cpp template class A { public: void f() {} };

template class A; // 同时显式实例化template void A::f() template void A::f(); // 仅显式实例化该成员

  2. - 显式实例化后，不能再特化实例化过的版本
  3. ```cpp
  4. template<typename T>
  5. void f() {}
  7. template void f<int>(); // 显式实例化
  9. template<> // 错误：已经基于int实例化过，不能再对int特化
  10. void f<int>()
  11. {
  12.   std::cout << 1;
  13. }
  • 但特化过后可以显式实例化，实例化的是特化版本 ```cpp

    include

template void f() {}

template<> void f() { std::cout << 1; }

template void f(); // 显式实例化的是特化的定义

int main() { f(); // 1 }

  2. - 显式实例化不会影响类型推断规则，它只是实例化了一个实体，并不是一个可以优先匹配的非模板函数。从函数模板实例化而来的函数永远不和普通函数等价
  3. ```cpp
  4. template<typename T>
  5. void f(T, T) {}
  7. template void f<double>(double, double); // 显式实例化
  9. f(1, 3.14); // 错误：推断类型不一致，不存在可匹配的普通函数void f(double, double)
  10. f<double>(1, 3.14); // OK

整合包含模型和显式实例化

  • 声明的头文件 ```cpp // stack.hpp

    ifndef STACK_HPP

    define STACK_HPP

include

template class Stack { public: Stack(); void push(const T&); void pop(); T top() const; private: std::vector elems; };

endif

  2. - 定义的头文件
  3. ```cpp
  4. // stackdef.hpp
  5. #ifndef STACKDEF_HPP
  6. #define STACKDEF_HPP
  8. #include "stack.hpp"
  9. #include <cassert>
  11. template<typename T>
  12. void Stack<T>::push(const T& elem)
  13. {
  14.   elems.push_back(elem);
  15. }
  17. template<typename T>
  18. void Stack<T>::pop()
  19. {
  20.   assert(!elems.empty());
  21.   elems.pop_back();
  22. }
  24. template<typename T>
  25. T Stack<T>::top() const
  26. {
  27.   assert(!elems.empty());
  28.   return elems.back();
  29. }
  31. #endif
  • 此时包含实现定义的头文件即可直接使用模板，这就是包含模型 ```cpp

    include

    include

    include “stackdef.hpp”

int main() { Stack intStack; intStack.push(42); std::cout << intStack.top() << std::endl; intStack.pop();

Stack stringStack; stringStack.push(“hello”); std::cout << stringStack.top() << std::endl; stringStack.pop(); }

  2. - 如果只包含声明的头文件，则还需要一个源文件来显式实例化要用到的模板实体。隐式实例化对构建时间有负面影响，而显式实例化能提高编译效率，一是没有隐式实例化的推断过程，二是把显式实例化放到一个文件中让其他文件包含，使用时只要实例化一次，减少了重复实例化次数
  3. ```cpp
  4. // stack_inst.cpp
  5. #include "stackdef.hpp"
  6. #include <string>
  8. // instantiate class Stack<> for int
  9. template class Stack<int>;
  11. // instantiate member functions of Stack<> for strings
  12. template Stack<std::string>::Stack();
  13. template void Stack<std::string>::push(std::string const&);
  14. template std::string Stack<std::string>::top() const;
  • 此时仅包含声明即可使用，但所使用的模板都必须在上述文件中手动实例化过。这也是显式实例化的缺点，必须仔细跟踪哪些实体要实例化，对于大型项目是一个巨大负担 ```cpp

    include

    include

    include “stack.hpp”

int main() { Stack intStack; intStack.push(42); std::cout << intStack.top() << std::endl; intStack.pop();

Stack stringStack; stringStack.push(“hello”); std::cout << stringStack.top() << std::endl; stringStack.pop(); // 错误：没有显式实例化std::string版本的此函数 }

  2. <a name="2ad7e69a"></a>
  3. ## 使用显式实例化声明
  5. - 由关键字extern指定的显式实例化称为显式实例化声明，它会抑制隐式实例化，但以下情况例外： 
  6.    - 内联函数为了展开内联，仍能被实例化
  7.    - auto或decltype(auto)类型变量和函数返回类型，仍可以被实例化来确定类型
  8.    - 值为常量表达式的变量仍能被实例化以计算它们的值
  9.    - 引用类型变量仍能被实例化，这样引用的实体才能被解析
  10.    - 类模板和别名模板，为了检查生成类型仍能被实例化
  11. - 使用显式实例化声明，可以在头文件中提供模板定义，以此抑制隐式实例化的特化。每个显式实例化声明必须与定义配对，省略定义将引发链接错误
  12. ```cpp
  13. // t.hpp:
  14. template<typename T> void f() {}
  16. extern template void f<int>(); // 声明但不定义
  17. extern template void f<float>(); // 声明但不定义
  19. // t.cpp:
  20. template void f<int>(); // 定义
  21. template void f<float>(); // 定义
  • 不同于手动实例化每需要一个新的特化都要手动更新显式实例化定义列表，显式实例化声明能在任何情况下作为一个优化引入。然而编译时间优化上就不如手动实例化了，因为可能产生一些冗余的隐式实例化，且模板定义也会被作为头文件的一部分解析

内联

  • 函数模板可以声明为inline或constexpr，说明符放在模板参数列表之后

    1. template<typename T>
    2. inline T min(const T&, const T&);

  • 然而编译器可能忽略这种内联，函数模板是否内联取决于编译器的优化策略

预编译头文件

  • 即使不存在模板，C++头文件也可以非常巨大，从而需要很长的编译时间，于是一种称为预编译头文件的机制实现了，该机制位于标准范围外，依赖于特定产品实现
  • 预编译头文件机制主要依赖于可以使用某种方式组织代码，让多个文件中前面的代码都是相同的，这样可以先编译完这些代码，并把编译器在这一点的状态存储到一个预编译头文件（通常为.pch）中，对于剩下文件的编译只需要先加载上面已经保存的状态，从下一行开始编译就可以了
  • 重新加载已保存的状态很快，但第一次编译并保存这个状态比编译这些代码慢，增加的时间代价根据实际情况在20%到200%不等
  • 对于被包含的头文件，注意#include包含顺序，不同顺序不能使用预编译头文件
  • 管理预编译头文件一种可取的方法是根据头文件的使用频率和稳定性分层，对于那些不会发生变化的头文件进行预编译。但如果在大型项目中，对所有文件预编译的时间可能比其能节省的时间多，因此关键在于对更稳定的头文件进行预编译，在不太稳定的头文件中重用这个稳定的预编译头文件

在Visual Studio中使用预编译头

  • 给项目添加stdafx.h和stdafx.cpp文件

  • 在stdafx.h中添加所有需要的头文件，如

    1. #pragma once
    2. #include <vector>
    3. #include <string>

  • stdafx.cpp只需要包含`stdafx.h``

    1. #include "stdafx.h"

  • 打开项目属性，将配置属性 - C/C++ - 预编译头 - 预编译头改为使用

  • 打开stdafx.cpp属性，将配置属性 - C/C++ - 预编译头 - 预编译头改为创建

图片.png

  • 在其他所有源文件中包含stdafx.h即可
    1. // file "test.cpp"
    2. #include "stdafx.h" // 相当于在test.h中包含了stdafx.h中的所有头文件