C++类模板学习笔记

最新推荐文章于 2023-05-14 22:46:59 发布
最新推荐文章于 2023-05-14 22:46:59 发布
阅读量581 收藏 1
点赞数
分类专栏： C++ 文章标签： c++ 学习 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44653420/article/details/127717270
版权

C++类模板学习笔记

一、概述

  • 类模板的定义
#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include<string>
using namespace std;
template<class NameType,class AgeType>
class Maker
{
public:
	Maker(NameType name, AgeType age)
	{
		this->name = name;
		this->age = age;
	}

public:
	NameType name;
	AgeType age;
};

int main()
{

	return EXIT_SUCCESS;
}
  • 类模板的使用
#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include<string>
using namespace std;

// 类模板  不固定类成员变量的参数类型
template<class NameType,class AgeType>
class Maker
{
public:
	Maker(NameType name, AgeType age)
	{
		this->name = name;
		this->age = age;
	}

	void printMaker()
	{
		cout << this->name << " " << this->age << endl;
	}

public:
	NameType name;
	AgeType age;
};

void test()
{
	// 类模板不会自动推导数据类型  需要显示的告诉编译器是什么类型
	Maker<string, int> m("悟空", 18);
	m.printMaker();
}

int main()
{
	test();
	return EXIT_SUCCESS;
}
  • 类模板和函数模板的区别
    类模板不会自动推导数据类型，要显示的告诉编译器是什么类型，但是函数模板可以根据实参来推导数据类型

传入的参数类型 需要程序员自己去把握
template<class NameType,class AgeType>

// 通过指定参数类型 然后传入参数
	Maker<string, int> m("悟空", 18);
	m.printMaker();

	Maker<int, int> n(11,11);
	n.printMaker();
  • 类模板的默认参数

可以给类模板指定参数类型

这里给类模板指定参数类型int template

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include<string>
using namespace std;

// 类模板  不固定类成员变量的参数类型
// 这里给出了默认类型int 但是创建对象时 可以具体指定参数列表类型
template<class NameType = int,class AgeType = int>
class Maker
{
public:
	Maker(NameType name, AgeType age)
	{
		this->name = name;
		this->age = age;
	}

	void printMaker()
	{
		cout << this->name << " " << this->age << endl;
	}

public:
	NameType name;
	AgeType age;
};

void test()
{
	// 类模板不会自动推导数据类型  需要显示的告诉编译器是什么类型
	Maker<string, int> m("悟空", 18);
	m.printMaker();

	Maker<int, int> n(11,11);
	n.printMaker();
}

int main()
{
	test();
	return EXIT_SUCCESS;
}
  • 类模板的默认参数注意

默认类型后面的泛型类型都必须有默认类型

二、复数的模板类

  • 目的：对象c1(3,4),对象c2(3,9),对象c3 = c1.Maker_add(c2),c3的两个成员变量会等于a + 3 + 5，
    b = 4 + (-10), 并且数据类型可以不同

  • 通过成员函数实现 返回类

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include<string>
using namespace std;

// 设置默认参数类型为int
template<class T = int>
class Maker
{
public:
	// 默认构造参数
	Maker()
	{
		a = 0;
		b = 0;
	}

	// 有参构造函数
	Maker(T r,T i)
	{
		a = r;
		b = i;
	}

	Maker Maker_add(Maker& c2)
	{
		Maker<T> c;// 设置临时变量  
		c.a = this->a + c2.a;
		c.b = this->b + c2.b;
		return c;
	}

	void printMaker()
	{
		cout << "a = " << a << ", " << "b = " << b;
	}

private:
	T a;
	T b;
};

void test()
{
	// 设置参数列表Int类型
	Maker<int> c1(3, -4);
	Maker<int> c2(5, -10);
	Maker<int> c3;// 使用默认构造函数

	c3 = c1.Maker_add(c2);
	c3.printMaker();
}

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


#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include<string>
using namespace std;

// 设置默认参数类型为int
template<class T = int>
class Maker
{
public:
	// 默认构造参数
	Maker()
	{
		a = 0;
		b = 0;
	}

	// 有参构造函数
	Maker(T r,T i)
	{
		a = r;
		b = i;
	}

	Maker Maker_add(Maker& c2)
	{
		Maker<T> c;// 设置临时变量  
		c.a = this->a + c2.a;
		c.b = this->b + c2.b;
		return c;
	}

