C++将模板实现放入头文件原理解析

目录
  • 写在前面
  • 例子
  • 原因
  • 分析
  • 解决方案
    • 方案一
    • 方案二
  • 参考
  • 写在后面

写在前面

本文通过实例分析与讲解,解释了为什么C++一般将模板实现放在头文件中。这主要与C/C++的编译机制以及C++模板的实现原理相关,详情见正文。同时,本文给出了不将模板实现放在头文件中的解决方案。

例子

现有如下3个文件:

// add.h
 template <typename T>
 T Add(const T &a, const T &b);
 // add.cpp
 #include "add.h"
 template <typename T>
 T Add(const T &a, const T &b)
 {
     return a + b;
 }
 // main.cpp
 #include "add.h"
 #include <iostream>
 int main()
 {
     int res = Add<int>(1, 2);
     std::cout << res << "\n";
     return 0;
 }

现象

使用 g++ -c add.cpp 编译生成 add.o ,使用 g++ -c main.cpp 编译生成 main.o ,这两步都没有问题。

使用 g++ -o main.exe main.o add.o 生成 main.exe 时,报错 undefined reference to 'int Add(int const&, int const&)' 。

当然,直接 g++ add.cpp main.cpp -o main.exe 肯定也会报错,这里把编译和链接分开是为了更好地展示与分析问题。​

原因

出现上述问题的原因是:

(1)C/C++源文件是按编译单元(translation unit)分开、独立编译的。所谓translation unit,其实就是输入给编译器的source code,只不过该source code是经过预处理(pre-processed​,包括去掉注释、宏替换、头文件展开)的。在本例中,即便你使用 g++ add.cpp main.cpp -o main.exe ,编译器也是分别编译 add.cpp 和 main.cpp (注意是预处理后的)的。在编译 add.cpp 时,编译器根本感知不到 main.cpp 的存在,反之同理。

(2) C++模板是通过实例化(instantiation)来实现多态(polymorphism)的。以函数模板为例,首先需要区分“函数模板”和“模板函数”。本例中,上面代码的第8~12行是函数模板,顾名思义,它就是一个模子,不是具体的函数,是不能运行的;当用具体的类型,如 int ,实例化模板参数 T 后,会生成函数模板的一个具体实例,称为模板函数,这是真正可以运行的函数。“函数模板”和“模板函数”的关系,可以类比“类”和“对象”的关系。以 int 为例,生成的实例/模板函数大概长这样(细节上肯定和编译器的实际实现有出入,但核心意思不会变)。

 int Add_int_int(const int &a, const int &b)
 {
     return a + b;
 }

​对于每一个用到的具体类型,编译器都会生成对应版本的实例,当函数调用时,会调用到该实例。如用到了 Add<int> ,就会生成 Add_int_int ,用到了 Add<double> ,就会生成 Add_double_double ,等等。本例中,当编译器编译到第20行,即 int res = Add<int>(1,2); 一句时,编译器就会试图生成 int 版本的模板实例(即模板函数)。

(3)编译器为模板生成实例的必要条件是:1. 知道模板的具体定义/实现;2. 知道模板参数对应的实际类型。

分析

下面把上面两节内容结合起来分析。

(1)当编译 add.cpp 时,相当于编译

 template <typename T>
 T Add(const T &a, const T &b);
 template <typename T>
 T Add(const T &a, const T &b)
 {
     return a + b;
 }

此时编译器虽然知道模板的具体定义,却不知道模板参数 T 的具体类型,因此不会生成任何的实例化代码。

(2)当编译 main.cpp 时,相当于编译

 #include <iostream>
 template <typename T>
 T Add(const T &a, const T &b);
 int main()
 {
     int res = Add<int>(1, 2);
     std::cout << res << "\n";
     return 0;
 }

当编译到 int res = Add<int>(1, 2); 时,编译器想要生成 int 版本的函数实例,但它找不到函数模板的具体定义(即 Add 的“函数体”),只好作罢。好在编译器看到了函数模板的声明,于是通过了编译,将寻找 int 版本函数实例的任务留给了链接器。​

至此,编译 add.cpp 时,只知模板定义,不知模板类型参数,无法生成具体的函数定义;编译 main.cpp 时,只知模板类型参数,不知模板定义,同样无法生成具体的函数定义。​

(3)没什么好说的,链接器在 add.o 和 main.o 中都没找到 int 版本的 Add 定义,直接报错。​

解决方案

方案一

传统方法:把模板实现也放在头文件中。

