C++类模板

最新推荐文章于 2022-06-25 14:45:42 发布
最新推荐文章于 2022-06-25 14:45:42 发布
阅读量358 收藏 3
点赞数
分类专栏： C++ 文章标签： C 类模板
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Young__Fan/article/details/80983028
版权

 1 类模板

    类模板和函数模板的定义和使用类似，我们已经进行了介绍。有时，有两个或多个类，

其功能是相同的，仅仅是数据类型不同。

    1.类模板用于实现类所需数据的类型参数化

    2.类模板在表示如数组、表、图等数据结构显得特别重要，这些数据结构的表示和算

法不受所包含的数据类型的影响。

/**
 *Copyright (c) 2018 Young Fan.All Right Reserved.
 *Filename: 4 类模板
 *Author: Young Fan
 *Date: 2018.4.30
 *IDE: Visual Studio 2017
 *Description: 类模板
 */

#include<iostream >
using namespace std;

template<class T>
class Person
{
public:
	Person(T id,T age)
	{
		this->mAge = age;
		this->mId = id;
	}

	void Show()
	{
		cout << "ID:" << mId << "  Age:" << mAge << endl;
	}
public:
	T mId;
	T mAge;
};

void test1()
{
	//函数模板在在调用的时候，可以自动类型推导
	//但，类模板必须显式指定类型
	Person<int> p(10, 20); //必须显式指定类型。因为类定义对象，对象要需要编译器分配内存
	p.Show();
}
 
int main()
{
	test1();
	return 0;
}

总结：

      函数模板在在调用的时候，可以自动类型推导，但，类模板必须显式指定类型如：Person<int> p(10, 20); 必须显式指定类型。因为类定义对象，对象要需要编译器分配内存

1.1 类模板派生普通类

/**
 *Copyright (c) 2018 Young Fan.All Right Reserved.
 *Filename: 5 类模板派生普通类
 *Author: Young Fan
 *Date: 2018.5.2
 *IDE: Visual Studio 2017
 *Description: 类模板派生普通类
 */

#include<iostream>
using namespace std;

template<class T>
class Person
{
public:
	Person()
	{
		mAge = 0;
	}
public:
	T mAge;
};

//类定义对象，对象要需要编译器分配内存
//所以必须显式指定类型
class subPerson:public Person<int> //必须显式指定类型。因为类定义对象，对象要需要编译器分配内存
{

};

int main()
{
	
	return 0;
}

总结：

函数模板在在调用的时候，可以自动类型推导但，类模板必须显式指定类型，必须显式指定类型。因为类定义对象，对象要需要编译器分配内存。故在继承（派生）类的时候要指定类型。

 

1.2 类模板派生类模板

 

 

/**
 *Copyright (c) 2018 Young Fan.All Right Reserved.
 *Filename: 6 类模板派生类模板
 *Author: Young Fan
 *Date: 2018.5.2
 *IDE: Visual Studio 2017
 *Description: 类模板派生类模板
 */

#include<iostream>
using namespace std;

template<class T>
class Animal
{
public:
	void Jiao()
	{
		cout << mAge << "岁动物在叫！" << endl;
	}
public:
	T mAge;
};

template<class T>
class Cat : public Animal<T>
{

};


int main()
{
	Cat<int> cat;
	cat.mAge = 2;
	cat.Jiao();

	return 0;
}

 

 

1.3 类的h与cpp分离编写

Person.h

//C语言中防止头文件被重复包含，如下方式
#ifndef PERSON_H  //防止头文件被重复包含，因为包含一次就行
				//Ctrl + shif + u，可以将选中英文字符内容变大写，如这里讲person_h变为PERSON_H
#define PERSON_H

//..................

#endif

//C++中防止头文件被重复包含用#pragma once
#pragma once

#include <iostream>
#include <string>

using namespace std;

class Person
{
public:
	Person(string name, int age);  //构造函数声明
	void Show(); //方法声明
public:
	string mName;
	int mAge;
	int mID;
};

//.h里只做声明，不做定义（实现），.cpp里做定义（实现）

Person.cpp

 

/**
 *Copyright (c) 2018 Young Fan.All Right Reserved.
 *Author: Young Fan
 *Date: 2018.6.22
 *IDE: Visual Studio 2017
 *Description: 
 */

#include "Person.h"

Person::Person(string name, int age)  //构造函数定义（实现），要加类的作用域
{
	this->mName = name;
	this->mAge = age;
}

void Person::Show()  //方法的定义（实现）
{
	cout << "Name:" << this->mName << "  Age:" << this->mAge << endl;
}


main.cpp

 

/**
 *Copyright (c) 2018 Young Fan.All Right Reserved.
 *Author: Young Fan
 *Date: 2018.6.22
 *IDE: Visual Studio 2017
 *Description: 
 */

