泛型编程之类模版

最新推荐文章于 2024-05-27 23:22:10 发布
最新推荐文章于 2024-05-27 23:22:10 发布
阅读量337 收藏
点赞数
分类专栏： C++ 文章标签： C++ 泛型编程 类模版
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/IT_iverson/article/details/77991820
版权

一.概念

类模版和函数模版的定义和使用类似，上篇博客已经介绍了函数模版，有时，有两个或者类，其功能是相同的，仅仅是数据类型不同，如下面语句声明了一个类


注意：1.类模版用于实现所需数据的类型参数化

            2.类模版在表示如数组，表，图等数据结构显得提别重要

            3.这些数据结构表示和算法不收所包含的元素类型的影响

二.单个类模版语法

看如下代码：

template <typename T>
class A
{
private:
	T a;
public:
	A(T a)
	{
		this->a = a;
	}
	void print()
	{
		cout << "a=" << a << endl;
	}
};
void test(A<int> &n)//类模版做函数参数的用法
{
	n.print();
}
int main()
{
	//用模版类生成具体的类，用具体的类生成具体的对象
	{
		A<int> c1(10);
		c1.print();
		test(c1);
	}
	{
	A<double> c1(99.9);
	c1.print();
    }   
	system("pause");
	return 0;
}

三.继承中的类模版语法

1.从模版类派生一个普通类

template <typename T>
class A
{
protected:
	T a;
public:
	A(T a)
	{
		this->a = a;
	}
	void print()
	{
		cout << "a=" << a << endl;
	}
};
//类模版派生时，需要具体化模版类，C++编译器需要知道父类的数据类型具体是什么样子的
//要知道父类所占的内存大小是多少，只有数据类型固定下来，否则不知道怎么分配内存
class B :public A<int>
{
private:
	int b;
public:
	B(int a, int b) :A<int>(a)
	{
		this->b = b;
	}
	void print1()
	{
		cout << "a=" << a << "  b="<<b << endl;
	}
};
int main()
{
	B c1(10, 20);
	c1.print1();
	system("pause");
	return 0;
}

2.从模版类派生模版类

template <typename T>
class A
{
protected:
	T a;
public:
	A(T a)
	{
		this->a = a;
	}
	void print()
	{
		cout << "a=" << a << endl;
	}
};
template <typename T>
class B :public A<T>
{
private:
	T b;
public:
	B(T a b) :A<T>(a)
	{
		this->b = b;
	}
	void print()
	{
		cout << "b="<<b << endl;
	}
};
int main()
{
	B<int> c1(1, 2);
	c1.print();
	system("pause");
	return 0;
}
四.类模版语法知识体系梳理

1.所有类模版函数写在类内部

template <typename T>
class complex
{
private:
	friend ostream& operator<<(ostream &out, const complex &n)//写在类内部没有问题，等会写在类外部就会出问题。等会看下个代码
	{
		{
			out << "a=" << n.a << " b=" << n.b << endl;
			return out;
		}
	}
	friend complex mysub(const complex &n, const complex&m)
	{
		complex c1(n.a - m.a, n.b - m.b);
		return c1;
	}
	T a;
	T b;
public:
	complex(T a, T b)
	{
		this->a = a;
		this->b = b;
	}
	void print()
	{
		cout << "a=" << a << "  b=" << b << endl;
	}
	complex operator+(const complex &n)
	{
		complex c1(this->a + n.a, this->b + n.b);
		return  c1;
	}
};
int main()
{
	//需要把模版类具体话以后才能定义对象，因为编译器要分配内存
	complex <int>c1(1, 2);
	complex<int> c2(2, 4);
     complex<int> c3=c1 + c2;
	 cout << c1 + c2;
	 c3.print();
	 cout << mysub(c1, c2);
	 system("pause");
	 return 0;
}

2.所有模版函数都写在类的外部，不过都写在一个文件中，比如.cpp文件

