C++提高编程

于 2022-05-04 11:19:04 发布
阅读量91 收藏
点赞数
分类专栏： C++ 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44000605/article/details/124567844
版权

1、c++中的编程思想
(1)面向对象编程
(2)泛型编程：主要是利用技术模板进行编程的
2、模板
(1)特点
①不可以直接使用，它只是一个框架
②模板的通用性不是万能的，即一个模板并不是使用所以的场合
(2)函数模板
①模板目的，提高代码的复用性，将类型参数化，使用的时候再确定具体类型

//函数模板 数据类型很多，若没有模板，则实现两个数交换，则需写很多函数
// 模板目的，提高代码的复用性，将类型参数化
//函数模板
template<typename T>//这里的typaname可以用class代替
//声明一个模板，告诉编译器后面代码中紧跟的T不要报错，T是一个通用的数据类型
void mySwap(T& a, T& b) {
	T temp = a;
	a = b;
	b = temp;
}
void test() {
	int a = 10;
	int b = 30;
	//利用函数模板进行交换
	//两种使用方式
	1、自动推导类型 //必须推导出一致的数据类型T方可使用
//（而模板也是要确定数据类型T才可使用的）
	//mySwap(a, b);
	//2、显示指定类型(用尖括号)
	mySwap<int>(a, b);

②自动类型推导，必须推导出一致的数据类型T才可以使用

void test01() {
	int a = 10;
	int b = 20;
	char c = 'c';
	//mySwap(a, c);//推导出T不一致，错误
	mySwap(a, b);
}

③模板必须要确定出T的数据类型，才可以使用

template<class T>
void func()
{
	cout << "func 调用" << endl;
}

void test02() {
	//func();//调用错误，因函数中没有使用到T，无法推出T的类型
	func<int>();
}

(3)普通函数和函数模板的区别
①普通函数调用时，可以发生隐式类型转换的（如下例）

//普通函数
int myAdd(int a, int b)
{
	return a + b;
}
void test05()
{
	int a = 10;
	int b = 10;
	char c = 'c';
	cout << myAdd(a, c) << endl;
	//这里本来是要传入两个int型的，而c是char型，所以会进行隐式类型转化，将c以其ASCLL码呈现
}

②函数模板
1)用自动类型推导时，不可以发生隐式类型转换
2)用显示指定类型，可以发生隐式类型转换（故一般使用函数模板的时候，用显示指定类型）
③普通函数与函数模板调用规则
// 1、如果函数模板和普通函数都可以调用，优先调用普通函数
// 2、可以通过空模板参数列表 强制调用 函数模板，如Myprint<>(a, b,b);
// 3、函数模板可以发生函数重载
// 4、如果函数模板可以产生更好的匹配，优先调用函数模板
// （如普通函数需要进行数据类型强制转化《char 型转为int型》，而函数模板不需要的时候）

(4)函数模板的局限性
//模板不是万能的，如自自定义类型，写代码的时候不会报错，但在运行时会报错
// 解决方法：利用具体化的模板（也即针对自定义类型具体化）,解决自定义类型的通用化
//学习模板不是为了写模板，而是在STL能够运用系统提供的模板

//模板代码，不适用于自定义类型数据，因自定义类型没有==的定义
 //解决方法：1、具体化模板类
 //2、当然也可以重载==，对该自定义类型下的==进行定义
template<class T>
bool ifEqual(T a, T b) {
	if (a==b)
	{
		return true;
	}
	else
	{
		return false;
	}
}
//利用具体化Person的版本实现代码，具体化优先调用
template<>bool ifEqual(Person a, Person b) {
	if (a.m_Name==b.m_Name && a.m_age==b.m_age)
	{
		return true;
	}
	else
	{
		return false;
	}
}
void test08()
{
	Person p1("deng", 11);
	Person p2("deng", 11);
	if (ifEqual(p1, p2))
	{
		cout << "a = b" << endl;
	}
	else
	{
		cout << "a != b" << endl;
	}
}

3、类模板
(1)和函数模板的差不过，只不过template后面是一个类

template<class NameType,class AgeTye>//多个参数也一样
class Person
{
public:
	Person(NameType name,AgeTye age) {
		this->m_Name = name;
		this->m_Age = age;
	}
	void showM() {
		cout << "姓名：" << this->m_Name << endl;
		cout << "年龄：" << this->m_Age << endl;
	}
	NameType m_Name;
	AgeTye m_Age;
};