#include<iostream>
#include "Person.h"
using namespace std;

int main()
{
	Person p("YoungFan", 25);
	p.Show();

    return 0;
}

 

1.4 类模板实现-在类内实现

/**
 *Copyright (c) 2018 Young Fan.All Right Reserved.
 *Author: Young Fan
 *Date: 2018.6.22
 *IDE: Visual Studio 2017
 *Description: 
 */

#include <iostream>
#include <string>  //用string要加头文件

using namespace std;

template<class T1,class T2>
class Person
{
public: //构造函数这里也得加权限，不加默认为private
	Person(T1 name, T2 age)
	{
		this->mName = name;
		this->mAge = age;
	}
	void Show()
	{
		cout << "Name:" << this->mName << "  Age:" << this->mAge << endl;
	}
public:
	T1 mName;
	T2 mAge;
};

void test()
{
	Person<string, int> p("YoungFan",25);
	p.Show();
}

int main()
{
	
	test();
    return 0;
}

构造函数也得加权限，不加默认为private

 

1.5 类模板的外部实现

/**
 *Copyright (c) 2018 Young Fan.All Right Reserved.
 *Author: Young Fan
 *Date: 2018.6.22
 *IDE: Visual Studio 2017
 *Description: 
 */

#include <iostream>

using namespace std;

//普通友元的类外声明，很麻烦，所以不要滥用友元
template<class T> class Person; //类声明
template<class T> void PrintPerson(Person<T>& p); //函数声明

template<class T>
class Person
{
public: 
	Person(T age, T id); //声明。编译器碰到声明不编译，会生成一个函数符号。在连接的时候
						//，根据这个符号去找函数定义（实现），找到就连上，找不到就连接失败
						//，连接失败的话就会报无法解析的外部符号
	void Show();

	//重载左移操作符,这里使用友元
	//方法一：加template<class T>，这种方法在vs下编译可以通过并执行，但在其他编译器如Linux不能编译通过
	//代码如下所示
	//template<class T>
	//friend ostream& operator<<(ostream& os, Person<T>& p);

	//方法二：不加template<class T>，加<T>
	friend ostream& operator<<<T>(ostream& os, Person<T>& p);

	//普通友元函数
	//方法一：加template<class T>，这种方法在vs下编译可以通过并执行，但在其他编译器如Linux不能编译通过
	//代码如下所示
	//template<class T>
	//friend void PrintPerson(Person<T>& p);

	//方法二：不加template<class T>，加<T>，还要写类外声明
	friend void PrintPerson<T>(Person<T>& p);

private:
	T mID;
	T mAge;
};

//类外定义
template<class T>
Person<T>::Person(T age, T id) //使用类模板需要模板参数列表,即Person<T>::
{
	this->mID = id;
	this->mAge = age;
}

template<class T>
void Person<T>::Show() //使用类模板需要模板参数列表,即Person<T>::
{
	cout << "ID:" << this->mID << "  Age:" << this->mAge << endl;
}

//重载左移运算操作符
template<class T>
ostream& operator<<(ostream& os, Person<T>& p)
{
	os << "Age:" << p.mAge << " ID:" << p.mID << endl; //因为使用的友元，故能直接获取私有成员
	return os;
}

template<class T>
void PrintPerson(Person<T>& p)
{
	cout << "Age:" << p.mAge << " ID:" << p.mID << endl;
}

void test()
{
	Person<int> p(10, 20);
	p.Show();
	cout << p; //使用重载的操作符“<<” 
	PrintPerson(p);
}

int main()
{
	test();
	return 0;
}

1.6 类模板h与cpp分离编写

Person.h

//这里使用C语言的防止头文件被重复包含
//C++中防止头文件被重复包含用#pragma once

#ifndef PERSON_H
#define PERSON_H

#include <iostream>
using namespace std;
template<class T>
class Person
{
public:
	Person(T age);
	void Show();
private:
	T age;
};

#endif

Person.hpp

/**
 *Copyright (c) 2018 Young Fan.All Right Reserved.
 *Author: Young Fan
 *Date: 2018.7.8
 *IDE: Visual Studio 2017
 *Description: 
 */

#include "Person.h"

//函数模板  ，它经过两次编译
//并没有生成独立的具体模板函数（因为是独立编译的，没有调用，即没有调用设置类型）
template<class T>
Person<T>::Person(T age)
{
	this->age = age;
}

template<class T>
void Person<T>::Show()
{
	cout << "Age: " << age << endl;
}

main.cpp

/**
 *Copyright (c) 2018 Young Fan.All Right Reserved.
 *Author: Young Fan
 *Date: 2018.7.8
 *IDE: Visual Studio 2017
 *Description: 
 */

