day8-C++学习

最新推荐文章于 2024-10-17 15:47:06 发布
最新推荐文章于 2024-10-17 15:47:06 发布
阅读量471 收藏
点赞数 1
文章标签： c++ 学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/www_com_hwb/article/details/126838764
版权
本文深入探讨了C++中的模板技术，包括函数模板的基本用法、与普通函数的区别及调用规则，以及模板的局限性和解决方法。详细阐述了类模板的应用，如作为函数参数、遇到继承问题时的处理，以及类模板的成员函数实现和分文件编写。此外，还介绍了模板在友元函数和数组封装类中的应用，展示了模板在提高代码复用性和灵活性方面的强大能力。
摘要由CSDN通过智能技术生成

目录

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 <iostream>
#include <string>
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 <iostream>
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 <iostream>
#include <string>
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;
}
一条~咸鱼
关注
嵌入式学习-C++-Day2
weixin_51597107的博客
01-25 709
【代码】嵌入式学习-C++-Day2。
C++学习day--01 C生万物
我的博客
05-03 880
C++学习day--01 C生万物
sinx实现----c++学习day02
qq_44231964的博客
04-18 2025
题目如下：直接贴图片了（考研党时间有限，哈哈） 思路： 1、看到k后面r和s大小不同，对应不同的表达式，所以要用到if语句 2、由于多次出现sinx，所以把sinx功能封装 3、实现 #include<iostream> #include <cmath> using namespace std; const double value = 1e-10; //sin函数的实现sinx=x-x^3/3!+x^5/5!-x^7/7!+....... double tsin(double x
C++语言学习笔记Day1-C++概述
qq_44653420的博客
09-03 282
C++语言学习笔记Day1-C++概述
C++学习记录--day4
weixin_45922480的博客
06-06 160
思维导图：
C++学习记录--day1
weixin_45922480的博客
05-27 228
【代码】C++学习记录--day1。
21天学会C++：Day1----C++的发展史
m0_73096566的博客
04-14 840
21天学会C++：Day1
嵌入式学习-C++Day7&&QT Day1
m0_56018621的博客
02-19 696
【代码】嵌入式学习-C++Day7&&QT Day1。
C++学习day--04 图形化开发环境搭建
我的博客
05-04 2143
因为很多初学者学习C++就是单纯的控制台打印输出，很枯燥，我们今后在做项目或者在学习的过程中，采用图形化方式相结合的方法学习，再学习中体会编程带来的快乐。这个工具前面我们是不会用到，因为前面学习基础语法，不是做项目，等后面做项目，项目有多个版本，找出版本差异这时候这个工具就牛逼了。注意：一个解决方案里可以有多个项目，而每次只能运行一个项目，我们运行某个指定的项目就得把该项目设置为启动项目。案例：南京研究所，某卫星通信项目的芯片移植，进度严重受阻，被迫更换芯片。做任何有难度的项目，必定会遇到困难，甚至瓶颈。
回文数判断---c++学习day01
qq_44231964的博客
04-17 786
1、输入一个数，判断是不是回文数 //判断回文数 #include<iostream> using namespace std; bool symm(unsigned n) { unsigned i = n; unsigned m = 0; while (i>0) { m=m*10+i % 10;//翻转之后的数 i /= 10; } return m == n;//如果相等就是回文 } int main() { unsigned testnum; cin >&
day1-code.rar_达内_达内 c++_达内培训
09-24
综上所述，这个压缩包"day1-code.rar"对于想要学习或复习C++编程的人来说是一个宝贵的资源。它提供了达内教育的专业指导，可以帮助学习者逐步理解C++的基本概念、语法规则，并通过实践加深对编程的理解。无论是初学...
great-day-personal-use.zip_C++_personal
09-23
【标题】"great-day-personal-use.zip" 是一个与C++编程语言相关的个人项目压缩包。这个项目的重点可能在于利用C++开发一个...对于学习者来说，这是一个深入了解C++编程、实践面向对象设计以及提升个人技能的好机会。
[学习笔记-C++篇]day10 标准库-实例
warningm_dm的博客
03-14 1171
c++复习训练
C++，STL 028（24.10.11）
Erif_Liu的博客
10-12 237
利用sort排序算法来对deque容器进行排序。
如何用c++模拟创建用户（只得创建一个用户）
2301_78863827的博客
10-14 776
模拟系列，希望大家能多提意见
C语言内存函数
L73S37的博客
10-13 446
对于重叠内存，用memmove来实现。
【C语言】指针与函数：传值与传址
最新发布
我的我的博客
10-17 495
函数在使用的时候，给到的形式参数属于局部变量，仅在函数体内部有效。 1. 传值，对于两个值的交换，不影响函数调用之前的数值。这个就是传值，传递的是实参。 2. 传址，如果想通过函数来改变原本两个变量的值，那么需要传递地址。 3. 另外一种方式就是定义**全局变量**，参数不进行传递。可以直接实现在自定义函数体内，改变main函数中、或者其他函数中的值。
C++文档数据保存与解析
一个大佬的博客
10-12 364
【代码】C++文档数据保存与解析。
C++ 中的自旋锁应用：SpinLockManual、SpinLockGuard 和 SpinLockTryGuard
极地星辰
10-13 342
在多线程编程中，同步机制是确保线程安全的关键。自旋锁（Spin Lock）是一种常见的同步机制，它通过忙等待（busy-waiting）的方式来实现线程间的互斥访问。在 C++ 中，我们可以使用 `std::atomic_flag` 来实现自旋锁。本文将介绍如何使用 `SpinLockManual`、`SpinLockGuard` 和 `SpinLockTryGuard` 这三个类来应用自旋锁。
Sams Teach Yourself C++ in One Hour a Day - 第6版
这本书遵循“在一天一小时”的学习理念，旨在帮助读者在21天内掌握C++编程的基础知识和进阶技能。 C++是一种通用的、面向对象的编程语言，由Bjarne Stroustrup于1983年创建，是C语言的增强版。C++不仅保留了C语言的...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值