// add.h
 template <typename T>
 T Add(const T &a, const T &b)
 {
     return a + b;
 }
 // main.cpp
 #include "add.h"
 #include <iostream>
 int main()
 {
     int res = Add<int>(1, 2);
     std::cout << res << "\n";
     return 0;
 }

当编译 main.cpp 时,相当于编译​

 #include <iostream>
 template <typename T>
 T Add(const T &a, const T &b)
 {
     return a + b;
 }
 int main()
 {
     int res = Add<int>(1, 2);
     std::cout << res << "\n";
     return 0;
 }

此时编译器既知道函数模板的定义,又知道具体的模板类型参数 int ,因此可以生成 int 版本的函数实例,不会出错。​

这种方式的优缺点如下:

  • 优点:可以按需生成。假如我们在 main.cpp 中调用了 Add<double>(1.0, 2.0); ,编译器就会为我们生成 double 版本的函数实例。
  • 缺点:不得不把实现细节暴露给用户。

方案二

模板声明和定义分离的方案。​

 // add.h
 template <typename T>
 T Add(const T &a, const T &b);
 // add.cpp
 #include "add.h"
 template <typename T>
 T Add(const T &a, const T &b)
 {
     return a + b;
 }
 template int Add(const int &a, const int &b);
 // main.cpp
 #include "add.h"
 #include <iostream>
 int main()
 {
     int res = Add<int>(1, 2);
     std::cout << res << "\n";
     return 0;
 }

注意, template int Add(const int &a, const int &b); 是函数模板实例化(function template instantiation)[1], template 关键字不能省略,否则, int Add(const int &a, const int&b); 会被编译器当做普通函数的声明,从而在链接时又会报 undefined reference to 'int Add(int const&, int const&)' 错误。​

对于这种写法,编译器在编译 add.cpp 时,既能看到函数模板的定义,又能看到具体的模板类型参数 int ,于是生成了 int 版本的函数实例,整个程序可以正常编译运行。​

很显然,这种情况下编译器只生成了 int 版本的函数实例,所以,在 main.cpp 中使用 Add<double>(1.0, 2.0); 这样的代码肯定是不可以的。这种情况的优缺点可以辩证看待:​

优点:

  • 1. 可以隐藏实现细节(我们可以把 add.cpp 做成.lib或.dll);
  • 2. 也可以限制只实例化特定的版本。​

缺点:就是只能使用特定的几个版本,不能像方案一那样在编译 main.cpp 时根据具体的调用情况按需生成。​

从这里也可以看出,模板实现不一定非得放在头文件中。

参考

[1] Function template - cppreference.com

[2] c++ - Why can templates only be implemented in the header file? - Stack Overflow

写在后面

本文从C/C++编译机制以及C++模板实现原理的角度,结合具体实例,讲解了为什么一般将模板实现放在头文件中。由于在下才疏学浅,能力有限,错误疏漏之处在所难免,恳请广大读者批评指正,您的批评是在下前进的不竭动力,更多关于C++头文件放入模板实现的资料请关注我们其它相关文章!

时间: 2022-06-03

如何C++使用模板特化功能

目录 前言: 1.函数模板的特化 2.类模板的特化 前言: 通过定义模板,使得函数或者类不依赖于特定的类型,这样大幅提升了代码的复用性. 然而,不管是类模板还是函数模板,对所有的类型都是采用相同的处理方式(同一份代码).为此,C++提出了“模板特化的概念”,对特定类型提供模板的改造. 比如,对于函数模板来说,可以通过特化指定特定的类型,针对此特定类型对函数体内容进行重写,使得函数对特定类型实现特定功能. 注意: 按照语法,对函数模板和类模板进行特化后,就变为普通函数和普通的类,而不再是模板. 1

c++分离讲解模板的概念与使用

目录 泛类编程 函数模板 函数模板的概念 函数模板的使用 函数模板的实例化 函数模板的匹配原则 类模板 类模板的定义格式 类模板的实例化 泛类编程 学习模板,首先我们需要了解一下什么是泛类编程 #include<iostream> using namespace std; int add(int a, int b) { return a + b; } double add(double a, double b) //这两个add构成了函数重载 { return a + b; } int mai

C++可变参数模板的展开方式

文章目录 前言可变参数模板的定义参数包的展开递归函数方式展开逗号表达式展开enable_if方式展开折叠表达式展开(c++17) 总结 前言 可变参数模板(variadic templates)是C++11新增的强大的特性之一,它对模板参数进行了高度泛化,能表示0到任意个数.任意类型的参数.相比C++98/03这些类模版和函数模版中只能含固定数量模版参数的“老古董”,可变模版参数无疑是一个巨大的进步. 如果是刚接触可变参数模板可能会觉得比较抽象,使用起来会不太顺手,使用可变参数模板时通常离不开模