void test01() {
	Person<string, int> p1("deng", 12);
//创建对象的时候需要声明参数列表，不能自动类型推导，只能用显示指定类型
	p1.showM();
}

(2)类模板和函数模板的区别
①类模板无自动类型推导
②类模板在模板参数列表中可以有默认参数

template<class NameType,class AgeTye=int>//第二个参数用类默认类型
class Person
{
public:
	Person(NameType name,AgeTye age) {
		this->m_Name = name;
		this->m_Age = age;
	}
	NameType m_Name;
	AgeTye m_Age;
};
void test01() {
	Person<string> p1("deng", 12);
	//创建对象的时候需要声明参数列表，不能自动推导
	//类模板可使用默认类型，故这里声明参数列表时，第二个参数使用的是默认参数列表
}

(3)类模板中成员函数和普通类中的成员函数创建时机
①普通类，一开始就可以创建了
②模板类：成员函数在调用时才创建（故成员函数内部有类型出错，只有调用的时候才能发现，若每调用，则无法发现该错误）
(4)类模板对象做函数参数

//类模板对象作为一个函数的参数
//1、指定传入类型（一般用这种）
// 2、参数模板化
// 3、整个类模板化
template<class T1,class T2>
class Person1
{
public:
	Person1(T1 name, T2 age) {
		m_name = name;
		m_age = age;
	}
	void showPerson1()
	{
		cout << "姓名：" << this->m_name << endl;
		cout << "年龄：" << this->m_age << endl;
	}
	T1 m_name;
	T2 m_age;
};
//1、指定传入参数类型
void printMyclass01(Person1<string,int>&p) {
	p.showPerson1();
}
//2、参数模板化
template<class T1,class T2>
void printMyclass02(Person1<T1,T2>&p) {
	p.showPerson1();
}
//3、类模板化
template<class T>
void printMyclass03(T& p) {
	p.showPerson1();
}

void test02() {
	Person1<string,int> p("deng", 12);
printMyclass01(p);
printMyclass02(p);
	printMyclass03(p);
}

(5)类模板与继承
//类模板与继承
//当子类继承的父类是一个类模板的时候，子类在声明的时候，要指定出父类中T的类型
//如果不指定，无法给子类分配内存（这样，子类中父类元素的T类型就固定死了）
//如果想灵活指定出父类中的T类型，子类也需变为类模板

template<class T>
class Base
{
public:
	T m_obj1;
};
//1、指定父类中T的类型
class son:public Base<int>
{
};
//2、为灵活，将子类也模板化
template<class T1,class T2>
class son1:public Base<T1>
{
public:
	son1(T1 obj1, T2 obj2) {
		this->m_obj1 = obj1;
		this->m_obj2 = obj2;
		cout << typeid(T1).name() << endl;//输出T1代表的类型
	}
	T2 m_obj2;
};
void test03()
{
	son1<string,int> s("ren",12);	
}

(6)类模板成员函数的类外实现
// 1、在类外实现，加上类模板声明，如template<class T1，class T2>
//2、在作用域后面，加上参数列表,如void Person<T1,T2>::showPerson()
//上述两个步骤在所有成员函数的类外实现都要加上的，不管有没有使用到该参数，
//用以声明这个是类模板的成员函数，包括构造函数、析构函数

template<class T1,class T2>
class Person2
{
public:
	Person2(T1 name,T2 age);
	void showPerson();
	T1 m_name;
	T2 m_age;

};
template<class T1, class T2>				//加上类模板声明
Person2<T1,T2>::Person2(T1 name, T2 age)	//作用域后面，加上参数列表
{
	m_name = name;
	m_age = age;
}
template<class T1, class T2>				//加上类模板声明
void Person2<T1,T2>::showPerson() {			//作用域后面，加上参数列表
	cout << "姓名：" << m_name << endl;
	cout << "年龄：" << m_age << endl;
}

(7)类模板分文件编写
①问题：由于类模板的创建时机是在调用阶段，导致分文件填写时链接不到
1)也即在调用文件（.cpp）引入Person.h时，没有导入Person.cpp
②解决方法
1)直接在调用文件中导入Person.cpp,也即#include”Person.cpp”，而Person.cpp中有导入Person.h的（该法较少用）
2)将该模板类的声明和实现写到同一个文件中，并将文件后缀改为.hpp，如Person.hpp，该后缀是约定的名称，并不是强制的，用于表示模板类的

