操作符重载and模板(泛化, 全特化, 偏特化)

已于 2022-08-27 23:17:05 修改
阅读量126 收藏
点赞数
文章标签： c++
于 2022-08-27 23:01:05 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/link_null/article/details/126563801
版权

模板

Header(头文件)中的防卫式声明、布局

// complex.h

// guard 防卫式声明
#ifndef __COMPLEX__
#define __COMPLEX__

// 0、forward declarations (前置声明)
#include <cmath>

class ostream;
class complex;

complex&
    __doapl (complex* ths, const complex& r);

// 1、class declarations (类-声明)
class complex
{
    ...
};

// 2、class definition (类-定义)
complex::function ...

#endif

// complex-test.cpp

#include <iostream>
#incldue "complex.h" // *****HERE*****
using namespace std;

int main() {
    ...
}

class - 声明

class complex // class head
{ // class body
public:
    complex (double r = 0, double i = 0) 
        : re (r), im (i) 
    {  }
    // 有些函数在此直接定义，另一些在body之外定义
    complex& operator += (const complex&) ;
    double real () const { return re; }
    double imag () const { return im; }
private:
    double re, im;

    friend complex& __doapl (complex*, const complex&);

};

// .cpp
{
    complex c1(2,1);
    complex c2;
}

类模板

template<typename T>
class complex // class head
{ // class body
public:
    complex (T r = 0, Ti = 0) 
        : re (r), im (i) 
    {  }
    // 有些函数在此直接定义，另一些在body之外定义
    complex& operator += (const complex&) ;
    T real () const { return re; }
    T imag () const { return im; }
private:
    T re, im;

    friend complex& __doapl (complex*, const complex&);

};

// .cpp
{
    complex<double> c1(2.5,1.5);
    complex<int> c2(2,6);
}

函数模板

stone r1(2, 3), r2(3, 3), r3;
r3 = min(r1, r2);

template <class T>
inline
const T& min(const T& a, const T& b)
{
	return b < a ? b : a;
}

class stone
{
public:
	stone(int w, int h, int we)
	  : _w(w), _h(h), _weight(we)
	    {	}
	bool operator<const stone& rhs) const
		{return _weight < rhs. _weight;}
private:
	int _w, _h, _weight;
}

操作符重载

头文件

#ifndef __COMPLEX__ // 1.防卫式声明
#define __COMPLEX__	

#include <iostream>
using std::ostream;

// 2.class head
class complex 
{ // class body
public:
	// 3.构造函数 inline
	complex (double r = 0, double i = 0) // pass by 什么都可以，因为double是4个字节
		: re(r), im(i) // 设初值
	{  }
	// 有些函数在此直接定义，另一些在body之外定义
	complex& operator += (const complex&); // 5.重载+=，设计为成员函数
	// 4.取得实部和虚部，不会改data，所以函数是const；inline
	double real() const { return re; } 
	double imag() const { return im; }
private:
	double re, im;
	// 6.do assignment-plus 函数中想直接取得re和im，所以声明成友元函数
	friend complex& __doapl(complex*, const complex&);
};

#endif // __COMPLEX__

cpp文件

#include "complex.h"


// 重载+=
// 想法类似下面
inline complex&
__doapl(complex* ths, const complex& r) {
	ths->re += r.re;
	ths->im += r.im;
	return *ths;
}

// +=左边是默认的this指针；
// 右边最好引用&，不改变右边，所以const；
// 返回值不是局部变量，可以传引用&；
// 希望成为inline函数
inline complex&
complex::operator += (const complex& r) {
	return __doapl(this, r);
}

// 重载 +，非成员函数：因为不一定就是复数加复数，可以实数加复数
// 因为不能加到x和y上，所以会加到一个新的局部变量上，所以return by value
inline complex
operator + (const complex& x, const complex& y) {
	return complex(x.real() + y.real(), x.imag() + y.imag());
}

inline complex
operator + (double x, const complex& y) {
	return complex(x + y.real(), y.imag());
}

inline complex
operator + (const complex& x, double y) {
	return complex(x.real() + y, x.imag());
}