	void printMaker()
	{
		cout << "a = " << a << ", " << "b = " << b;
		cout << endl;
	}

private:
	T a;
	T b;
};

void test()
{
	// 设置参数列表Int类型
	Maker<int> c1(3, -4);
	Maker<int> c2(5, -10);
	Maker<int> c3;// 使用默认构造函数

	c3 = c1.Maker_add(c2);
	c3.printMaker();

	Maker<double> d1(3.0, -4.1);
	Maker<double> d2(5.1, -10.1);
	Maker<double> d3;// 使用默认构造函数

	d3 = d1.Maker_add(d2);
	d3.printMaker();

}

int main()
{
	test();
	return EXIT_SUCCESS;
}
  • 通过重载运算符进行实现
	// 重载加号运算符
	Maker operator+(Maker& c2)
	{
		// 创建临时对象 进行有参构造
		Maker tmp(this->a + c2.a,this->b + c2.b);
		return tmp;
	}

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include<string>
using namespace std;

// 设置默认参数类型为int
template<class T = int>
class Maker
{
public:
	// 默认构造参数
	Maker()
	{
		a = 0;
		b = 0;
	}

	// 有参构造函数
	Maker(T r,T i)
	{
		a = r;
		b = i;
	}

	Maker Maker_add(Maker& c2)
	{
		Maker<T> c;// 设置临时变量  
		c.a = this->a + c2.a;
		c.b = this->b + c2.b;
		return c;
	}

	// 重载加号运算符
	Maker operator+(Maker& c2)
	{
		// 创建临时对象 进行有参构造
		Maker tmp(this->a + c2.a,this->b + c2.b);
		return tmp;
	}

	void printMaker()
	{
		cout << "a = " << a << ", " << "b = " << b;
		cout << endl;
	}

private:
	T a;
	T b;
};

void test()
{
	// 设置参数列表Int类型
	Maker<int> c1(3, -4);
	Maker<int> c2(5, -10);
	Maker<int> c3;// 使用默认构造函数

	c3 = c1 + c2;
	c3.printMaker();
}

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

三、类模板作为函数参数


#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include<string>
using namespace std;

// 设置类模板的参数  默认参数是int
template<class TypeName = int,class TypeAge = int>
class Maker
{
public:
	Maker(TypeName a, TypeAge b)
	{
		this->name = a;
		this->age = b;
	}
	void PrintMaker()
	{
		cout << this->name << " " << this->age << endl;
	}

public:
	TypeName name;
	TypeAge age;
};


// 类模板作为函数参数
void func(Maker<string, int>& m)
{
	m.PrintMaker();
}

// 或者直接参数模板化
template<class T1,class T2>
void func2(Maker<T1, T2>& m)
{
	m.PrintMaker();
}

void test()
{
	Maker<string, int> m1("ddd",21);
	func(m1);

	func2(m1);
}

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

四、类模板的继承

类模板的继承：需要告诉编译器父类的泛型数据具体是什么样的数据类型

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include<string>
using namespace std;

// 设置类模板
template<class T = int>
class Father
{
public:
	Father()
	{
		m = 20;
	}

public:
	T m;
};

// 普通类  继承模板类的时候需要具体指定参数类型 这里参数列表设置为int
// 要告诉编译器 父类的泛型数据具体是什么类型的数据
class Son :public Father<int>
{
public:

};

template<class T1, class T2>
// 这里要告诉编译器父类的泛型数据类型具体是什么类型的数据  这里指定T2类型
class Son2 :public Father<T2>
{

};

void test()
{
	Son2<int, int> s;// 这里指定T2 是string 类型 说明父类的成员变量的类型是string 
	cout << s.m << endl;
}

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

五、类模板的成员函数类内和类外实现

5.1 成员函数类内实现

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include<string>
using namespace std;

// 成员函数类内实现
template<class NameType,class AgeType>
class Maker
{
public:
	Maker(NameType name, AgeType age)
	{
		this->name = name;
		this->age = age;
	}

	void printMkaer()
	{
		cout << this->name << " " << this->age << " " << endl;
	}

public:
	NameType name;
	AgeType age;
};

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

5.2 类模板的成员函数的类外实现

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include<string>
using namespace std;

// 成员函数类内实现
template<class NameType,class AgeType>
class Maker
{
public:
	Maker(NameType name, AgeType age);
	void printMaker();

public:
	NameType name;
	AgeType age;
};

