投稿
  1. 首页
  2. C

day8-C++学习

鸦片玫瑰 • 2022-9-14 • C • 阅读 21

day8-C++学习,第1张

目录
    • 1.函数模板的基本用法
    • 2.函数模板与普通函数的区别以及调用规则
    • 3.模板局限性
    • 4.类模板的基本使用
    • 5.类模板做函数的参数
    • 6.类模板碰到继承的问题
    • 7.类模板类外实现成员函数
    • 8.类模板的分文件编写问题以及解决
    • 9.类模板碰到了友元函数-类内/类外实现
    • 10.类模板的应用-数组类封装

1.函数模板的基本用法

下面两个函数，除了变量类型不同之外，它们的逻辑非常相似

//交换int类型两个数字
void mySwapInt(int& a, int& b)
{
	int temp = a;
	a = b;
	b = temp;
}

//交换double类型两个数字
void mySwapDouble(double& a, double& b)
{
	double temp = a;
	a = b;
	b = temp;
}

为了不必定义多个函数，可以将类型参数化，也就是泛型编程——模板技术

//函数模板写法：template < class / typename  T> 

template<class T>//告诉编译器，下面如果出现T不要报错，T是一个通用的类型
void mySwap(T& a, T& b)
{
	T temp = a;
	a = b;
	b = temp;
}

template<typename T>
void mySwap2(){}


//调用时有两种方式
void test()
{
	int a = 110;
	int b = 220;
	char c1 = 'c';

	//1.自动类型推导，必须有参数类型才可以推导
	//mySwap(a, c1);推导不出来T，不能运行
	mySwap(a, b);

	//2.显示指定类型
	mySwap<int>(a, b);

	//模板必须要指定T才可以使用
	mySwap2<double>();
}
2.函数模板与普通函数的区别以及调用规则 
//1.普通函数与函数模板的区别
template<class T>
T myPlus(T a, T b)
{
	return a + b;
}

int myPlus2(int a, int b)
{
	return a + b;
}

void test()
{
	int a = 10;
	int b = 20;
	char c = 'c';//a=97 c=99
	//myPlus(a, c);//类型推导不出来，函数模板不可以进行隐式类型转换
	cout << myPlus2(a, c) << endl;//10+99  普通函数可以进行隐式类型转换
}

//2.普通函数和函数模板的调用规则
template<class T>
void myPrint(T a, T b)
{
	cout << "模板调用的myPrint" << endl;
}

template<class T>
void myPrint(T a, T b,T c)
{
	cout << "模板调用的myPrint(a,b,c)" << endl;
}

void myPrint(int a, int b)
{
	cout << "普通函数调用的myPrint" << endl;
}

void test2()
{
	int a = 10;
	int b = 20;
	//1.如果出现重载，优先使用普通函数调用，如果普通函数没有实现，会出现错误
	myPrint(a, b);

	//2.如果想强制调用模板，那么可以使用空参数列表
	myPrint<>(a, b);

	//3.函数模板也可以发生重载
	int c = 30;
	myPrint(a, b, c);

	//4.如果函数模板可以产生更好匹配，那么优先调用函数模板
	char e = 'e';
	char d = 'd';
	myPrint(e, d);
}

模板的机制
——模板并不是万能的，不能通用所有的数据类型；
——模板不能直接调用，生成后的模板函数才可以调用；
——二次编译，第一次对模板进行编译，第二次对替换T类型后的代码进行二次编译。

3.模板局限性

模板不能解决所有的类型，如果出现不能解决的类型，可以通过第三地具体化来解决问题

//自定义数据类型
class Person
{
public:
	Person(string name, int age)
	{
		this->m_name = name;
		this->m_age = age;
	}
	string m_name;
	int m_age;
}; 

template<class T>
bool myCompare(T& a, T& b)
{
	if (a == b)
	{
		return true;
	}
	return false;
}

void test()
{
	int a = 10;
	int b = 20;
	int ret = myCompare(a, b);

	cout << "ret = " << ret << endl;//0

	Person p1("Tom", 18);
	Person p2("Jerry", 16);

	int ret2 = myCompare(p1, p3);
	cout << "ret2 = " << ret2 << endl;//报错
}


//通过第三代具体化自定义数据类型，解决上述问题
//如果具体化能够优先匹配，那么就选择具体化
//语法：template<> 返回值 函数名<具体类型>(参数)
template<> bool myCompare<Person>(Person& a, Person& b)
{
	if (a.m_age == b.m_age && a.m_name == b.m_name)
	{
		return true;
	}
	return false;
}

void test()
{
	int a = 10;
	int b = 20;
	int ret = myCompare(a, b);

	cout << "ret = " << ret << endl;

	Person p1("Tom", 18);
	Person p2("Jerry", 16);
	Person p3("Tom", 18);

	int ret2 = myCompare(p1, p3);
	cout << "ret2 = " << ret2 << endl;//1
}
4.类模板的基本使用