// 重载 <<
// 因为不可以写成 c1 << cout，所以要写成非成员函数
// os传进来以后，每次输出一点东西，就会改变，所以是&
// 返回ostream 是为了可以连续输出;ostream 不是局部变量，可以返回引用
// 为了使用ostream，要 #include <iostream>
inline ostream& 
operator << (ostream& os, const complex& x) {
	return os << "(" << x.real() << "," << x.imag() << ")";
}

模板特化

概述

模板特化（template specialization）不同于模板的实例化，模板参数在某种特定类型下的具体实现称为模板特化。模板特化有时也称之为模板的具体化，分别有函数模板特化和类模板特化。

函数模板特化

函数模板特化指函数模板在模板参数为特定类型下的特定实现。查看以下示例：

#include <iostream>
using namespace std;

template<typename T> T Max(T t1,T t2) {
	return (t1>t2)?t1:t2;
}

typedef const char* CCP;
template<> CCP Max<CCP>(CCP s1,CCP s2) {
	return (strcmp(s1,s2)>0)?s1:s2;
}

int main() {
	// 隐式调用实例：int Max<int>(int,int)
	int i=Max(10,5);
	

	// 显式调用特化版本：const char* Max<const char*>(const char*,const char*)
	const char* p=Max<const char*>("very","good");
	cout<<"i:"<<i<<endl;
	cout<<"p:"<<p<<endl;

}

程序正常编译运行结果：

i:10
p:very

在函数模板显示特化定义（Explicit Specialization Definition）中，显示关键字 template 和一对尖括号 <>，然后是函数模板特化的定义。该定义指出了模板名、被用来特化模板的模板实参，以及函数参数表和函数体。在上面的程序中，如果不给出函数模板Max< T>在T为const char*时的特化版本，那么在比较两个字符串的大小时，比较的是字符串的起始地址的大小，而不是字符串的内容在字典序中的先后次序。

除了定义函数模板特化版本外，还可以直接给出模板函数在特定类型下的重载形式（普通函数）。使用函数重载可以实现函数模板特化的功能，也可以避免函数模板的特定实例的失效。例如，把上面的模板特化可以改成如下重载函数。

typedef const char* CCP;
CCP Max(CCP s1,CCP s2) {
	return (strcmp(s1,s2)>0)?s1:s2;
}

程序运行结果和使用函数模板特化相同。但是，使用普通函数重载和使用模板特化还是有不同之处，主要表现在如下两个方面：

（1）如果使用普通重载函数，那么不管是否发生实际的函数调用，都会在目标文件中生成该函数的二进制代码。而如果使用模板的特化版本，除非发生函数调用，否则不会在目标文件中包含特化模板函数的二进制代码。这符合函数模板的“惰性实例化”准则。

（2）如果使用普通重载函数，那么在分离编译模式下，需要在各个源文件中包含重载函数的申明，否则在某些源文件中就会使用模板函数，而不是重载函数。

类模板特化

类模板特化类似于函数模板的特化，即类模板参数在某种特定类型下的具体实现。考察如下代码：

#include <iostream>
using namespace std;

template<typename T>class A {
	T num;
public:
	A(){
		num=T(6.6);
	}
	void print(){
		cout<<"A'num:"<<num<<endl;
	}
};

template<> class A<char*> {
	char* str;
public:
	A() {
		str="A' special definition ";
	}
	void print() {
		cout<<str<<endl;
	}
};

int main() {
	A<int> a1;      //显示模板实参的隐式实例化
	a1.print();
	A<char*> a2;    //使用特化的类模板
	A2.print();
}

程序输出结果如下：

A'num:6
A' special definition

模板偏特化

概述

模板偏特化（Template Partitial Specialization）是模板特化的一种特殊情况，指显示指定部分模板参数而非全部模板参数，或者指定模板参数的部分特性分而非全部特性，也称为模板部分特化。与模板偏特化相对的是模板全特化，指对所有模板参数进行特化。模板全特化与模板偏特化共同组成模板特化。

模板偏特化主要分为两种，一种是指对部分模板参数进行全特化，另一种是对模板参数特性进行特化，包括将模板参数特化为指针、引用或是另外一个模板类。

函数模板偏特化

假如我们有一个 compare 函数模板，在比较数值大小时没有问题，如果传入的是数值的地址，我们需要比较两个数值的大小，而非比较传入的地址大小。此时我们需要对 compare 函数模板进行偏特化。考察如下代码：

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