// 类模板的成员函数类外实现
// 要写成函数模板的形式
template<class NameType,class AgeType>
// 需要指定具体的参数类型  然后再使用作用域符号
Maker<NameType,AgeType>::Maker(NameType name, AgeType age)
{
	cout << "构造函数" << endl;

	this->name = name;
	this->age = age;
}

template<class NameType,class AgeType>
void Maker<NameType, AgeType>::printMaker()
{
	cout << this->name <<" "<<this->age << endl;
}

void test()
{
	Maker<string, int> m("hhh", 11);
	m.printMaker();
}

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

六、类模板分文件编写问题和解决办法

  • 调用类模板的时候，需要进行二次编译，要把泛型的数据类型替换为具体的类型，这时候需要知道函数体，但是函数的实现是在.cpp中，那么调用类模板的.cpp没有引入实现.cpp 之引入.h 所以报错

  • 解决办法：将成员函数放到.h中，然后将.h改为.hpp 然后在调用成员函数的地方 引入.hpp

  • 为什么.hpp中有成员的实现，然后再调用类模板的地方引入.hpp，不会报重定义。类的成员函数默认申请为内联函数，在连接的时候，链接器会对重复的成员函数进行处理，只保留一份成员函数，所以不会进行报错

main.cpp

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include<string>
using namespace std;
#include"Maker.hpp"

int main()
{
	Maker<string, int> m("悟空",22);
	m.printMaker();

	return EXIT_SUCCESS;
}

Maker.hpp

// 防止多次编译
#pragma once
#include<iostream>
using namespace std;

template<class NameType,class AgeType>
class Maker
{
public:
	Maker(NameType name,AgeType age);
	void printMaker();

public:
	NameType name;
	AgeType age;
};


// 实现类模板中的成员函数 需要使用函数模板进行引入
template<class NameType, class AgeType>
Maker<NameType, AgeType>::Maker(NameType name, AgeType age)
{
	cout << "构造函数" << endl;
	this->name = name;
	this->age = age;
}

template<class NameType, class AgeType>
void Maker<NameType, AgeType>::printMaker()
{
	cout << this->name << " " << this->age << " " << endl;
}

七、类模板和友元

  • 友元函数类内实现
#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include<string>
using namespace std;

template<class NameType,class AgeType>

class Maker
{
	friend void printMaker(Maker<NameType, AgeType>& p)
	{
		cout << "类内实现" << p.name << " " << p.age << endl;
	}

public:
	Maker(NameType name, AgeType age)
	{
		this->name = name;
		this->age = age;
	}

private:
	NameType name;
	AgeType age;
};

void test1()
{
	Maker<string, int> m("悟空",11);
	printMaker(m);
}

int main()
{
	
	test1();
	return EXIT_SUCCESS;
}
  • 友元函数类外实现

使用函数模板的方式进行实现

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include<string>
using namespace std;

template<class NameType, class AgeType>
class Maker;
template<class NameType,class AgeType>
void printMaker(Maker<NameType, AgeType>& p);

template<class NameType, class AgeType>
class Maker
{
	friend void printMaker<>(Maker<NameType, AgeType>& p);
	

public:
	Maker(NameType name, AgeType age)
	{
		this->name = name;
		this->age = age;
	}

private:
	NameType name;
	AgeType age;
};

void test1()
{
	Maker<string, int> m("悟空",11);
	printMaker(m);
}

template<class NameType,class AgeType>
void printMaker(Maker<NameType, AgeType>& p)
{
	cout << "类外实现的友元函数" << p.name << " " << p.age << endl;
}

void test2()
{
	Maker<string, int> m("悟空",19);
	printMaker(m);
}

int main()
{
	
	test1();
	return EXIT_SUCCESS;
}

七、类模板实现数组

main.cpp

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include<string>
using namespace std;
#include"MyArray.hpp"
#include<string>

class Maker
{
public:

	Maker() {}

	Maker(string name, int age)
	{
		this->name = name;
		this->age = age;
	}

public:
	string name;
	int age;
};

void printMaker(MyArray<Maker>& arr)
{
	for (int i = 0; i < arr.getSize(); i++)
	{
		cout << "姓名" << arr[i].name << "年龄" << arr[i].age << endl;
	}
}

