02~C++类模板

最新推荐文章于 2023-07-05 22:18:27 发布
最新推荐文章于 2023-07-05 22:18:27 发布
阅读量225 收藏
点赞数
分类专栏： C++ 模板基础
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/uncle103/article/details/88651199
版权

文章目录

一 类模板定义

常常把 类模板 同 函数模板 进行比较。函数模板侧重实现不同类型的通用算法。
类模板相比下，首先具有容器的属性，描述了内存的开销与布局特点。

1. 简答的Stack类

设想分别这样定义Item
typename unsigned char Item;
typename short int Item;
甚至
typename struct Element Item;
这种形式，类类型 Element将会作为类型Stack的基本单元

#include <iostream>
using namespace std;
typedef unsigned long Item;
//typename unsigned char Item;
//typename short int Item;
struct Stack {
public:
	
		
	Stack (void) {
		int cnt = 0;
		top = 0;
		for (;cnt < MAX; cnt++)  {
			items[cnt] = 0;
		}
	}
	bool isempty() const{
	}
	bool isfull () const {
	}
	bool push (Item const & item) {
	}
	bool pop (Item &item) {
	}
	
private:
   enum {MAX=10};
	int top;
	Item items[MAX];
};
int main (void) {
Stack st;
return 0;
}

2. 请对比上面示例代码

区别出在于抽象表示
不再使用typedef long Item 这种固定而难用的形式，而是使用抽象模板类型 template <>这种形式

其次在使用（调用）类模板时，需要显示指出容器单元的类型

#include <iostream>
using namespace std;
//不再使用typendef 的形式
template <typename Item>
struct Stack {
public:
	
		
	Stack (void) {
		int cnt = 0;
		top = 0;
		for (;cnt < MAX; cnt++)  {
			items[cnt] = 0;
		}
	}
	bool isempty() const{
	}
	bool isfull () const {
	}
	bool push (Item const & item) {
	}
	bool pop (Item &item) {
	}
	
private:
   enum {MAX=10};
	int top;
	Item items[MAX];
};
int main (void) {
Stack<long int> st; //指出容器单元
//Stack <char> st;
//Stack <long long> st;
return 0;
}

二 例举类模板特殊使用方式

1. 模板接收整型类型参数

模板编译时：定义Items个数为MAX

#include <iostream>
using namespace std;
template <typename Item, int MAX>
struct Stack {
public:
	Stack (void) {
		int cnt = 0;
		top = 0;
		for (;cnt < MAX; cnt++)  {
			items[cnt] = 0;
		}
	}
	bool isempty() const{
	}
	bool isfull () const {
	}
	bool push (Item const & item) {
	}
	bool pop (Item &item) {
	}
	
private:
	int top;
	Item items[MAX];
};
int main (void) {
Stack<long int,10> st; //指出容器单元 以及容器容量

return 0;
}

2. 动态分配内存

使用动态内存分配方法，修改Stack的设计结构

#include <iostream>
using namespace std;
template <typename Item>
struct Stack {
public:
	//改用动态内存分配
	Stack (int nums) : size(nums), item (NULL){
		item = new Item[nums];
	}
	bool isempty() const{
	}
	bool isfull () const {
	}
	bool push (Item const & item) {
	}
	bool pop (Item &item) {
	}
	~ Stack(void) {
		if(item)
		delete [] item;
	}
private:
	int top;
	int size;//records the max element nums
	Item* item; // holds the elements
};
int main (void) {
//通过构造函数提供需要的容器 容量
Stack<long int> st(10); //指出容器单元 以及容器容量
return 0;
}

3. 类模板的递归

递归调用通常是用来描述类似多维数组这样的结构

Stack<int, 10> st1，表示了一个一维的Stack结构（由10个int组成）
访问方法：一维数组成员访问形式如下:st1. items[0] , st1.items[1]

Stack< Stack<int,10>,20 > st2，表示由20个一维Stack 结构构成的二维结构，每一个一维结构由（10个int构成）
访问方法：
事实上，这种形式是由20个 单元类型为Stack<int, 10> 的模板类型
st2.items[0], st2.items[1], 表示的每一个Stack<int,10> 模板类
st2.items[0].items[0], st2.items[1].items[2]，表示内层数据中的int

#include <iostream>
using namespace std;
template <typename Item, int MAX>
struct Stack {
public:
	bool isempty() const{
	}
	bool isfull () const {
	}
	bool push (Item const & item) {
	}
	bool pop (Item &item) {
	}
public:
int top;
Item items[MAX];
};
int main (void) {
Stack<long int,10> st1; //指出容器单元 以及容器容量
Stack<Stack<int,10>,20> st2;

st1.items[0] = 100;
st2.items[0].items[9] = 200;
cout << "items one array " << st1.items[0] << endl;
cout <<"items double array " << st2.items[0].items[9] << endl;
return 0;
}