template <typename T>
class complex
{
private:
	friend ostream& operator<<(ostream &out, const complex &n)
	{
			out << "a=" << n.a << " b=" << n.b << endl;
			return out;
	}
	friend complex mysub(const complex &n, const complex&m)
	{
		complex c1(n.a - m.a, n.b - m.b);
		return c1;
	}
	T a;
	T b;
public:
	complex(T a, T b);
	void print();
	complex operator+(const complex &n);
};
template <typename T>
complex<T>::complex(T a, T b)
{
	this->a = a;
	this->b = b;
}
template <typename T>
void complex<T>::print()
{
		cout << "a=" << a << "  b=" << b;
}
template <typename T>
complex<T> complex<T>::operator+(const complex<T> &n)
{
	complex c1(this->a + n.a, this->b + n.b);//在这个里面加不加<T>都可以
	return  c1;
}
int main()
{
	//需要把模版类具体话以后才能定义对象，因为编译器要分配内存
	complex <int>c1(1, 2);
	complex<int> c2(2, 4);
     complex<int> c3=c1 + c2;
	 cout << c1 + c2;
	 c3.print();
	 system("pause");
	 return 0;
}

现在还没有将友元函数写在外面，代码没有任何问题，接下来将友元也写在外面

template <typename T>
class complex
{
private:
	friend ostream& operator<<(ostream &out, const complex &n);
	friend complex mysub(const complex &n, const complex&m)
	{
		complex c1(n.a - m.a, n.b - m.b);
		return c1;
	}

	T a;
	T b;
public:
	complex(T a, T b);
	void print();
	complex operator+(const complex &n);
};
template <typename T>
complex<T>::complex(T a, T b)
{
	this->a = a;
	this->b = b;
}
template <typename T>
void complex<T>::print()
{
		cout << "a=" << a << "  b=" << b;
}
template <typename T>
complex<T> complex<T>::operator+(const complex<T> &n)
{
	complex c1(this->a + n.a, this->b + n.b);//在这个里面加不加<T>都可以
	return  c1;
}
template <typename T>
ostream& operator<<(ostream &out, const complex<T> &n)
{
	out << "a=" << n.a << " b=" << n.b << endl;
	return out;
}
int main()
{
	//需要把模版类具体话以后才能定义对象，因为编译器要分配内存
	complex <int>c1(1, 2);
	complex<int> c2(2, 4);
     complex<int> c3=c1 + c2;
	 cout << c1 + c2;
	 c3.print();
	 system("pause");
	 return 0;
}
程序一跑就出问题

这是为什么呢？
因为：和函数模版的机制有问题，因为两次编译生成的函数头不一样。


template <typename T>
class complex
{
private:
	friend ostream& operator<<<T>(ostream &out, const complex<T> &n);
	friend complex mysub(const complex &n, const complex&m)//此函数刚才忘记添加，自己加上即可
	{
		complex c1(n.a - m.a, n.b - m.b);
		return c1;
	}
	T a;
	T b;
public:
	complex(T a, T b);
	void print();
	complex operator+(const complex &n);
};
template <typename T>
complex<T>::complex(T a, T b)
{
	this->a = a;
	this->b = b;
}
template <typename T>
void complex<T>::print()
{
		cout << "a=" << a << "  b=" << b;
}
template <typename T>
complex<T> complex<T>::operator+(const complex<T> &n)
{
	complex c1(this->a + n.a, this->b + n.b);//在这个里面加不加<T>都可以
	return  c1;
}
template <typename T>
ostream& operator<<(ostream &out, const complex<T> &n)
{
	out << "a=" << n.a << " b=" << n.b << endl;
	return out;
}
int main()
{
	//需要把模版类具体话以后才能定义对象，因为编译器要分配内存
	 complex <int>c1(1, 2);
	complex<int> c2(2, 4);
     complex<int> c3=c1 + c2;
	 //c1 << cout;//     complex <int>c1(1, 2);
	 operator<<(cout, c1);
	 c3.print();
	 system("pause");
	 return 0;
}