void test()
{
	MyArray<Maker> myarr(4);
	Maker m1("悟空",11);
	Maker m2("悟空1",11111);
	Maker m3("悟空2",1111);
	Maker m4("悟空3",111);
	myarr.Push_Back(m1);
	myarr.Push_Back(m2);
	myarr.Push_Back(m3);
	myarr.Push_Back(m4);

}

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

MyArray.hpp

#pragma once
template<class T>

class MyArray {
public:
	MyArray(int capacity)
	{
		this->mCapacity = capacity;
		this->mSize = 0;
		p = new T[this->mCapacity];// 创建数组空间
	}

	// 拷贝构造
	MyArray(const MyArray& arr)
	{
		this->mCapacity = arr.mCapacity;
		this->mSize = arr.mSize;
		p = new T[arr.mCapacity];// 开辟一个和arr 相同大小的数组

		// 然后开始复制数值
		for (int i = 0; i < this->mSize; i++)
		{
			p[i] = arr.p[i];
		}
	}

	// 赋值函数  重载赋值运算符
	MyArray& operator = (const MyArray& arr)
	{
		if (this->p != NULL)
		{
			delete[] this->p;
			this > p = NULL;
		}

		p = new T[arr.mCapacity];// 创建一个T类型的数组  数组长度就是arr的长度
		this->mSize = arr.mSize;
		this->mCapacity = arr.mCapacity;
		for (int i = 0; i < this->mSize; i++)
		{
			p[i] = arr.p[i];
		}

		return *this;
	}

	// 重载[]
	T& operator[](int index)
	{
		return this->p[index];
	}

	// 尾插
	void Push_Back(const T &val)
	{
		if (this->mSize == this->mCapacity)
		{
			return;
		}

		this->p[this->mSize] = val;
		this->mSize++;
	}

	// 尾删
	void Pop_back()
	{
		if (this->mSize == 0)
		{
			return;
		}

		this->mSize--;
	}

	// 析构函数
	~MyArray()
	{
		if (this->p != NULL)
		{
			delete[] p;
			p = NULL;
		}
	}