C++超详细讲解模板的使用

目录 一.函数模板 1.1函数模板概念 1.2 函数模板格式 1.3 函数模板的原理 1.4 函数模板的实例化 二.类模板 2.1 类模板的定义格式 2.2类模板的实例化 总结 一.函数模板 1.1函数模板概念 函数模板代表了一个函数家族,该函数模板与类型无关,在使用时被参数化,根据实参类型产生函数的特定类型版本. 1.2 函数模板格式 template<typename T1, typename T2,…,typename Tn> 返回值类型 函数名(参数列表){} template<

C++11中模板隐式实例化与显式实例化的定义详解分析

目录 1. 隐式实例化 2. 显式实例化声明与定义 3. 显式实例化的用途 1. 隐式实例化 在代码中实际使用模板类构造对象或者调用模板函数时,编译器会根据调用者传给模板的实参进行模板类型推导然后对模板进行实例化,此过程中的实例化即是隐式实例化. template<typename T> T add(T t1, T2) { return t1 + t2; } template<typename T> class Dylan { public: T m_data; }; int ma

C++&nbsp;深入浅出探索模板

目录 非类型模板参数 模板特化 函数模板特化 类模板特化 全特化 偏特化 模板分离编译 模板的分离编译 解决方法 总结 非类型模板参数 模板参数分类类型形参与非类型形参. 类型形参:出现在模板参数列表中,跟在class或者typename之类的参数类型名称. 非类型形参,就是用一个常量作为类(函数)模板的一个参数,在类(函数)模板中可将该参数当成常量来使用. 注意: 浮点数,类对象以及字符串是不允许作为非类型模板的. 非类型的模板参数必须在编译期就能确认结果. 模板特化 有时候,编译默认函数模板

C++模板Template详解及其作用介绍

目录 1. 模板 2. 函数模板 2.1 函数模板概念 2.2 函数模板格式 2.3 函数模板原理 2.4 函数模板的实例化 2.5 模板参数的匹配原则 2.6声明定义分离 3. 类模板 3.1 类模板格式 3.2 类模板的实例化 3.3 类模板中函数放在类外进行定义时 4. 模板分离编译 4.1 什么是分离编译 4.2 模板的分离编译 5. 缺省值与返回值 6. 总结 1. 模板 首先模板分为函数模板和类模板 想到模板,就会联想到泛型编程 泛型编程:编写与类型无关的通用代码,是代码复用的一种手

c++模板自定义数组

目录 1.自定义数组.hpp--文件 2.测试文件 前言: 制造通用模板,创建自定义的数组, 一个数组,里面有这么几个属性,数组容量,数组元素个数,数组本身内存地址,这几个数据都是定义私有类型,提供有参构造,让用户可以构造出这个数组对象.下面是有参构造和拷贝构造和析构函数还有operator=重载的代码 在前面类模板中成员函数创建有这个主意问题,最好的办法就是把类模板写在一个hpp的文件中,不要拆开写成多个文件 1.自定义数组.hpp--文件 #pragma once #include<iost

C++模板全方位深入解读