所以说不要滥用友元函数~一般情况下左移和右移运算符重载用友元函数，其余的尽量不要用不然就会出错，不然我们继续往下看

接下来我们将这个函数

	friend complex mysub(const complex &n, const complex&m)
		{
			complex c1(n.a - m.a, n.b - m.b);
			return c1;
		}

弄到模版类外面，看看是什么样的

template <typename T>
class complex
{
private:
	friend ostream& operator<<<T>(ostream &out, const complex<T> &n);
	friend complex mysub(const complex &n, const complex&m);
	T a;
	T b;
public:
	complex(T a, T b);
	void print();
	complex operator+(const complex &n);
};
template <typename T>
complex<T>::complex(T a, T b)
{
	this->a = a;
	this->b = b;
}
template <typename T>
void complex<T>::print()
{
		cout << "a=" << a << "  b=" << b;
}
template <typename T>
complex<T> complex<T>::operator+(const complex<T> &n)
{
	complex c1(this->a + n.a, this->b + n.b);//在这个里面加不加<T>都可以
	return  c1;
}
template <typename T>
ostream& operator<<(ostream &out, const complex<T> &n)
{
	out << "a=" << n.a << " b=" << n.b << endl;
	return out;
}
template <typename T>
complex<T> mysub(const complex<T> &n, const complex<T>&m)
{
	complex c1(n.a - m.a, n.b - m.b);
	return c1;
}
int main()
{
	//需要把模版类具体话以后才能定义对象，因为编译器要分配内存
	 complex <int>c1(1, 2);
	 complex<int> c2(2, 4);
     complex<int> c3=c1 + c2;
	 cout << mysub(c1,c2);
	 c3.print();
	 system("pause");
	 return 0;
}

一样会出错，怎么解决呢？

友元函数如果不是实现函数重载，写在类外，需要进行类的前置声明和函数的前置声明

如下：


  代码如下：

template <typename T>
class complex;
template<typename T>
complex<T> mysub(const complex<T> &n, const complex<T>&m);
template <typename T>
class complex
{
private:
	friend ostream& operator<<<T>(ostream &out, const complex<T> &n);
	friend complex<T> mysub<T>(const complex<T> &n, const complex<T>&m);
	T a;
	T b;
public:
	complex(T a, T b);
	void print();
	complex operator+(const complex &n);
};
template <typename T>
complex<T>::complex(T a, T b)
{
	this->a = a;
	this->b = b;
}
template <typename T>
void complex<T>::print()
{
		cout << "a=" << a << "  b=" << b;
}
template <typename T>
complex<T> complex<T>::operator+(const complex<T> &n)
{
	complex c1(this->a + n.a, this->b + n.b);//在这个里面加不加<T>都可以
	return  c1;
}
template <typename T>
ostream& operator<<(ostream &out, const complex<T> &n)
{
	out << "a=" << n.a << " b=" << n.b << endl;
	return out;
}
template <typename T>
complex<T> mysub<T>(const complex<T> &n, const complex<T>&m)
{
	complex<T> c1(n.a - m.a, n.b - m.b);
	return c1;
}
int main()
{
	//需要把模版类具体话以后才能定义对象，因为编译器要分配内存
	 complex <int>c1(1, 2);
	 complex<int> c2(2, 4);
     complex<int> c3=c1 + c2;
	 cout << mysub(c1,c2);
	 c3.print();
	 system("pause");
	 return 0;
}

3.所有模版函数都写在类的外部，不过都写在.h;.cpp文件中

就是分文件写，这里就不多做介绍了。

总之一句话，不要乱用友元函数~
五.类模版中的static关键字

看如下代码：