// 函数模板
template<typename T, class N> void compare(T num1, N num2) {
	cout << "standard function template" << endl;
	if(num1>num2) {
		cout << "num1:" << num1 << " > num2:" << num2 <<endl;
	} else {
		cout << "num1:" << num1 << " <= num2:" << num2 << endl;
	}
}

// 对部分模板参数进行特化
template<class N> void compare(int num1, N num2) {
	cout<< "partitial specialization" <<endl;
	if (num1>num2)
		cout << "num1:" << num1 << " > num2:" << num2 << endl;
	else
		cout << "num1:" << num1 << " <= num2:" << num2 << endl;
}

// 将模板参数特化为指针(模板参数的部分特性)
template<typename T, class N> void compare(T* num1, N* num2) {
	cout << "new partitial specialization" << endl;
	if (*num1>*num2)
		cout << "num1:" << *num1 << " > num2:" << *num2 << endl;
	else
		cout << "num1:" << *num1 << " <= num2:" << *num2 << endl;
}

// 将模板参数特化为另一个模板类
template<typename T, class N> void compare(std::vector<T>& vecLeft, std::vector<T>& vecRight) {
	cout << "to vector partitial specialization" << endl;
	if (vecLeft.size()>vecRight.size())
		cout << "vecLeft.size()" << vecLeft.size() << " > vecRight.size():" << vecRight.size() << endl;
	else
		cout << "vecLeft.size()" << vecLeft.size() << " <= vecRight.size():" << vecRight.size() << endl;
}

int main() {
	// 调用非特化版本 compare<int,int>(int num1, int num2)
	compare<int,int>(30,31);

	// 调用偏特化版本 compare<char>(int num1, char num2)
	compare(30,'1');
	
	int a = 30;
	char c = '1';
	// 调用偏特化版本 compare<int,char>(int* num1, char* num2)
	compare(&a, &c);
	
	vector<int> vecLeft{0};
	vector<int> vecRight{1,2,3};
	// 调用偏特化版本 compare<int,char>(int* num1, char* num2)
	compare<int,int>(vecLeft,vecRight);

}

程序输出结果如下：

standard function template
num1:30 <= num2:31
partitial specialization
num1:30 <= num2:1
new partitial specialization
num1:30 <= num2:1
to vector partitial specialization
vecLeft.size()1 <= vecRight.size():3

类模板偏特化

类模板的偏特化与函数模板的偏特化类似。考察如下代码：

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

// 类模板
template<typename T, class N> class TestClass {
public:
	static bool comp(T num1, N num2) {
		cout <<"standard class template"<< endl;
		return (num1<num2) ? true : false;
	}
};

// 对部分模板参数进行特化
template<class N> class TestClass<int, N> {
public:
	static bool comp(int num1, N num2) {
		cout << "partitial specialization" << endl;
		return (num1<num2) ? true : false;
	}
};

// 将模板参数特化为指针
template<typename T, class N> class TestClass<T*, N*> {
public:
	static bool comp(T* num1, N* num2) {
		cout << "new partitial specialization" << endl;
		return (*num1<*num2) ? true : false;
	}
};

// 将模板参数特化为另一个模板类
template<typename T, class N> class TestClass<vector<T>,vector<N>> {
public:
	static bool comp(const vector<T>& vecLeft, const vector<N>& vecRight) {
		cout << "to vector partitial specialization" << endl;
		return (vecLeft.size()<vecRight.size()) ? true : false;
	}
};

int main() {
	// 调用非特化版本
	cout << TestClass<char, char>::comp('0', '1') << endl;	
	

	// 调用部分模板参数特化版本
	cout << TestClass<int,char>::comp(30, '1') << endl;		
	
	// 调用模板参数特化为指针版本
	int a = 30;
	char c = '1';
	cout << TestClass<int*, char*>::comp(&a, &c) << endl;		
	
	// 调用模板参数特化为另一个模板类版本
	vector<int> vecLeft{0};
	vector<int> vecRight{1,2,3};
	cout << TestClass<vector<int>, vector<int>>::comp(vecLeft,vecRight) << endl;	

}

程序输出结果：

standard class template
1
partitial specialization
1
new partitial specialization
1
to vector partitial specialization
1

参考
[1]侯捷c++
[2]C++ 模板特化与偏特化