类模板的写法是template后面紧跟着类

template <class NameType,class AgeType = int>//类模板可以有默认类型
class Person
{
public:
	Person(NameType name, AgeType age)
	{
		this->m_name = name;
		this->m_age = age;
	}

	void showPerson()
	{
		cout << "姓名：" << this->m_name << " 年龄：" << this->m_age << endl;
	}

	NameType m_name;
	AgeType m_age;
};


void test()
{
	//自动类型推导，类模板不支持
	//Person p("孙悟空", 500);

	//显示指定类型
	Person<string, int> p("孙悟空", 500);
	p.showPerson();
}

class Person1
{
public:
	void showPerson1()
	{
		cout << "Person1的调用" << endl;
	}

};

class Person2
{
public:
	void showPerson2()
	{
		cout << "Person2的调用" << endl;
	}

};

template <class T>
class myClass
{
public:
	T obj;
	void func1()
	{
		obj.showPerson1();
	}

	void func2()
	{
		obj.showPerson2();
	}
};

//成员函数一开始不会创建出来，而是在运行时才会去创建
void test1()
{
	myClass<Person1> m;
	m.func1();

	myClass<Person2> p;
	p.func2();
}
5.类模板做函数的参数 
template <class NameType, class AgeType = int>//类模板可以有默认类型
class Person
{
public:
	Person(NameType name, AgeType age)
	{
		this->m_name = name;
		this->m_age = age;
	}

	void showPerson()
	{
		cout << "姓名：" << this->m_name << " 年龄：" << this->m_age << endl;
	}

	NameType m_name;
	AgeType m_age;
};

1.指定传入类型

void doWork(Person<string, int>& p)
{
	p.showPerson();
}

void test()
{
	Person<string, int> p("MT", 100);
	doWork(p);
}

2.参数模板化

template <class T1,class T2>
void doWork2(Person<T1, T2> & p)
{
	//如何查看类型
	cout << typeid(T1).name() << endl;
	cout << typeid(T2).name() << endl;
	p.showPerson();
}

void test2()
{
	Person<string, int> p("呆头", 13);
	doWork2(p);
}

3.整体模板化

template<class T>
void doWork3(T& p)
{
	cout << typeid(T).name() << endl;
	p.showPerson();
}

void test3()
{
	Person<string, int> p("阿衰", 12);
	doWork3(p);
}
6.类模板碰到继承的问题

基类如果是模板类，必须让子类告诉编译器基类中的T到底是什么类型
如果不告诉，那么无法分配内存，编译不过

 template <class T>
 class Base
 {
 public:
	 T m_a;//double类型
 };

 //child继承base，必须告诉base中的T的类型，否则T无法分配内存
 class Child :public Base<int>
 {

 };

//Child2也是模板类
 template <class T1,class T2>
 class Child2 :public Base<T2>
 {
 public:
	 Child2()
	 {
		 cout << typeid(T1).name() << endl;
		 cout << typeid(T2).name() << endl;
	 }
	 T1 m_b;//int类型
 };

 void test()
 {
	 Child2<int, double> child;//由用户来指定类型
 }
7.类模板类外实现成员函数 
template <class T1,class T2>
class Person
{
public:
	Person(T1 name, T2 age);

	void showPerson();

	T1 m_name;
	T2 m_age;
};

//类外实现成员函数
template <class T1,class T2>
Person<T1, T2>::Person(T1 name, T2 age)
{
	this->m_name = name;
	this->m_age = age;
}

template <class T1, class T2>
void Person<T1, T2>::showPerson()
{
	cout << "姓名：" << this->m_name << " 年龄：" << this->m_age << endl;
}
8.类模板的分文件编写问题以及解决

建立.h和.cpp文件分别写声明和实现
但是由于类模板的成员函数运行阶段才去创建，导致包含.h头文件，不会创建函数的实现，无法解析外部命令
所以不要进行分文件编写，写到同一个文件中，进行声明和实现，将.h文件的后缀名改为.hpp

#pragma once
#include 
#include 
using namespace std;

template <class T1,class T2>
class Person
{
public:
	Person(T1 name,T2 age);

	void showPerson();

	T1 m_name;
	T2 m_age;
};

template <class T1,class T2>
Person<T1, T2>::Person(T1 name,T2 age)
{
	this->m_name = name;
	this->m_age = age;
}

