《C++新经典对象模型》之第7章模板实例化语义学-CSDN博客

本文链接：https://blog.csdn.net/oqqyx1234567/article/details/128911171

本文详细探讨了C++中的模板实例化，包括函数模板、类模板实例化分析，以及虚函数、静态成员、友元和不能被继承的类的使用。还介绍了如何在多个源文件中管理类模板和避免重复实例化问题。

摘要由CSDN通过智能技术生成

《C++新经典对象模型》之第7章模板实例化语义学

7.1 模板及其实例化详细分析

7.1.1 函数模板

template <class T>
T funcadd(const T &a, const T &b)
{
	T addhe = a + b;
	return addhe;
}

cout<<funcadd(12, 14)<<endl;
//dumpbin
//nm

编译器编译时根据funcadd的调用来确定函数模板中T的类型。
int funcadd(int const &, int const &);

7.1.2 类模板的实例化分析

template <class T>
struct ATPL
{
	T m_i, m_j;
	ATPL(T tmpi = 0, T tmpj = 0) 
		: m_i(tmpi), m_j(tmpj) {}
};

类模板中的枚举类型

template <class T>
struct ATPL
{
	enum ECURRSTATUS
	{
		E_CS_Busy,
		E_CS_Free,
	};
	T m_i, m_j;
	ATPL(T tmpi = 0, T tmpj = 0) 
		: m_i(tmpi), m_j(tmpj) {}
};

		ATPL<int>::ECURRSTATUS myenum = ATPL<int>::E_CS_Busy;
		ATPL<int>::ECURRSTATUS myenum2 = ATPL<int>::E_CS_Free;
		ATPL<double>::ECURRSTATUS myenum3 = ATPL<double>::E_CS_Free;

类模板中的静态成员变量

template <class T>
struct ATPL
{
	T m_i, m_j;
	ATPL(T tmpi = 0, T tmpj = 0) 
		: m_i(tmpi), m_j(tmpj) {}
		
	static int m_sti;
	static T m_sti2;
};

template <class T>
int ATPL<T>::m_sti = 10;
template <class T>
T ATPL<T>::m_sti2 = 10;//必须要和10兼容的类型

		ATPL<int>::m_sti = 18;
		cout << ATPL<int>::m_sti << endl;
		ATPL<float>::m_sti = 21;
		cout << ATPL<float>::m_sti << endl;
		
		//ATPL<string>::m_sti2;//error
		ATPL<int>::m_sti2 = 132;
		cout << ATPL<int>::m_sti2 << endl;
		ATPL<float>::m_sti2 = 1050.5;
		cout << ATPL<float>::m_sti2 << endl;

类模板的实例化

template <class T>
struct ATPL
{
	T m_i, m_j;
	ATPL(T tmpi = 0, T tmpj = 0) 
		: m_i(tmpi), m_j(tmpj) {}
};

	ATPL<int> *pobj = nullptr;//未实例化类
	
	const ATPL<int> &yobj = 0; // 因为构造函数允许缺省参数，这里有隐式类型转换
	//等价于
	//ATPL<int> tmpobj(0);
	//const ATPL<int> &yobj = tmpobj;

成员函数的实例化

template <class T>
struct ATPL
{
	T m_i, m_j;
	ATPL(T tmpi = 0, T tmpj = 0) 
		: m_i(tmpi), m_j(tmpj) {}
		
	void func1() const { cout << "ATPL::func1()" << endl; }
	void func2() const { cout << "ATPL::func2()" << endl; }
};

	const ATPL<int> &yobj = 0;
	yobj.func1();//成员函数调用时，才会实例化出成员函数

7.1.3 多个源文件中使用类模板

mytemplate.h

#pragma once
#include <iostream>
using namespace std;

template <class T>
T funadd(const T &a, const T &b)
{
	T addhe = a + b;
	return addhe;
}

template <class T>
struct ATPL
{
	enum ECURRSTATUS
	{
		E_CS_Busy,
		E_CS_Free,
	};

	T m_i, m_j;
	ATPL(T tmpi = 0, T tmpj = 0) 
		: m_i(tmpi), m_j(tmpj) {}

	static int m_sti;
	static T m_sti2;

	void func1() const { cout << "ATPL::func1()" << endl; }
	void func2() const { cout << "ATPL::func2()" << endl; }
};

template <class T>
int ATPL<T>::m_sti = 10;

template <class T>
T ATPL<T>::m_sti2 = 10;

MyProject.cpp

#include "mytemplate.h"

void myfunc()
{
	ATPL<int> myobj;//即使没调用myfunc()函数，也会实例化ATPL<int>类
	myobj.m_sti2 = 18;
	cout << myobj.m_sti2 << endl;
}

myfunc.cpp

#include "mytemplate.h"

int ftest()
{
	ATPL<int> myobj;//即使没调用myfunc()函数，也会实例化ATPL<int>类
	myobj.m_sti2 = 21;
	cout << myobj.m_sti2 << endl;
	return 15;
}

编译时可能多个.obj文件产生了多个相同的ATPL类，但链接时只保留一个ATPL类实体，其余忽略掉。

虚函数的实例化

template <class T>
struct ATPL
{
	enum ECURRSTATUS
	{
		E_CS_Busy,
		E_CS_Free,
	};

	T m_i, m_j;
	ATPL(T tmpi = 0, T tmpj = 0) 
		: m_i(tmpi), m_j(tmpj) {}

	static int m_sti;
	static T m_sti2;