(8)类模板与友元
①建议全局函数（友元）做类内实现，用法简单，而且编译器可以直接识别
②友元函数类外实现较为复杂

//通过全局函数，打印Person信息
template<class T1, class T2>
class Person4;//由于showPerson中用到Person4，所以需要在前面声明一下Person4

//2、全局函数类外实现
template<class T1, class T2>
void showPerson(Person4<T1, T2>p) {//由于是全局函数，所以不用写作用域
	cout << "姓名：" << p.m_Name << endl;
	cout << "年龄：" << p.m_Age << endl;
}

template<class T1,class T2>
class Person4
{
	1、全局函数类内实现
	//friend void showPerson(Person4<T1,T2>p) {
	//	cout << "姓名：" << p.m_Name << endl;
	//	cout << "年龄：" << p.m_Age << endl;
	//}

	//2、全局函数类外实现
	// 加空模板参数列表
	// 如果全局函数类外实现，需要让编译器提前知道这个函数的存在
	//friend void showPerson(Person4<T1, T2>p);//这样只是一个普通函数的声明，和下方函数模板的实现无法链接起来，需加空的参数列表
	friend void showPerson<>(Person4<T1, T2>p);//加了空参数列表
	
public:
	Person4(T1 name,T2 age) {
		this->m_Name = name;
		this->m_Age = age;
	}
private:
	T1 m_Name;
	T2 m_Age;
};
void test06() {
	Person4<string,int> p("feng",12);
	showPerson(p);
}

4、注意：
(1)防止浅拷贝的问题（堆区数据问题）
①设置拷贝构造函数
②重载等号，operator=

C++ 提高编程
m0_56069948的博客
02-19 404
Python微信订餐小程序课程视频 https://edu.csdn.net/course/detail/36074 Python实战量化交易理财系统 https://edu.csdn.net/course/detail/35475 目录* C++ 提高编程 + 一、 模板 - 1、 概念 - 2、 函数模板 * 2.1 函数模板语法 * 2.2 注意事项 * 2.3 普通函数和函数模板的区别 * 2.4 普通函数和函数模板的调用规则 * 2.5 模板的局限性 - 3、 类模板 * 3.1 类模板语法 *
程序员C++提高编程PDF.pdf
07-24
在黑马程序员的《程序员C++提高编程PDF》讲义中，特别针对泛型编程和STL技术进行了详细讲解，这表明了模板在C++编程中的重要性。 首先，讲义介绍了模板的基本概念，这可以通过生活中的模板类比来理解。模板就像是一...
C++提高编程C++提高编程.md
04-10
C++提高编程C++提高编程.md
黑马程序员匠心之作 C++教程_第5阶段-C++提高编程资料讲义.rar
03-19
《黑马程序员匠心之作 C++教程_第5阶段-C++提高编程资料讲义》是一份针对C++编程初学者精心制作的教程资料，旨在帮助学习者深入理解和提升C++编程技能。这份讲义涵盖了许多关键的C++知识点，下面将对其进行详细解读...
C++提高编程讲义.zip
02-05
这份"C++提高编程讲义"旨在帮助中级或高级C++程序员深化对语言的理解，提升编程技巧。讲义可能包含了以下几个核心主题： 1. **面向对象编程（OOP）**：C++是面向对象的语言，讲义可能会深入讨论类、对象、继承、...
C++提高编程 C++提高编程
最新发布
12-14
C++提高编程 C++提高编程
c++提高编程
GitHub：https://github.com/myp020301
10-23 136
C++提高编程 1 模板 1.1 模板的概念 模板就是建立通用的模具，大大提高复用性 例如生活中的模板 一寸照片模板： PPT模板： 模板的特点： 模板不可以直接使用，它只是一个框架 模板的通用并不是万能的 1.2 函数模板 C++另一种编程思想称为 泛型编程 ，主要利用的技术就是模板 C++提供两种模板机制:函数模板和类模板 1.2.1 函数模板语法 函数模板作用： 建立一个通用函数，其函数返回值类型和形参类型可以不具体制定，用一个虚拟的类型来代表。 语法： template<type
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值