	int getSize()
	{
		return this->mSize;
	}

private:
	T* p;
	int mCapacity;
	int mSize;
};
少写代码少看论文多多睡觉
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
模板类笔记
Goodbye121的博客
07-19 114
类模板
C++STL学习笔记.pdf
05-23
关于学习C++《STL模板库》以及学习《STL源码剖析》的学习笔记。
C++之模板与泛型编程（下）：类模板
xjtuse2014的博客
04-24 319
在上一篇中，我们提到了函数模板，本文将来讲述一下类模板（class template）。 类模板是用来生成类的蓝图的。与函数模板不同的是，编译器不能为类模板推断模板参数类型。如我们在使用类的模板时，必须在模板名后的尖括号里提供额外的信息，用来代替模板参数的模板实参列表。1.定义类模板 类似函数模板，类模板以关键字template开始，后跟模板参数列表。在类模板（以及成员）的定义中，我们将模板参数
【大一程序设计基础作业】定义：类模板T_Counter，实现基本数据类型的+、-、*、=、＞＞、＜＜运算；类模板T_Counter 实现向量运算。
2301_77136128的博客
05-14 296
在当时的我眼中这就是个很玄学的问题了，因为别人的代码全篇能跑，但别人的函数单拿过来给我跑不了（其实这个时候就应该意识到不是这个重载运算符出问题了，但是由于删掉这一部分能完美地跑出结果，所以当时的我就一直纠结在这个地方）在这个地方几乎花了我写这个程序的90%时间……为了确认我是否也遇到了这个问题，我直接删掉了我的析构函数，果不其然，跑通了。事情是这样的，这份作业我写了不下6个小时，就是因为各种细节的错误，各种bug层出不穷，一个bug修完又出现新的bug，一次次的崩溃，最终还是磨出来了……
c++ .hpp文件及类模板
u012719076的博客
05-07 3333
由于.hpp是在.h中混入.cpp中的代码。hpp文件将定义和实现放在同一个文件，减少了文件的数量 如何创建hpp: 创建时使用.h 头文件，然后名称修改一下后缀为hpp即可。 hpp的特点 是Header Plus Plus 的简写。 与.h类似，hpp是C++程序头文件 。 是VCL 专用的头文件,已预编译。 是一般模板类的头文件。 一般将类模板定义为hpp类型的文件 一般来说， .h里面只有声明，没有实现，而.hpp里声明实现都有，后者可以减 少.cpp的数量。 .h里...
C++编程——类模板
热门推荐
professor_tao的博客
05-08 2万+
文章目录1 类模板语法2 类模板与函数模板的区别3 类模板中成员函数创建时机4 类模板对象做函数参数 1 类模板语法 类模板的作用：建立一个通用类，类中的成员数据类型可以不具体制定，用一个虚拟的类型来代表 语法： template<typename T> 类 解释： template声明创建模板 typename表明其后面的符号是一种数据类型，可以用class代替 T是通用的数据类型，名称可以替换，通常为大写字母 示例： //类模板 template<class NameType, cl
P167~184C++类和函数模板学习笔记.docx
04-13
P167~184C++类和函数模板学习笔记.docx
LearningNote:C++和Linux学习笔记
05-03
这个仓库中 、 是秋招过程中的总结，其余几个类别是学习过程中琐事总结。以下是自己学习过程中收集的视频资源： 后续更新： 学习路线 深入了解 Modern C++ 裸数组传入模板函数，退化还是不退化 auto与函数模板之推导...
C++学习笔记、常见面试知识点.zip
08-04
C++学习笔记和常见面试知识点，C++11特性，包括多态、虚表、移动语义、友元函数、符号重载、完美转发、智能指针、const和static、数组指针和指针数组、struct内存对齐、enum和union关键字等等。帮助了解C++的特性，...
C++学习笔记
01-18
C++学习笔记，基础知识和后边的高级部分，类，模板，异常等都有。
类模板的成员函数的类外实现 c++ 简单易懂
weixin_54907221的博客
07-10 308
#include<iostream> using namespace std; template<typename T1,typename T2> class person { public: person(T1 age, T2 name); void showperson(); T1 m_age; T2 m_name; }; template<typename T1,typename T2> person<T1,T2>::person(T1 age,
C++中的类模板（黑马程序员）
Bruce
09-17 1519
类模板
C++入门基础教程(八)：模板
总结论文中的算法并给出论文的复现代码
06-23 201
C++的另一种编程思想称为泛型编程，主要利用的技术就是模板，C++提供两种模板机制：函数模板和类模板。作用：建立一个通用函数，其函数返回值类型和形参类型可以不具体指定，用一个虚拟的类型来代表。
C++类模板成员函数类外实现
码云仓库地址：https://gitee.com/lance-gyq
02-24 250
学习目标：能够掌握类模板中成员函数类外实现 代码示例： #include<iostream> #include<string> using namespace std; //类模板成员函数类外实现 template<class T1,class T2> class Person { public: Person(T1 name, T2 age); //{ // this->m_Name = name;
15.2.6 类模板成员函数的类外实现
qq_32513033的博客
07-18 234
15.2.6 类模板成员函数的类外实现 技巧：任何时候，用到类模板，都需要指定T的数据类型。 所以在类外实现成员函数时，加作用域时用到了类模板，所以作用域后面要指定类型。 除此之外，参数列表也要指定类型。 #include <iostream> #include <string> using namespace std; template<class T1, class T2> class Person { public: Person(T1 name, T2 age
C++类模板的函数类外实现
weixin_46245201的博客
08-12 447
#include <iostream> using namespace std; #include<string> //2、类模板在模板参数列表中可以有默认参数 template<class NameType, class AgeType> class Person { public: //构造函数声明 Person(NameType name, AgeType age); //成员函数声明 void showInfo();
C++初学笔记“模板”：矩阵运算
qijinqichu的博客
04-05 2002
C++初学“模板”：矩阵运算 一道作业题，题目： （1）定义类模板T_Counter，实现基本类型数据的 + 、 - 、 * 、 = 、 >> 、 << 运算； （2）类模板T_Matrix，实现矩阵运算。 （题目要求很模糊，我为了少出点bug降低难度以交作业，都是写最简单的情况，其实最理想的应该就是写矩阵，n维向量，complex等都更实用） 先单看（2）的代码； 主函数： #include"T_Matrix.h" #include <iostream&gt
C++ hpp 文件
一得同学
06-06 1627
声明、定义和实现都包含在同一 hpp 文件
侯捷c++笔记stl
最新发布
08-13
STL（标准模板库）是C++的一个重要组成部分，它提供了一系列的模板类和函数，用于实现常用的数据结构和算法。 STL主要包括以下几个部分： 1. 容器（Containers）：包括向量（vector）、链表（list）、集合（set）、...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

少写代码少看论文多多睡觉

求打赏，求关注，求点赞

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值