template <class T1, class T2>
void Person<T1, T2>::showPerson()
{
	cout << "姓名：" << this->m_name << "  年龄：  " << this->m_age << endl;
}
9.类模板碰到了友元函数-类内/类外实现 
template <class T1,class T2>
class Person
{
	//友元函数类内实现
	friend void printPerson(Person<T1,T2> & p)
	{
		cout << "姓名：" << p.m_Name << " 年龄：" << p.m_Age << endl;
	}
public:
	Person(T1 name, T2 age)
	{
		this->m_Name = name;
		this->m_Age = age;
	}

private:
	T1 m_Name;
	T2 m_Age;
};

//让编译器看到Person类声明
template <class T1, class T2> class Person;
//让编译器提前看到printPerson声明
template <class T1, class T2> void printPerson(Person<T1, T2>& p);

template <class T1, class T2>
class Person
{
	//友元函数类内实现 ,利用空参数列表告诉编译器，这是模板函数声明
	friend void printPerson<>(Person<T1, T2>& p);//不加<>是普通函数声明

public:
	Person(T1 name, T2 age)
	{
		this->m_Name = name;
		this->m_Age = age;
	}

private:
	T1 m_Name;
	T2 m_Age;
};

//类外实现
template <class T1,class T2>
void printPerson(Person<T1, T2>& p)
{
	cout << "姓名：" << p.m_Name << " 年龄：" << p.m_Age << endl;
}
10.类模板的应用-数组类封装

.hpp文件

#pragma once
#include 
using namespace std;

template <class T>
class MyArray
{
public:
	//构造
	explicit MyArray(int capacity)//防止隐式类型转换 防止MyArray arr = 10写法
	{
		this->m_Capacity = capacity;
		this->m_Size = 0;
		this->pAddress = new T[this->m_Capacity];
	}

	MyArray(const MyArray& array)
	{
		this->m_Capacity = array.m_Capacity;
		this->m_Size = array.m_Size;
		this->pAddress = new T[this->m_Capacity];
		for (int i = 0; i < m_Size; i++)
		{
			this->pAddress[i] = array[i];
		}
	}

	~MyArray()
	{
		if (this->pAddress != NULL)
		{
			delete[] this->pAddress;
			this->pAddress = NULL;
		}
	}

	//赋值 *** 作符重载
	MyArray& operator=(MyArray & array)
	{
		//先判断原始数据，有就清空
		if (this->pAddress != NULL)
		{
			delete[] this->pAddress;
			this->pAddress = NULL;
		}
		this->m_Capacity = array.m_Capacity;
		this->m_Size = array.m_Size;
		this->pAddress = new T[this->m_Capacity];
		for (int i = 0; i < m_Size; i++)
		{
			this->pAddress[i] = array[i];
		}
	}

	//[]重载
	//MyArray arr(10);
	//arr[0] = 100;
	T& operator[](int index)
	{
		return this->pAddress[index];
	}

	//尾插法
	void push_Back(T val)
	{
		this->pAddress[this->m_Size] = val;
		this->m_Size++;
	}

	//获取大小
	int getSize()
	{
		return this->m_Size;
	}
	//获取容量
	int getCapacity()
	{
		return this->m_Capacity;
	}

private:
	T* pAddress;//指向堆区的指针
	int m_Capacity;//容量
	int m_Size;//大小
};

.cpp文件

#define _CRT_SECURE_NO_WARNINGS
#include 
#include 
using namespace std;
#include "MyArray.hpp"

//输出int类型数组
void printIntArray(MyArray<int>& array)
{
	for (int i = 0; i < array.getSize(); i++)
	{
		cout << array[i] << endl;
	}
}

class Person
{
public:
	Person() {};

	Person(string name, int age)
	{
		this->m_Name = name;
		this->m_Age = age;
	}
	string m_Name;
	int m_Age;
};

//输出Person类型数组
void printPersonArray(MyArray<Person>& array)
{
	for (int i = 0; i < array.getSize(); i++)
	{
		cout << "姓名： " << array[i].m_Name << " 年龄： " << array[i].m_Age << endl;
	}
}

int main()
{
	MyArray <int >arr(10);
	for (int i = 0; i < 10; i++)
	{
		arr.push_Back(i + 100);
	}
	printIntArray(arr);

	Person p1("MT", 10);
	Person p2("呆贼", 12);
	Person p3("傻馒", 14);
	Person p4("劣人", 15);

	MyArray<Person>arr2(10);
	arr2.push_Back(p1);
	arr2.push_Back(p2);
	arr2.push_Back(p3);
	arr2.push_Back(p4);

	printPersonArray(arr2);

	system("pause");
	return 0;
}

欢迎分享，转载请注明来源：内存溢出

原文地址: http://outofmemory.cn/langs/2889261.html

赞 (0)
打赏 微信扫一扫 微信扫一扫 支付宝扫一扫 支付宝扫一扫
鸦片玫瑰 鸦片玫瑰 一级用户组
0 0
上一篇 2022-09-14
下一篇 2022-09-14

发表评论

登录后才能评论

评论列表（0条）

保存