template <typename T>
class A
{
public:
	static T a;
};
template <typename T>
T A<T>::a = 0;
int main()
{
	{
		A<int> c1, c2, c3;
		c1.a++;
		c2.a++;
		c3.a++;
		cout << A<int>::a << endl;
	}
	{
	  A<char> c1, c2, c3;
	  c1.a = 'a';
	  c2.a++;
	  c3.a++;
	  cout << A<char>::a << endl;
    }
	system("pause");
	return 0;
}

各自用自己static 变量~

以上就是类模版的基本用法！




IT_iverson
关注
专栏目录
泛型编程之类模板
cat_eat_fish
09-09 194
1 类模板基本使用(代码中解析) 类模板与函数模板的定义和使用类似 类模板中的泛型是指类中成员变量类型和成员函数中参数的类型 语法： template <class T> class Test { public: Test(T a,T b) { this->a = a; this->b = b; } private: T a; T b; }; temp
c++ 泛型编程之类模板
jun8086的博客
11-01 264
泛型编程之类模板
C++- 泛型编程之类模板(详解)
qq_36059321的博客
01-24 489
类模板介绍 和函数模板一样,将泛型思想应用于类. 编译器对类模板处理方式和函数模板相同,都是进行2次编译 类模板通常应用于数据结构方面,使得类的实现不在关注数据元素的具体类型,而只关注需要实现的功能 比如: 数组类,链表类,Queue类,Stack类等 使用方法 通过template关键字来声明,然后通过typename关键字来定义模板类型,如下图所示: 类模板的使用 定义对象时,必须指定类模板...
C++泛型编程之类模板案例
Lan的博客
10-21 206
案例描述：实现一个通用的数组类。 要求如下： 1、可以对内置数据类型以及自定义数据类型的数据进行存储 2、将数组中的数据存储到堆区中 3、构造函数中可以传入数组的容量 4、提供对应的拷贝构造函数以及operator=防止浅拷贝问题 5、提供尾插法和尾删法对数组中的数据进行增加和删除 6、可以通过下标的方式访问数组中的元素 7、可以获取数组中当前元素个数和数组的容量 ...
C++泛型编程之模板
m0_72532428的博客
05-27 1541
模板的知识详解
C++泛型编程之类模板【详细讲解】
weixin_45688108的博客
01-16 458
本篇文章主要对于C++泛型编程中的类模板进行了讲解，文章中含有大量的代码，希望读者自行动手实现一下，对您应该会有所帮助。
泛型编程与模板
修行的凡人的博客
11-14 3888
基于著名书籍和自我学习得出的泛型编程与模板知识
26.C++- 泛型编程之类模板(详解)
抵抗时间扭曲，坚持做一件有意义的事
04-10 195
在上章25.C++- 泛型编程之函数模板(详解)学习了后,本章继续来学习类模板 类模板介绍 和函数模板一样,将泛型思想应用于类. 编译器对类模板处理方式和函数模板相同,都是进行2次编译 类模板通常应用于数据结构方面,使得类的实现不在关注数据元素的具体类型,而只关注需要实现的功能 比如:数组类,链表类,Queue类,Stack类等 使用方法 通过template关键字来声明,然后通过type...
c++模板与泛型编程
最新发布
tankeven的博客
05-27 212
总而言之：泛型编程就是为了编写和数据类型没有关系的逻辑代码，而模板就是为了实现代码逻辑和数据类型没有关系抽象的数据类，是泛型编程的先决条件；3.如果需要强制调用模板函数，可以使用显式调用的方式去调用指定的模板函数；模板的作用：通过使用模板降低重复代码的编写，把已经写好的代码作用最大化；总而言之：模板作用于函数就是函数模板，模板作用于类就是类模板；函数模板用于定义模板函数，模板函数就是用模板生成的函数；类模板用于定义模板类，模板类就是用类模板定义出来的类；模板就是泛型编程的前置条件，属于充分但不必要条件；
【C++】模板与泛型编程
Qiuhan_909的博客
03-29 937
1. 函数模板 2. 类模板 3. 非类型模板参数 4. 模板编译 5. 模板特化 6. 可变参数模板
C++模板元编程（0）模板编程与泛型编程
二进制君
04-04 3824
什么是元编程 元编程 (metaprogramming) 通过操作 程序实体 (program entity)，在 编译时 (compile time) 计算出 运行时 (runtime) 需要的常数、类型、代码的方法。 一般的编程是通过直接编写 程序 (program)，通过编译器 编译 (compile)，产生目标代码，并用于 运行时 执行。与普通的编程不同，元编程则是借助语言提供的 模板 (template) 机制，通过编译器 推导 (deduce)，在 编译时 生成程序。元编程经过编译器推导得到的程
C++泛型编程：创建模板与容器类实现
总结起来，这段代码示例展示了C++泛型编程的强大之处，它通过模板和继承机制，允许程序员编写出能处理多种数据类型的通用代码，并且支持灵活地扩展和定制不同类的行为。通过这种方式，代码更易于维护和复用，提高了...
C++模板与泛型编程：函数模板和类模板解析
"本资源主要探讨了泛型算法在C++中的应用，特别是通过模板和泛型编程来提高代码的复用性和效率。文件详细介绍了模板的概念，包括函数模板和类模板，以及它们如何解决传统编程中代码重复的问题。此外，提到了STL中的...
C++泛型编程:函数模板与类模板
烂笔头
12-15 665
泛型编程是一种语言机制,通过他可以实现一个标准的容器库,可以处理不同的数据类型. 比如对栈的描述: class stack { push(参数类型)//入栈 pop（参数类型）//出栈 } 由于上面的代码与数据类型有关，可以通过模板实现一个代码处理不同的数据类型。 首先执行一种通用的数据类型，不用具体指明哪一种。 class stack&lt;参数模板 T&gt; { push(T)//入栈 po...
菱形继承和虚函数
IT_iverson的博客
10-11 1861
此篇博客主要介绍菱形虚拟继承和虚函数的混合情况下的模型分析。 一首先介绍一下虚函数的实质内容 代码如下 class A { public: int a; virtual void fun1() { cout << "A::fun1 "<< endl; } }; class B :public A { public: int b; virtual void fun1()//函数
C++中的引用
IT_iverson的博客
08-07 1490
引用是C++新引进的概念在C语言中是不存在的，接下里啊重点介绍引用。 说到引用首先得提一个概念：变量名，变量名是指上是一段连续储存空间的别名，算是一个标号，门牌号，程序中通过变量来申请并命名内存空间。通过变量的名字来使用内存空间。 1.引用的概念 引用：相当于一个变量的别名，相当于给这个变量的内存空间重新起了第二个名字。 用法：如下代码 int main() { int a = 10;
升级版的C语言-->C++
IT_iverson的博客
08-06 899
C++相对于C语言不但继承 了C语言的大部分语法功能再次基础上还增强优化了很多的功能，接下来我就一一列举！ 1.register关键字功能增强 解释：//C语言的register的作用请求编译器将变量放在寄存器里面速度快，但是变量不能取地址            //C++中对依然支持register，但是变量可以取地址，因为C++编译器有自己的优化方式，当检测当程序有register变量要
C++类型萃取
IT_iverson的博客
10-23 739
一.问题的引入 首先我们如果要写一个拷贝函数，代码如下： template void Copy(T *dst, T *src, size_t size) { memcpy(dst, src, sizeof(T)*szie); }但是这个代码拷贝内置类型的没有问题，但是如果是自定义类型的，就牵扯到深浅拷贝问题，就行不通了，所以我们需要做的就是在代码内部判断传过来的数据类型，从而进行不同的操作。
函数重载重写重定义
IT_iverson的博客
09-11 717
一.首先问题的引出 看如下代码 class parent { public: void fun() { cout fun()..." << endl; } void fun(int i) { cout fun(int i) " << i << endl; } void fun(int i, int j) { cout fun(int i,int j) " << i
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值