目录 1.泛型编程 2.函数模板 概念 函数模板的格式 函数模板的原理 函数模板的实例化 隐式实例化 显式实例化 模板参数的匹配原则 3.类模板 (1) 类模板的定义格式 (2) 类模板的实例化 4.非类型模板参数 5.模板特化 (1)函数模板的特化 (2)类模板的特化 全特化 偏特化 6.模板的分离编译 问题分析 1.泛型编程 如何实现一个通用的交换函数? 这点函数重载可以做到,比如一下Swap函数的重载,分别重载了俩种不同参数类型的Swap void Swap(int& x, int&

解读C++编程中类模板的三种特化

1.类模板显式特化 为了进行特化,首先需要一个通用的版本,称主模板.主模板使用了标准库堆算法.  堆 是一种线性化的树形结构,将一个值压入一个堆中, 实际上等于将该值插入到一个树形结构中;将一个值从堆中取出就等于移除并返回堆中最大值.但在处理字符的指针时会碰钉子.堆将按照指针的值进行组织. 我们可以提供一个显式特化版本解决此问题(例1)如果希望除了一个针对const char*的Heap外,还希望提供一个针对char *的Heap;(例2) //主模板 template <typename T>

PHP中MVC模式的模板引擎开发经验分享

使Web系统的开发与维护更加方便,从而有效的节省人力物力,受到了越来越多企业的青眯. 模板引擎是MVC模式建立过程的重要方法,开发者可以设计一套赋予含义的标签,通过技术解析处理有效的把数据逻辑处理从界面模板中提取出来,通过解读标签的含义把控制权提交给相应业务逻辑处理程序,从而获取到需要的数据,以模板设计的形式展现出来,使设计人员能把精力更多放在表现形式上.下面是我对模板引擎的认识与设计方法: 说的好听些叫模板引擎,实际就是解读模板数据的过程(个人观点^^).通过我对建站方面的思考认识,网站在展现

使用vue官方提供的模板vue-cli搭建一个helloWorld案例分析

安装环境 安装node.js并配置环境变量 安装淘宝镜像,npm install -g cnpm --registry=https://registry.npm.taobao.org 安装webpack,cnpm install webpack -g 安装脚手架npm install vue-cli -g 创建项目 在硬盘上找一个文件夹放工程用的,在终端中进入该目录,cd目录路径 根据模板创建项目,vue init webpack-simple 工程名字<工程名字不能用中文>,vue init

详解搭建一个vue-cli的移动端H5开发模板

简介 vue-mobile 是是基于 vue-cli 实现的移动端 H5 开发模板,其中已经搭建好基本的开发框架,可帮助您实现快速开发. 技术栈:vue + vux + axios + less 源码地址:https://github.com/Michael-lzg/vue-mobile 功能 搭建项目目录 配置 css 预处理器 配置 UI 组件库 vux 解决移动端适配 配置页面路由缓存 axios 请求封装 工具类函数封装 toast 组件封装 dialog 组件封装 底部导航组件封装 列

thinkPHP5框架渲染模板的3种方式简述

本文实例讲述了thinkPHP5框架渲染模板的3种方式.分享给大家供大家参考,具体如下: 默认情况下,控制器的输出全部采用return的方式,无需进行任何的手动输出,系统会自动完成渲染内容的输出. 在控制器里渲染模板 namespace app\index\controller; use think\view; class Index{ public function index(){ $view = new view(); return $view->fetch('index'); } } 直

浅析Prototype的模板类 Template

用过Prototype的人都知道,里面有个类叫做Template,用法示例如下: 复制代码 代码如下: var str = '#{what} may have gone, but there is a time of #{how}'; var object = { what : 'Swallows', how : 'return' } var template_1 = new Template(str); var result = template_1.evaluate(object); con

Sublime Text新建.vue模板并高亮(图文教程)

本文介绍了 Sublime Text新建.vue模板并高亮(图文教程),分享给大家,也给自己留个笔记. 准备工作 下载安装新建文件模板插件 SublimeTmpl 下载安装vue语法高亮插件 Vue Syntax Highlight Sublime Text安装插件的方法有两种: 1.使用Sublime Text自带的安装库 Package Control 去安装 点击菜单栏的 Preferences -> Package Control 或使用快捷键 CTRL+SHIFT+P 打开终端窗口,输

laytpl 精致巧妙的JavaScript模板引擎

laytpl是一款颠覆性的JavaScript模板引擎,它用巧妙的实现方式,将自身的体积变得小巧玲珑,不仅性能接近极致,并且还具备传统前端引擎的几乎所有功能.所有的变身魔法都由不到1KB的代码创造,这仿佛是一场革命,又或者不是,但毋庸置疑的是,laytpl的确在用最轻量的方式呈现给世人.如果你从未接触这方面的应用,没关系,下面的讲述将会让你迫不及待地选择laytpl,从此更好地把握页面的数据渲染,走上人生巅峰! laytpl优势 •性能卓绝,执行速度比号称性能王的artTemplate.doT还

AngularJS入门教程之静态模板详解

为了说明angularJS如何增强了标准HTML,我们先将创建一个静态HTML页面模板,然后把这个静态HTML页面模板转换成能动态显示的AngularJS模板. 在本步骤中,我们往HTML页面中添加两个手机的基本信息,用以下命令将工作目录重置到步骤1. git checkout -f step-1 请编辑app/index.html文件,将下面的代码添加到index.html文件中,然后运行该应用查看效果. app/index.html <ul> <li> <span>

详解在 Angular 项目中添加 clean-blog 模板

在 Angular 项目中添加 clean-blog 模板 clean-blog 博客模板下载 clean-blog 或者在下面链接下载 startbootstrap-clean-blog-4-dev.zip 解压并拷贝 解压下载的文件,将所有文件拷贝到 assets/clean-blog 目录下 拷贝代码 将 clean-blog 的 index.html 内容拷贝到 app.component.html <!--The whole content below can be removed w