//#include "Person.h"  //不能包含.h
//#include "Person.cpp"  //要包含cpp,相当于把该cpp拷进来了
#include "Person.hpp" //把头文件的那个cpp文件后缀改为hpp（相当于头文件和cpp文件的合体）
					//然后，在这里包含hpp文件，一般有类模板分文件的时候都这么写
//分离写法的时候不要涉及友元，会不通过，具体不知原因

int main()
{
	Person<int> p(10);//构造函数的定义在当前文件没有找到，编译器认为这个函数在其他文件中定义
	            //让链接器在连接的时候，去找这个函数的具体位置
	p.Show(); //Show函数的定义在当前文件没有找到，编译器认为这个函数在其他文件中定义
		//让链接器在连接的时候，去找这个函数的具体位置

    return 0;
}

//在写类模板的时候，最好写在一个文件里
//但如果要分开为多文件，就把头文件的那个cpp文件后缀改为hpp（相当于头文件和cpp文件的合体）
//所以在写类模板的时候写为hpp，别人一看见就知道里面有类模板

总结：

#include "Person.hpp" 把头文件的那个cpp文件后缀改为hpp（相当于头文件和cpp文件的合体）

然后，在这里包含hpp文件，一般有类模板分文件的时候都这写

分离写法的时候不要涉及友元，会不通过，具体不知原因

 

Person<int> p(10);//构造函数的定义在当前文件没有找到，编译器认为这个函数在其他文件中定义,让链接器在连接的时候，去找这个函数的具体位置

p.Show(); //Show函数的定义在当前文件没有找到，编译器认为这个函数在其他文件中定义,让链接器在连接的时候，去找这个函数的具体位置

 

在写类模板的时候，最好写在一个文件里,但如果要分开为多文件，就把头文件的那个cpp文件后缀改为hpp（相当于头文件和cpp文件的合体）,所以在写类模板的时候写为hpp，别人一看见就知道里面有类模板

 

 

1.7  类模板碰到static成员

    从类模板实例化的每一个模板类有自己的类模板数据成员，该模板的所有对象共享一个static 数据成员。

    和非模板类的static 数据成员一样，模板类的static 数据成员也应该在文件范围定义和初始化。

    每个模板类有自己类模板的static 数据成员的副本。

/**
 *Copyright (c) 2018 Young Fan.All Right Reserved.
 *Author: Young Fan
 *Date: 2018.7.8
 *IDE: Visual Studio 2017
 *Description: 
 */

#include <iostream>
using namespace std;

template<class T>
class Person
{
public:
	static int a;
};

//类外初始化
template<class T> int Person<T>::a = 0;

int main()
{
	Person<int> p1, p2, p3;
	Person<char> pp1, pp2, pp3;

	p1.a = 10;
	pp1.a = 100;

	cout << p1.a << " " << p2.a << " " << p3.a << endl; //打印：10 10 10
	cout << pp1.a << " " << pp2.a << " " << pp3.a << endl;//打印： 100 100 100

	//1.从类模板实例化的每一个模板类有自己的类模板数据成员，该模板的所有对象共享一个static 数据成员

	//2.故每个模板类有自己类模板的static数据成员的副本，即具有独有的static成员

    return 0;
}

总结：

1.从类模板实例化的每一个模板类有自己的类模板数据成员，该模板的所有对象共享一个static 数据成员


2.故每个模板类有自己类模板的static数据成员的副本，即具有独有的static成员
 