	void func1() const { cout << "ATPL::func1()" << endl; }
	void func2() const { cout << "ATPL::func2()" << endl; }
	
	virtual void virfunc1() { cout << "ATPL::virfunc1()" << endl; }
	virtual void virfunc2() { cout << "ATPL::virfunc2()" << endl; }
};

template <class T>
int ATPL<T>::m_sti = 10;

template <class T>
T ATPL<T>::m_sti2 = 10;

类模板存在虚函数时，会实例化所以虚函数，即使未调用。
虚函数，产生虚函数表，虚函数表需要放置各个虚函数的地址，所以实例化出所以虚函数。

显示实例化

//.cpp文件中
template class ATPL<double>;

类模板的显示实例化，所有内容（类、成员函数、虚函数、静态成员变量等）都实例化出来，无论是否调用。

//.cpp文件中
template void ATPL<double>::func2() const;

实例化单独的成员函数，类并未实例化。

07.01.cpp

#include <cstdio>
#include <iostream>
using namespace std;

template <class T>
T funadd(const T &a, const T &b)
{
	T addhe = a + b;
	return addhe;
}

template <class T>
struct ATPL
{
	enum ECURRSTATUS
	{
		E_CS_Busy,
		E_CS_Free,
	};

	T m_i, m_j;
	ATPL(T tmpi = 0, T tmpj = 0) : m_i(tmpi), m_j(tmpj) {}

	static int m_sti;
	static T m_sti2;

	void func1() const { cout << "ATPL::func1()" << endl; }
	void func2() const { cout << "ATPL::func2()" << endl; }

	virtual void virfunc1() { cout << "ATPL::virfunc1()" << endl; }
	virtual void virfunc2() { cout << "ATPL::virfunc2()" << endl; }
};

template <class T>
int ATPL<T>::m_sti = 10;

template <class T>
T ATPL<T>::m_sti2 = 10;

void myfunc()
{
	ATPL<int> myobj;
	myobj.m_sti2 = 18;
	cout << myobj.m_sti2 << endl;
}

int main()
{
	cout << funadd(12, 14) << endl;

	{
		ATPL<int>::ECURRSTATUS myenum = ATPL<int>::E_CS_Busy;
		ATPL<int>::ECURRSTATUS myenum2 = ATPL<int>::E_CS_Free;
		ATPL<double>::ECURRSTATUS myenum3 = ATPL<double>::E_CS_Free;
	}

	{
		ATPL<int>::m_sti = 18;
		cout << ATPL<int>::m_sti << endl;

		ATPL<float>::m_sti = 21;
		cout << ATPL<float>::m_sti << endl;

		ATPL<int>::m_sti2 = 132;
		cout << ATPL<int>::m_sti2 << endl;

		ATPL<float>::m_sti2 = 1050.5;
		cout << ATPL<float>::m_sti2 << endl;
	}

	ATPL<int> *pobj = nullptr;

	{
		const ATPL<int> &yobj = 0; // 因为构造函数允许缺省参数，这里有隐式类型转换
		yobj.func1();
	}

	cout << sizeof(ATPL<int>) << endl;

	cout << "Over!\n";
	return 0;
}

7.2 炫技写法

7.2.1 不能被继承的类

使用final关键字
友元函数+虚继承（友元破坏封装，虚继承消耗大）


class A
{
private:
	A() {}
	friend class B; // B可以调用A的私有构造函数
};
class B : virtual public A // 虚继承A
{
public:
	int m_b;
};
// 虚基类A的构造函数由孙子类C调用
// 但虚基类A的构造函数私有，只有友元类B能调用，孙子类C无法调用
// 无法创建C类，即B类无法被继承
class C : public B
{
public:
	int m_c;
};

	{
		B myobjb;
		myobjb.m_b = 15;

		// C myobjc;
		// myobjc.m_c = 20;
	}

7.2.2 类外调用私有虚成员函数

class A2
{
private:
	virtual void virfunc()
	{
		myfunc();
	}
	void myfunc()
	{
		cout << "A::myfunc()" << endl;
	}
};

	{
		A2 aobj;
		(reinterpret_cast<void (*)()>(**(long ***)(&aobj)))();
		//通过虚函数表指针调用虚函数
		//long*** pvptr = (long ***)&aobj;
		//long** vptr = *pvptr;
		//typedef void(*Func)();
		//Func f = (Func)*vptr;
		//f();
	}

07.02.cpp

#include <iostream>
using namespace std;

class A
{
private:
	A() {}
	friend class B; // B可以调用A的私有构造函数
};
class B : virtual public A // 虚继承A
{
public:
	int m_b;
};
// 虚基类A的构造函数由孙子类C调用
// 但虚基类A的构造函数私有，只有友元类B能调用，孙子类C无法调用
// 无法创建C类，即B类无法被继承
class C : public B
{
public:
	int m_c;
};

class A2
{
private:
	virtual void virfunc()
	{
		myfunc();
	}
	void myfunc()
	{
		cout << "A::myfunc()" << endl;
	}
};

int main()
{

	{
		B myobjb;
		myobjb.m_b = 15;

		// C myobjc;
		// myobjc.m_c = 20;
	}

	{
		A2 aobj;
		(reinterpret_cast<void (*)()>(**(long ***)(&aobj)))();
		// 通过虚函数表指针调用虚函数
		// long*** pvptr = (long ***)&aobj;
		// long** vptr = *pvptr;
		// typedef void(*Func)();
		// Func f = (Func)*vptr;
		// f();
	}

	cout << "Over!\n";
	return 0;
}