4. 使用多个类型参数

模板的一种使用技巧如下
template < typename type >
class classname {
…
}

猜测存在单一的类型形参不能满足设计需要的情况，因此诞生了多个类型参数的模板设计，形如
template < typename T1, typename T2>
class classname {
…
}
以下直接贴上C++ primer plus 一书提供的模板 Pair 实现

#include <iostream>
#include <string>

template <typename T1,  typename T2>
class Pair {
private:
T1 a;
T2 b;
public:
T1& first();
T2& second();
T1 first() const {return a;}
T2 sencond() const {return b;}
Pair(T1 const& aval, T2 const& bval) : a(aval), b(bval){}
Pair() {}
};

int main(void)
{
using namespace std;
Pair<string,int> Packages[4] {
	Pair<string, int>("The purple Duck", 5),
	Pair<string, int>("rabbits", 6),
	Pair<string, int>("rabbits", 7),
	Pair<string, int>("rabbits", 8),
};
int nums  = sizeof(Packages)/sizeof(Pair<string,int>);
cout << "nums  = " << nums << endl;
int cnt = 0;
for (;cnt < nums;cnt++) {
	cout << "cnt = " << cnt << " string = " << Packages[cnt].first() << endl;
}
return 0;
}
template <typename T1, typename T2>
T1& Pair<T1, T2>::first() {
	return a;
}
template <typename T1, typename T2>
T2& Pair<T1,T2>::second() {
	return b;
}

5. 类模板默认参数

#include <iostream>
using namespace std;
//默认单元类型为int ，默认个数为10
template <typename Item = int, int MAX = 10>
struct Stack {
public:
	Stack (void) {
		int cnt = 0;
		top = 0;
		for (;cnt < MAX; cnt++)  {
			items[cnt] = 0;
		}
	}
	bool isempty() const{
	}
	bool isfull () const {
	}
	bool push (Item const & item) {
	}
	bool pop (Item &item) {
	}
	
private:
	int top;
	Item items[MAX];
};
int main (void) {
Stack<> st; //不给入 类型参数，使用默认类型参数
cout << "size = " << sizeof(st)  << endl; //40 + 4

return 0;
}

6. 模板重载

模板的具体化就形式上来看 同函数模板没有什么区别。直接示例作为参考即可

#include <iostream>
using namespace std;
template <typename Item, int MAX>
struct Stack {
public:
	Stack(void) {
		cout <<"general version " <<endl;
	}
private:
	int top;
	Item items[MAX];
};

//具体的char 单元设计方法 
template <int MAX>
struct Stack<char,MAX> {
public:
	Stack(void) {
		cout <<"char version " << endl;
	}
private:
	int top;
	char items[MAX];
};

//具体的使用指针的 设计方法
template <typename T, int MAX>
struct Stack<T *, MAX> {
public:
	Stack(void) {
		cout <<"Ptr version " << endl;
	}
private:
	int top;
	T* items[MAX];
};

int main (void) {
//通用方法
Stack<int,100> st; //general
Stack<char, 100> st_char; //char
Stack<char *, 100> st_ptr; //ptr
return 0;
}

7. 成员模板

Item 作为成员模板存在的。 他用来进一步封装实用易于管理的类型

#include <iostream>
using namespace std;
template <typename element, int MAX>
struct Stack {
public:
	template <typename V> 
	struct Item {
	V member;
	int state;
	};
	
	Stack (void) {
	}
	bool isempty() const{
	}
	bool isfull () const {
	}
	bool push (Item<element> const & item) {
	}
	bool pop (Item <element> &item) {
	}
	
private:
	int top;
	Item<element> items[MAX];
};
int main (void) {
return 0;
}

8. 类模板作为参数

  • 示例1
#include <iostream>
using namespace std;

template <typename V> 
struct Item {
V member;
int state;
};
   
template <template <typename T> class Item , int MAX>
struct Stack {
public:

   Stack (void) {
   }
   bool isempty() const{
   }
   bool isfull () const {
   }
   bool push (Item<int> const & item) {
   }
   bool pop (Item <int> &item) {
   }
   
private:
   int top;
   Item<int> items[MAX];
};
int main (void) {
return 0;
}
  • 示例 2
#include <iostream>
using namespace std;

template <typename V> 
struct Item {
V member;
int state;
};
   
template <template <typename T> class Item , typename element, int MAX>
struct Stack {
public:

   Stack (void) {
   }
   bool isempty() const{
   }
   bool isfull () const {
   }
   bool push (Item<element> const & item) {
   }
   bool pop (Item <element> &item) {
   }
   
private:
   int top;
   Item<element> items[MAX];
};
int main (void) {
return 0;
}

三 类模板与友元函数

1. 非模板友元函数

友元表示为特定的函数声明（G++编译器对此种语法表示一些警告）

#include <iostream>
using namespace std;
template <typename T>
class Container{
public:
	Container(T const& a , T const& b):m_c1(a),m_c2(b) {}
	//非模板形式的友元函数声明
	friend void show_mem(Container const& that);
private:
T m_c1;
T m_c2;
};
void show_mem(Container<int> const& that) {
	cout << that.m_c1 << ' ' << that.m_c2 << endl;
}
int main() {
Container<int> c1(10,20);
show_mem(c1);
return 0;
}

2. 友元函数

#include <iostream>
using namespace std;

/*声明show_mem为函数模板*/
template <typename T>
void show_mem(T const& that);

template <typename T>
class Container{
public:
	Container(T const& a , T const& b):m_c1(a),m_c2(b) {}
	//友元函数形参为模板的一种特化,这里也是叫做约束模板的原因
	friend void show_mem<>(Container<T> const& that);
private:
T m_c1;
T m_c2;
};


//给出 友元函数模板定义
template <typename T>
void show_mem(T const& that) {
	cout << that.m_c1 << ' ' << that.m_c2 <<endl;
}

int main() {
Container<int> c1(10,20);
show_mem(c1); //show_mem< Container<int> >
Container<double> c2(1.1,1.2);
show_mem(c2);//show_mem< Container<double> >
return 0;
}

3. 友元函数模板

#include <iostream>
using namespace std;

template <typename T>
class Container{
public:
	Container(T const& a , T const& b):m_c1(a),m_c2(b) {}
	//友元函数为通用模板
	template <typename D> friend void show_mem(D & that);
private:
T m_c1;
T m_c2;
};


//给出 友元函数模板定义
template <typename T>
void show_mem(T & that) {
	cout << that.m_c1 << ' ' << that.m_c2 <<endl;
}