Young__Fan
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++ premier plus 第六版 编程练习解答（第十章）
acslsr的博客
02-21 206
10.2 //1.person.h #ifndef PERSON_H_ #define PERSON_H_ class Person { private: static const int LIMIT = 25; string lname; char fname[LLIMIT]; public: Person(){lname = "";fname[0] = '\0';} Person(...
c++ 类模板
01-28
很不错的类模板，
c++类模板
weixin_50866517的博客
04-11 220
类模板类模板与函数模板的区别类模板作为函数的参数类模板中成员函数创建时机类模板对象做函数参数二级标题三级标题四级标题五级标题六级标题 1.C++ 除了支持函数模板，还支持类模板（Class Template）。函数模板中定义的类型参数可以用在函数声明和函数定义中，类模板中定义的类型参数可以用在类声明和类实现中。类模板的目的同样是将数据的类型参数化。 3.语法： template<class T1, class T2> class 类名 {...} 4.类模板和函数模板都是以 template
设计一个Person类，Person类具有name和age属性，提供初始化函数(Init)
Ysmooth的博客
06-25 4895
设计一个Person类，Person类具有name和age属性
【翁恺】24-拷贝构造2
博观约取，厚积薄发
04-20 799
如果类包含指针？ Copy pointer： #ifndef PERSON_H_ #define PERSON_H_ class Person { public: Person(const char* s);//构造函数 ~Person();//析构函数 void print();//函数原型，没有实际body，有一些什么样的函数 //... //private: char* name ;//数据成员 char* instead of string //... }; #endif // !
#ifndef#define#endif的用法(整理)
放牛娃的专栏
07-27 1万+
1.头文件中的#ifndef头件的中的#ifndef，这是一个很关键的东西。比如你有两个C文件，这两个C文件都include了同一个头文件。而编译时，这两个C文件要一同编译成一个可运行文件，于是问题来了，大量的声明冲突。 还是把头文件的内容都放在#ifndef和#endif中吧。不管你的头文件会不会被多个文件引用，你都要加上这个。一般格式是这样的： #ifndef #define
C++类模板案例.zip
08-11
C++标准库提供了`std::array`模板类，它是固定大小数组的封装，可以与类模板结合使用。`std::array`模板接收两个参数：元素类型和数组的大小。例如，创建一个存储5个整数的数组： ```cpp #include template ...
C++类模板与模板类深入详解
09-04
C++类模板与模板类是C++编程中重要的特性，它们提供了泛型编程的能力，允许程序员编写出能够处理多种数据类型的一般性代码。本文将深入探讨这两个概念及其相关知识点。 1. 关键字`typename`与`class`： 在C++的模板...
c++类模板学习指南
04-02
有助于你深入地学习，理解c++类模板相关技术。由简单到复杂逐渐深入学习。
C++ 类模板、函数模板全特化、偏特化的使用
08-25
C++ 类模板、函数模板全特化、偏特化的使用 类模板全特化和偏特化是 C++ 编程语言中非常重要的概念，它们都是模板元编程的基础。类模板全特化和偏特化可以让开发者更好地控制模板的行为，提高代码的灵活性和可维护...
C++类模板实现数组的排序以及增删查
最新发布
06-06
该段代码包含对数组的增删查以及排序的函数，采用面向对象的思路进行编写，其中应用了类模板，它是C++中一类特殊的数据类型，允许用户定义具有通用性的类。用户可以通过代码实例，了解类模板的语法等应用规范，包括...
C++堆栈类模板实现代码
08-26
C++堆栈类模板实现代码 C++堆栈类模板是指使用C++语言实现的堆栈类模板，它可以存储不同类型的数据。下面是堆栈类模板的实现代码： 首先，我们需要定义一个堆栈类模板MyStack，使用模板参数T来表示存储的数据类型...
C++使用模板类实现链式栈
08-19
"C++使用模板类实现链式栈" 本文主要介绍了C++使用模板类实现链式栈的知识点，包括链式栈的定义、实现、操作等方面的内容。 一、链式栈的定义 链式栈是一种数据结构，它可以存储大量的数据元素，并且可以实现栈的...
C++模板类的用法实例
12-31
本文实例讲述了C++中模板类的用法，分享给大家供大家参考。具体方法如下： //#include StdAfx.h #ifndef __AFXTLS_H__ #define __AFXTLS_H__ #include class CSimpleList { public: CSimpleList(int nNextOffset=...
C++ 类模板和模板类的深入解析
01-20
　答：class用于定义类，在模板引入c++后，初定义模板的方法为：template，这里class关键字表明T是一个类型，后来为了避免class在这两个地方的使用可能给人带来混淆，所以引入了typename这个关键字，它的作用同...
【C++】02 类模板
piano_diano的博客
02-26 280
#include &lt;iostream&gt; using namespace std; template &lt;class T&gt; class Person{ public : Person(T id,T age){ this-&gt;mAge = age; this-&gt;mId = id; ...
1.3 C++基础知识_程序结构
一个嵌入式软件工程师的博客
06-02 458
本节讨论C++的程序结构。之前将函数在类中定义，现在首先将函数定义到类的外部，仅在类中申明。注意定义在外部的函数，函数名前面需要加上Person::，表示属于Person类，其他规则和在类中定义一致。当函数内容比较简短时，写在类中也可以，但是如果篇幅较大，最好还是在外部实现，这样代码会更简洁些。假设一个团队在做某个设备：那么，A需要创建两个文件：其中头文件 person.h 需要提供给B使用，person.cpp 则由A自行保管维护即可。B只需要实现一个文件 main.cpp 即可，在 main.cpp 文
#include的两种形式
Benson的专栏
12-21 1716
通常我们在使用include指令的时候，有两种形式： #include "file" #include 比如我们想导入I/0流头文件，我们是这样做的: #include 如果我们有一个Person.h头文件 // Person.h class Person { char * name; int age ; //
正确使用#include和前置声明(forward declaration)
热门推荐
SpriteLW的专栏
07-23 3万+
差不多一年时间没用过C++写过程序了,由于工作的需要,我又回到了C++的阵形。在工作的过程中遇到了很多麻烦，当我往工程里加一个类，而且那个类又与工程里的类相关，如有那个类型的成员变量。情况如下//////A.h///////////class A{.......};////////B.h//////////class B:A{....A member;}

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值