Chic???
关注
[C++ Template]深入模板--特化与重载
u012481976的博客
11-26 3550
目录 第12章 特化与重载 12.2 重载函数模板 12.2.1 签名 12.2.2 重载的函数模板的局部排序 12.2.3 正式的排序原则 12.2.4 模板和非模板 12.3 显式特化 12.3.1 全局的类模板特化 12.3.2 全局的函数模板特化 12.3.3 全局成员特化 12.4 局部的类模板特化 第12章 特化与重载 目前为止，我们已经知道了：C++模板如何...
5.C++ STL之操作符重载、泛化
CarmenIsOK的博客
04-02 289
操作符重载 reference operator*(){} pointer opeator->(){} self& operator++() self operator++(int) 类模板 template\<typename\ T> class complex { ...... } complex<double> c1(2.5,1.5); 函数模板 ...
C++primer 学习笔记 -第16章 模板与泛型编程(模板的偏特化与全特化)
weixin_43471255的博客
03-20 872
1. 特化的概念 模板特化（template specialization）不同于模板的实例化，模板参数在某种特定类型下的具体实现称为模板特化。模板特化有时也称之为模板的具体化，分别有函数模板特化和类模板特化。 1.1 模板偏特化 模板偏特化（Template Partitial Specialization）是模板特化的一种特殊情况，指显示指定部分模板参数而非全部模板参数，或者指定模板参数的部分特性分而非全部特性，也称为模板部分特化。与模板偏特化相对的是模板全特化，指对所有模板参数进行特化。模板全特化
C++ Template 特化与重载
weixin_30596735的博客
11-24 156
特化与重载:1.重载函数模板: 与普通函数一样,函数模板也可以重载.在重载函数模板的时候,应该把改变限制在一下两种情况:改变参数的数目或者显示地指定模板参数.除此之外,函数的所有重载版本的声明都应该位于该函数被调用的位置之前.P.S: 类模板是不能被重载的.2.特化: 1`全局类模板的的特化: 如果要特化一个类模板,就要特化该类模板的所有成员函数.引入全局特化需要用到3个标记序列:temp...
操作符重载 与 模板（泛化，全特化，偏特化）
weixin_40137369的博客
08-14 401
操作符重载 与 模板操作符重载模板 操作符重载 参考链接：https://zh.cppreference.com/w/cpp/language/operators 在 C++ STL 中，广泛使用了操作符重载和模板。实际上 C++ 使用者在使用容器时，对不同容器的迭代器使用的操作符（*, ->, ++， --）都可能是不同的实现逻辑。操作符重载使得使用者不需要知道底层具体的代码实现过程，降低编程的复杂度。 限制 （1）不能重载运算符 ::（作用域解析）、.（成员访问）、.*（通过成员指针的成员
《C++ Primer》学习笔记（第十六章）——模板和泛型编程
weixin_42702722的博客
08-06 368
模板和泛型编程 泛型编程的基础就是模板，一个模板就是创建类或函数的公式或者框架。 一、函数模板 当我们定义一个函数，希望该函数可以对不同类型的实参进行相同的操作。一种方法就是函数重载，为每一种类型定义该类型的函数，但是这种方法比较麻烦，而且扩展性低。另外一种方法就是定义一个通用的函数模板，当我们使用不同的实参时，编译器就会根据实参类型实例化一个函数模板，如： template<typenam...
C++模板编程灵活应用：特化与偏特化的5大技巧
!...# 1. C++模板编程基础 ...在C++编程中，模板是一种强大的特性，它允许开发者编写可重用的代码，无需为不同数据类型或类提供多个函数和类的重载版本。模板分为函数模板和类模板，它们通过参数化类型
C++函数模板
T1mzhou的博客
09-12 397
C++函数模板 第一节-函数模板 模板的定义是以template关键字开头; 类型模板参数T前面用typename来修饰，所以，遇到typename就该知道其后面跟的是一个类型。typename可以被class取代，但此处的class并没有“类”； 类型模板参数T（代表是一个类型）以前前面的修饰符typename/class都用<>括起来 T这个名字可以换成任意其他标识符，对程序没有影响。用T只是一种编程习惯。 例子： namespace _nmsp1 { int Sub(int tv1,
C++命名空间与模板编程：模板特化与命名空间的关联
类模板定义了一类对象的蓝图，而函数模板则可以为一组功能相似但操作的数据类型不同的函数提供统一的接口。 ```cpp // 函数模板示例 template T max(T a, T b) { return (a > b) ? a : b; } // 类模板示例 ...
C++之模板＜template＞
热门推荐
gangaue的博客
05-28 1万+
目录🌈前言🌸 模板🌷1、泛型编程🌺2、函数模板🍀2.1、函数模板的概念🍁2.2、函数模板的格式🍂 2.3、函数模板的原理🍌2.4、函数模板的实例化🍃 2.5、模板参数的匹配原则🍒 3、类模板🍕 3.1、类模板的概念🍔 3.2、类模板的格式🍒3.3、类模板的实例化🍖 4、非类型模板参数🍗 5、模板的特化🍙5.1、特化的概念🍛5.2、函数模板的特化🍜5.3、类模板特化🍝 5.3.1、类模板全特化🍞 5.3.2、类模板的偏特化🍟6、模板的分离编译🎆6.1、 什么是分离编译🎆6. 2、解决方法🎇7、模板总结 🌈前
C++ Primer —— 第十六章 模板与泛型编程笔记
weixin_46698891的博客
07-12 460
文章目录第16章 模板与泛型编程定义模板函数模板类模板模板参数成员模板控制实例化效率与灵活性模板实参推断类型转换与模板类型参数函数模板显式实参尾置返回类型与类型转换函数指针和实参推断模板实参推断和引用理解std::move转发重载与模板可变参数模板编写可变参数函数模板包扩展转发参数包模板特例化术语表 第16章 模板与泛型编程 定义模板 函数模板 template<typename T> int compare(const T &v1, const T &v2) { if(
模板特化、重载
友善啊，朋友的博客
09-12 212
模板特化 将模板中的参数指定为特定的类型，模板特化之后可以针对特效类型实现特定的功能。 模板全特化 所有参数都特化为确定的类型。 模板类和模板函数都可以全特化。 全特化的模板参数列表是空的。 示例1，函数全特化： template<typename T> T add(T t1,T t2) { return t1 + t2; } 这个模板函数int类型可以正常使用，但char不行，这时候可以特化一个char类型的： template<typename T>
模板函数的特化与重载
asahi_331的博客
01-05 518
#include <iostream> #include <vector> #include <string> using namespace std; template <typename T> void compare(T a, T b) { cout << "泛化" << endl; } // 模板函数的偏特化。因为函数重载功能就可以实现，所以模板函数的偏特化是被禁止的 template <typename .
《C++程序设计原理与实践》笔记 第16章 图形用户界面
最新发布
zzy979481894的博客
04-09 3754
图形用户界面(graphical user interface, GUI)允许用户通过点击按钮、选择菜单、以不同的方式输入数据以及在屏幕上显示文本和图形等方式与程序进行交互。在本章中，我们将介绍编写代码来定义和控制GUI应用的基本方法。
模板函数的全特化与重载
airekans的专栏
10-31 632
References: http://www.gotw.ca/publications/mill17.htm
C++Primer Plus笔记——第十六章 string类和标准模板库总结及程序清单
YukinoAI的博客
10-03 803
目录 本章小结 程序清单 string类 16.1 str1.cpp                16.2 strfile.cpp            16.3 hangman.cpp          16.4 str2.cpp 智能指针模板类 16.5 smrtptrs.cpp         16.6 fowl.cpp 标准模板库 16.7 vect1.cpp      ...
泛化，特化，偏特化,traits
darmao的博客
05-15 978
template&lt;typename T&gt; struct _type_traits { //泛化 T t; }; template&lt;&gt; struct _type_traits&lt;int&gt; { //特化 int i; }; _type_traits&lt;Foo&gt;::t;//使用泛化版本 _type_traits&lt;int&g...
泛化基础-模板的偏特化
davidsu33的专栏
03-31 1617
C++泛化编程技术之模板的偏特化
第十天2017/04/21（2、泛型编程：模板 / 全特化、偏特化）
GoJawee的博客
04-21 534
1、什么是模板？ template<class T1,class T2,.....> 类属————类型参数化，又称参数模板 使得程序可以从逻辑功能上抽象，把被处理的对象（数据）的类型作为参数传递。【1】函数模板 #include <iostream> using namespace std; //函数模板 template <class T1,class T2> void show(T1
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值