• 作者: 雪山肥鱼
• 时间：20220207 19:47
• 目的: 模板代码的组织结构

# 模板代码的组织结构
# 模板的显式实例化、模板声明、代码组织结构

模板代码的组织结构

1. 在.h 文件中，实现类内成员函数

#ifndef __TEMP__
#define __TEMP__

template<typename T>
class Myclass {
public:
    void func();
};

template<typename T>
void Myclass<T>::func() {
    std::cout << "in Myclass<T>::func" << std::endl;
}

//特化位置
template<>
class Myclass<int> {
public:
    void func();
};

//template<> 不要
void Myclass<int>:: func() {
    std::cout << "in Myclass<int>::func tehua" << std::endl;
}


#endif

• 普通类:
  类定义和类实现要分别在.h头文件和.cpp源文件中。

• 类模板
  定义和实现

编译项目时编译器会对每个.cpp源文件作为一个编译单元编译
如果多个.cpp源文件都实例化出来Myclass<int> 类，那么链接时编译器会选择其中一个 Myclass<int>， 其他的丢其掉，即 贪婪实例化。

同理 函数 模板

模板的显式实例化，模板声明，代码组织结构

模板实例化声明

ca.h

#ifndef __CA_H__
#define __CA_H__


template <typename T>
void myfunc(T v1, T v2) {
    std::cout << v1 + v2 << endl;
}

//类模板A 的声明
template<typename C>
class A {
public:
    template<typename T2>
    A(T2 v1, T2 v2);//构造函数模板

    template<typename T>
    void myft(T tmpt) {
        std::cout << tmpt << std:endl;
    }
    C m_ic;
};

template<typename C>
template<typename T2>
A<C>::A(T2 v1, T2 v2) {
    std::cout << v1 << v2 << std::endl;
}
#endif

test.cpp

#include <iostream>
#include "ca.h"

using namespace std;

//显式实例化 - 只在一个cpp 文件中 这样写，编译器会为其生成实例化代码，则其他cpp不需要实例化这个类了，
//只需要 extern 一下即可
template A<float>;
template void myfunc(int & v1, int & v2);

void myfunc() {
    A<float> a(1, 2);
    a.myft(3);//3
}

main.cpp
#include <iostream>
#include "ca.h"

using namespace std;

//每个.cpp文件独立编译，都会生成一个obj 都有一个 A<float> 类
//如果编译.cpp文件过多，会生成多个obj，多个 实例化的 A<float>类，则浪费时间。
//通过显式实例化避免此类开销
extern template A<float>;//实例化声明
extern template void myfunc(int & v1, int & v2);

int main(int argc, char ** argv) {

    A<float> a(1, 2);
    A<float> a2(1.1, 2.2);
    a.myft(3);//3
    return 0;
}

显式实例化的作用，大型项目中避免多次实例化类模板。在一个cpp中显式实例化后，其他cpp只要显式声明即可。

**同理 函数 模板 **

• 引出的问题：
  显式实例化，不管类中的成员函数有没有用到，都会被实例化出来。除了，成员函数模板，因为其类型，仅仅提供一个 显式实例化，是不会被实例化的。

适用场景:
cpp 文件很多，且这个类模板中的成员函数比较少。