int main() {
Container<int> c1(10,20);
show_mem(c1); //show_mem< Container<int> >
Container<double> c2(1.1,1.2);
show_mem(c2);//show_mem< Container<double> >
return 0;
}
Johhny Rade
关注
专栏目录
C++基础知识整理
kiremi的博客
07-23 194
C++基础[持续更新]1.指针和引用的区别2.堆和栈的区别3.new和delete是如何实现的，new 与 malloc的异同处4.Struct和class的区别5.define 和const的区别（编译阶段、安全性、内存占用等）6.在C++中const和static的用法（定义，用途）7.const和static在类中使用的注意事项（定义、初始化和使用）8.C++中的const类成员函数（用法和...
C++类模板与模板类深入详解
09-04
C++类模板与模板类是C++编程中重要的特性，它们提供了泛型编程的能力，允许程序员编写出能够处理多种数据类型的一般性代码。本文将深入探讨这两个概念及其相关知识点。 1. 关键字`typename`与`class`： 在C++的模板...
C++—函数、对象复用、零拷贝、标准库
最新发布
qaaaaaaz的博客
07-05 877
C/C++的函数参数是通过压入堆栈的方式来给函数传参数的（堆栈是一种先进后出的数据结构），最先压入的参数最后出来，在计算机的内存中，数据有2块，一块是堆，一块是栈（函数参数及局部变量在这里），而栈是从内存的高地址向低地址生长的，控制生长的就是堆栈指针了，最先压入的参数是在最上面，就是说在所有参数的最后面，最后压入的参数在最下面，结构上看起来是第一个，所以最后压入的参数总是能够被函数找到，因为它就在堆栈指针的上方。标准函数库： 这个库是由通用的、独立的、不属于任何类的函数组成的。函数库继承自 C 语言。
C++代码复用的方法
热门推荐
Coder-Coder
12-02 1万+
情景：   对不同的对象，要执行相同的逻辑操作。在C++中有哪些方法实现？ 解决方法：   1，模板，将不同的对象的类型作为模板参数。 //例： int iarray[] = {2,6,4,8,3}; std::sort(iarray,iarray+sizeof(iarray)/sizeof(iarray[0])); double farray[] = {2.0,6.0,4.0
c++代码的复用形式
bieshang的博客
10-06 1070
在c++中的一些代码复用形式
C++ 类模板、函数模板全特化、偏特化的使用
08-25
C++ 类模板、函数模板全特化、偏特化的使用 类模板全特化和偏特化是 C++ 编程语言中非常重要的概念，它们都是模板元编程的基础。类模板全特化和偏特化可以让开发者更好地控制模板的行为，提高代码的灵活性和可维护...
《数据结构C++版》-顺序表实验-使用类模板的方式实现
10-24
用C++实现了数据结构中的顺序表，并且使用了面向对象知识中的类模板
C++堆栈类模板实现代码
08-26
C++堆栈类模板实现代码 C++堆栈类模板是指使用C++语言实现的堆栈类模板，它可以存储不同类型的数据。下面是堆栈类模板的实现代码： 首先，我们需要定义一个堆栈类模板MyStack，使用模板参数T来表示存储的数据类型...
C++函数模板与类模板实例解析
01-20
本文针对C++函数模板与类模板进行了较为详尽的实例解析，有助于帮助读者加深对C++函数模板与类模板的理解。具体内容如下： 泛型编程（Generic Programming）是一种编程范式，通过将类型参数化来实现在同一份代码上...
C++的精髓——代码复用、接口复用
浮城大亨的专栏
09-28 4639
C++的精髓——代码复用、接口复用 在另一篇文章中提到C++三大特点的核心概括，也写在这里吧。 封装：信息隐藏 继承：代码复用 多态：面向对象 C++并不是面向对象，它包容多种编程思想，如面向过程，面向对象，泛型编程等。 笔者还在学校的时候理解C++最终精髓是两点：代码复用、接口复用。到现在隔的时间挺长了，今天不防把它记录下来，希望不会引起各位高手的嘲笑吧。 C++的特点
c++代码复用...
weixin_33909059的博客
07-02 660
c++的代码复用方式无非就是两种-->使用类的继承-->使用类的模版 ps： 博主主要是linux c系的，对模版方面知道的不多；难免会有错误，如果发现有错，请向我提出 关于继承 继承中重要也是最困难的就是多继承的情况，在此情况下编程的复杂度也会明显增加 Human--------->Writer----------| ...
C++学习（十四）代码复用的几种方法
hankern的专栏
06-14 1895
一、宏定义 二、函数定义 两者的区别为： 1、普通函数是在程序运行时调用，程序会给它的成员分配内存。而带参宏是在编译前就已经执行，并且不会分配内存单元。 2、宏替换不占用运行时间，只占用编译时间。函数则占用运行时间。所以，如果想提高程序运行效率，可以用宏代替部分函数。 ...
C++ 实现复用第三方库的方法名
sliver.chen的博客
12-03 308
方法名重复时的应对假设有以下情况class test { public: test(){}; ~test(){}; double sin(double); double call_sin(double num, int flag); };sin函数在ｃ标准库里的math.h已经提供 但你并不想在所有场合都使用标准库的sin　而自己在类里也实现了一个sin 通过封装的
C++构造函数复用问题
guchuanhang的专栏
05-02 2414
在定义C++的构造函数复用
C++代码重用
powder_snow的博客
02-25 689
C++ Primer Plus读书笔记 代码重用 C++的一个主要目标是促进代码重用，公有继承是实现这种目标的机制之一，但不是唯一的机制。有一些类成员，本身是另一个类的对象，这种方法称为包含、组合或层次化。还有一些其他的继承方法是私有继承或保护继承。通常，包含、私有、保护继承方法用于实现has-a关系，即新的类将包含另一个类的对象。多重继承使得能够使用两个或更多的基类派生出来的新的类，将...
完整版：资深程序员都了解的代码复用法则
weixin_45583158的博客
05-09 824
编写代码最重要一条，是怎样复用其他程序员的代码和思路来解决问题。通过修改他人的代码来解决复杂问题是种错误的做法，不仅成功的机率很低，就算成功也不会提供什么经验。按照这种方...
C++ - 通过私有(private)继承复用类实现工厂函数(factory function) 详解
Mystra
04-15 3477
通过私有(private)继承复用类实现工厂函数(factory function) 详解 版权归C.L.Wang所有, 禁止转载, 如有需要, 请站内联系. 本文地址:http://blog.csdn.net/caroline_wendy/article/details/23750515 通过接口类(interface class), 实现工厂函数, 可以复用(reuse)已有类, 重写实现接口. 如
C++类模板深度解析与应用示例
"C++中的类模板是解决代码重复性问题的有效工具，允许创建能处理多种数据类型的通用类。通过引入类型参数，类模板可以应用于不同的数据类型，从而提高代码的复用性和灵活性。 类模板的定义包括以下几个关键点： 1....
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值