C++入门2(缺省参数 inline函数 函数重载 函数模板 类模板)

已于 2023-06-24 11:43:25 修改
阅读量729 收藏
点赞数
分类专栏： C++ 文章标签： c++ 开发语言
于 2023-05-01 22:08:14 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_61785714/article/details/130459399
版权
本文介绍了C++中的缺省参数，详细阐述了如何定义和使用，以及调用时的规则。接着讨论了inline函数的概念，用于提高效率，同时对比了内联函数与宏定义的区别。此外，还讲解了函数重载的基本原理和名字粉碎技术，以及C++中的函数和类模板，展示了如何利用模板实现泛型编程。
摘要由CSDN通过智能技术生成

C++入门2

缺省参数

定义

一般情况下，函数调用时的实参个数应与形参相同，如果不同，就会出错，为了不出错可以定义具有缺省参数的函数，这种函数调用时，实参个数可以与形参不相同。
这样函数在调用时，可以给出实参值，也可以不给出参数值。如果给出实参，将实参传递给形参进行调用，如果不给出实参，则按缺省值进行调用。即按照默认值处理

缺省参数的函数调用

函数定义时，缺省值赋值是从右向左依次赋值
调用函数时，从左向右依次给实参值，不能跳

void func(int a=0,int b=0,int c=0){
	printf("a=%d,\n b=%d\n c=%d\n",a,b,c);
}
int main(){
	func(1,2,3);
	return 0;
}

结合优先级

如果是普通变量，优先结合普通指针，么有普通指针，退而求其次，和指向常量的指针结合，这样的话，只能读取，不能修改
如果是常变量，优先结合常性指针，没有此函数，编译器无法通过，不能和普通指针结合，应为是常量，不能用普通指针取修改

#include<iostream>
using namespace std;
void func(int* p){}
void func(const int* p){}
int main(){
	int a=10;
	func(&a);//如果没有void func(int* p){}，就会调用void func(const int* p){}
	const int b=20;
	func(&b);//如果没有void func(const int* p){},无法调用报错
}

#include<iostream>
using namespace std;
void func(int& p){}
void func(const int& p){}
int main(){
	int x=10;
	func(x);//调用void func(int& p){}，如果没有，退而求其次和void func(const int& p){}结合
	const int y=10;
	func(y);//调用void func(const int& p){}，如果没有,无法通过，因为y是常性，不能修改，而void func(int& p){}可以修改
	func(10);//和他结合void func(const int& p){}
	return 0;
}

inline函数

当程序执行函数调用时，系统要建立栈空间，保护现场，传递参数以及控制程序执行的转移等等,这些工作需要系统时间和空间的开销。
加inline关键字将其改成内联函数，在编译期间编译器能够在调用点内联展开该函数。
当函数功能简单，使用频率很高，为了提高效率，直接将函数的代码嵌入到程序中。但这个办法有缺点，一是相同代码重复书写，二是程序可读性往往没有使用函数的好。
为了协调好效率和可读性之间的矛盾，C++提供了另一种方法，即定义内联函数，方法是在定义函数时用修饰词inline。
需要设置

vs中的测试实例

#include<iostream>
using namespace std;
inline int add(int a, int b) {
	return a + b;
}
int main(){
	int a = 10, b = 20;
	int sum=add(a, b);
	return 0;
}

在这里插入图片描述
在这里插入图片描述

inline函数要点

inline是一种以空间换时间的做法，省去调用函数额开销。但当函数体的代码过长或者是递归函数即便加上inline关键字，也不会在调用点以内联展开该函数。
inline不建议声明和定义分离，分离会导致链接错误。因为inline被展开，就没有函数地址了，链接就会找不到。
如果函数的执行开销小于开栈清栈开销(函数体较小)，使用inline处理效率高。如果函数的执行开销大于开栈清栈开销，使用普通函数方式处理。

内联函数与宏定义区别:

内联函数在编译时展开，带参的宏在预编译时展开。
内联函数直接嵌入到目标代码中，带参的宏是简单的做文本替换。
内联函数有类型检测、语法判断等功能，宏只是替换。

函数重载

定义

在C++中可以为两个或两个以上的函数提供相同的函数名称，只要参数类型不同，或参数类型相同而参数的个数不同，称为函数重载。
函数重载的依据是参数列表，即参数个数不同，参数类型不同
函数在编译的时候就确定了调用关系，即早期绑定


int my_max(int a,int b){return a>b?a:b;}
double my_max(double a,double b){return a>b?a:b;}
char my_max(char a,char b){return a>b?a:b;}
int main(){
	int x=my_max(12,34);//在编译的时候，就识别出整型，小数，字符
	double dx=my_max(12.23,9.12);
	char ch=my_max('a','b');//识别出字符是因为通过定界符 ' '识别
}

名字粉碎技术

编译器在编译的过程中，进行了名字的重命名，参数类型成为名字的一部分，所以可以区分，可以重载
c语言名字粉碎技术只是在函数名前面加了下划线，而c++的名字粉碎技术将函数的返回类型，和形参类型作为函数名的一部分
c语言不能进行函数重载，c++有名字粉碎技术

#include<iostream>
using namespace std;
void func(int a);
void func(int a, int b);
int main() {
	int x = 10;
	func(x);
	return 0;
}

错误 LNK2019 无法解析的外部符号 “void __cdecl func(int)” (?func@@YAXH@Z)，函数 _main 中引用了该符号
@@YA c调用规则
X 无类型的缩写
H 参数类型的缩写
@Z 名字的结束

__cdecl c调用规则
__stdcall 回调调用规则
__fastcall 快速调佣规则
thiscall

C语言的名字修饰规则非常简单，_cdecl是C/C++的缺省调用方式,调用约定函数名字前面添加了下划线前缀，格 式:_functionname
在这里插入图片描述
_stdcall调用约定在输出函数名前加上一个下划线前缀，后面加上一个"@“符号和其参数的字节数。格式: _functionname@number;
在这里插入图片描述
_fastcall 调用约定在输出函数名前加上一个”@“符号，函数名后面也是一个”@"符号和其参数的字节数，
格式为:@functionname@number
在这里插入图片描述

C++编译时函数名修饰约定规则

__cdecl调用约定:
1、以?“标识函数名的开始，后跟函数名;
2、函数名后面以”@@YA"标识参数表的开始，后跟参数表;
3、参数表的第一项为该函数的返回值类型，其后依次为参数的数据类型,指针标识在其所指数据类型前;
4、参数表后以"@卫"标识整个名字的结束，如果该函数无参数，则以"Z"标识结束。

//(?my_max@@YAHHHQZ)
int my_max(int a，int b);
//(?my_max@@YADDD@z)
char my_max(char a，char b) ;
//(?my_max@@YANNN@z)
double my_max (doub1e a，doub1e b);
int main(
{
		my_max(12，23);
		my_max('a', 'b ');
		my_max(12.23，34.45);
		return 0;
}

关键字:
extern “C” :函数名以C的方式修饰约定则;
extern "C++” :函数名以C++的方式修饰约定规则;

该编译无法通过

extern "C"
{ 
//_Add
int Add (int a,int b) { return a + b; }
//_Add
double Add(double a,double b) 
{ 
	return a + b; 
}
}

这样就可以编译通过

extern "C++"
{ 
//
int Add (int a,int b) { return a + b; }
//
double Add(double a,double b) 
{ 
	return a + b; 
}
}

函数模板

把类型作为一个设计参数，根据函数实参，会推到一个新的函数，是在编译的时候产生的class和typename都可以

template<class T>
T my_max(T a,T b){
	return a > b? a : b;
}
int main({
	my_max(12，23);
	my_max( 'a', 'b ');
	my_max(12.23，34.45);
	return 0;
}

注意：不是把T替换，而是类型的重命名
<>中的int就是让函数的返回值为int，必须要加返回值，后面也可以接参数，这样编译器就不用推导了
比如整型推导的函数为：

typedef int T
T my_max<int>(T a,T b){
	return a > b? a : b;
}

函数模板根据一组实际类型或(和)值构造出独立的函数的过程通常是隐式发生的，称为模板实参推演(template argument deduction)。

在这里插入图片描述

template<class T,typename R,typename U>
T my_max(R a,U b){
	return a > b? a : b;
}
int main(){
	double c=my_max<double>(12,34.45);//
	double c=my_max<double,int,double>(12,34.45);//这样我们就帮助编译器做了推导工作
	return 0;
}

类模板

类模板是生成代码的代码
用类实现的链栈

//该类栈是不带头结点的
class MyStack {
private:
	struct StackNode {
		int data;
		StackNode* next;
	public:
		StackNode(int val=0, StackNode* p = nullptr)
			:data(val), next(p) {}
	};
private:
	StackNode* top;
	int cursize;
	void clone(const MyStack& s) {
		Clear();
		cursize = s.cursize;
		StackNode* p = s.top;
		if (p == nullptr)return;
		top = new StackNode(p->data);
		StackNode* tail = top;
		p = p->next;
		while (p != nullptr) {
			tail = tail->next = new StackNode(p->data);
			p = p->next;
		}
	}
public:
	MyStack():top(nullptr),cursize(0){}
	MyStack(const MyStack& s) :top(nullptr), cursize(s.cursize) {
		clone;
	}
	MyStack& operator=(const MyStack& s) {
		if (this != &s) {
			clone(s);
		}
		return *this;
	}
	~MyStack() {
		Clear();
	}
	void Clear() {
		while (top != nullptr) {
			StackNode* q = top;
			top = q->next;
			delete q;
		}
		cursize = 0;
	}
	int Size()const { return cursize; }
	bool Empty()const { return Size() == 0; }
	void Push(int val) {
		top = new StackNode(val, top);
		cursize += 1;
	}
	int& Top()const { return top->data; }
	void Pop() {
		StackNode* q = top;
		top = q->next;
		delete q;
		cursize -= 1;

	}
	bool GetTop(int& val) {
		if (Empty())return false;
		val = top->data;
		StackNode* q = top;
		top = q->next;
		delete q;
		cursize -= 1;
		return true;
	}
};

将普通栈用类模板改成通用栈
定义：
// double int Point
//template
//不能template

//该类栈是不带头结点的
template<class _Ty>
class MyStack {
private:
	struct StackNode {
		_Ty data;
		StackNode* next;
	public:
		StackNode(const _Ty& val=_Ty(), StackNode* p = nullptr)
			:data(val), next(p) {}
	};
...

MyStackimys;这里<>必须要加，

int main() {
	MyStack<int>imys;
	MyStack<double>dmys;
	MyStack<Point>pmys;
}

生成处理整型的栈

//该类栈是不带头结点的
class MyStack<int> {
using _Ty=int;
private:
	struct StackNode {
		_Ty data;
		StackNode* next;
	public:
		StackNode(const _Ty& val=_Ty(), StackNode* p = nullptr)
			:data(val), next(p) {}
	};
...


//该类栈是不带头结点的
template<class _Ty>
// double int Point
//template<typename _Ty> 
//不能template<struct _Ty>
class MyStack {
private:
	struct StackNode {
		_Ty data;
		StackNode* next;
	public:
		StackNode(const _Ty& val=_Ty(), StackNode* p = nullptr)
			:data(val), next(p) {}
	};
private:
	StackNode* top;
	int cursize;
	void clone(const MyStack& s) {
		Clear();
		cursize = s.cursize;
		StackNode* p = s.top;
		if (p == nullptr)return;
		top = new StackNode(p->data);
		StackNode* tail = top;
		p = p->next;
		while (p != nullptr) {
			tail = tail->next = new StackNode(p->data);
			p = p->next;
		}
	}
public:
	MyStack():top(nullptr),cursize(0){}
	MyStack(const MyStack& s) :top(nullptr), cursize(s.cursize) {
		clone;
	}
	MyStack& operator=(const MyStack& s) {
		if (this != &s) {
			clone(s);
		}
		return *this;
	}
	~MyStack() {
		Clear();
	}
	void Clear() {
		while (top != nullptr) {
			StackNode* q = top;
			top = q->next;
			delete q;
		}
		cursize = 0;
	}
	int Size()const { return cursize; }
	bool Empty()const { return Size() == 0; }
	void Push(const _Ty& val) {
		top = new StackNode(val, top);
		cursize += 1;
	}
	_Ty& Top()const { return top->data; }
	void Pop() {
		StackNode* q = top;
		top = q->next;
		delete q;
		cursize -= 1;

	}
	bool GetTop(_Ty& val) {
		if (Empty())return false;
		val = top->data;
		StackNode* q = top;
		top = q->next;
		delete q;
		cursize -= 1;
		return true;
	}
};
class Point {
private:
	int x;
	int y;
public:
	Point(int a=0,int b=0):x(a),y(b){}
	int Getx()const { return x; }
	int Gety()const { return y; }
};
int main() {
	MyStack<int>imys;
	MyStack<double>dmys;
	MyStack<Point>pmys;
	for (int i = 0; i < 10; i++) {
		imys.Push(i);
	}
	int x;
	while (imys.GetTop(x)) {
		cout << x << endl;
	}


	for (int i = 0; i < 10; i++) {
		pmys.Push(Point(i,i+10));
	}
	Point px;
	while (pmys.GetTop(px)) {
		cout << "x:" << px.Getx() << "     y:" << px.Gety() << endl;
	}
	return 0;
}

在这里插入图片描述
模板的实例化过程是编译实现的
模板类型参数是一个重命名的过程，而模板非类型参数类似宏替换

在这里插入图片描述
类模板中的函数都是函数模板

IT_涛涛
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++基础-内联函数inline，重载，extern “C“ 及封装
weixin_41865866的博客
08-10 386
内联函数inline，重载，extern "C" 及封装
C++ inline函数和template函数
记录成长中的点点滴滴
05-20 4969
由于inline函数和template函数之间有些相同的特点，因此在学习C++的时候经常弄混inline函数和template函数的一些特点，读过Effective C++后对两者的概念有了较清楚的了解，在此记下来，方便以后查阅： 相同点：inline函数和template函数通常都被定义于头文件内。 原因：Inline函数通常一定被内置于头文件内，因为大多数建置环境(build envi
C++基本概念(内联,模板,函数)
hopegrace的博客
02-10 961
1、inlinefunction 嵌入到主调函数中的函数称为内置函数(inlinefunction)，又称内嵌函数，或内联函数。指定内置函数，只需在函数首行的左端加一个关键字inline即可。可以在声明函数和定义函数时同时写inline，也可以只在其中一处声明inline，效果相同。内置函数中不能包括复杂的控制语句，如循环语句和switch语句，一般少于5句。对函数作inlin...
inline函数，缺省函数，函数重载以及函数模板
HZ2170781977的博客
05-29 1850
1.内联函数在编译时展开，带参的宏在预编译时展开；2。内联函数直接嵌入到目标代码中，带参的宏是简单的做文本替换；3.内联函数有类型检测，语法判断等功能，宏只是替换。
入门级C++操作（缺省参数、函数重载、取别名）
Yuaniiiiii的博客
04-03 517
这样的代码也是不行的，为什么呢，因为在计算运算符的时候，会创建一个临时变量来储存结果。一个是乒乓球，一个 是男足。大家在C语言中自定义函数时，可能函数执行的操作类似，但由于形参类型的不同需要写成不同的函数名，在调用时十分的麻烦，还得加点后缀，所以C++中对于这方面就进行了改进，引入了函数重载，下面我们看一下代码段。大家先从函数的定义开始看，C语言中我们是不能给形参直接一个初值的，必须得传参数，不传参数无法使用参数，那么有些时候我们不太确定我们所需要传参的值的，那么在C++中，在定义函数时，可以给形参一个。
C++初阶——命名空间、缺省参数、函数重载和内联函数
01-31 2411
C++入门一、命名空间1.1 命名空间的定义1.1.1 普通的命名空间1.2.2 命名空间的嵌套1.3.1 同一个工程中允许存在多个相同名称的命名空间,编译器最后会合成同一个命名空间中。1.2 命令空间的使用1.2.1 加命名空间名称及作用域限定符1.2.2 使用using将命名空间中成员引入1.2.3 使用using namespace 命名空间名称引入二、输入&输出三、缺省参数3.1 缺省参数的定义3.2 缺省参数分类3.2.1 全缺省参数3.2.2 半缺省参数四、函数重载4.1 函数重载概念4
c++学习总结【2】inline函数，缺省函数，函数重载与函数模板
llfaker的博客
05-09 241
c++学习总结【2】inline函数，缺省函数，函数重载与函数模板 1.inline函数 内联是一种空间换时间的做法，不建议声明和定义分离，会导致链接错误，若函数的执行开销小于清栈开销，则使用内联函数处理的效率高 2.缺省函数 缺省参数是在定义函数时为形参指定缺省值（默认值）。 缺省参数可以有多个，但所有缺省参数必须放在参数表右侧，即先定义非缺省的参数。 缺省参数一般在函数的声明中指定，而函数定义中则不能再次指定。 3.函数重载 两个或两个以上的函数有相同的函数名，而他们的参数数据类型不同，或是参数的个数不
C++学习之函数重载、哑元参数、缺省参数、内联函数
u013511885的博客
11-20 336
函数重载 1)定义 在相同作用域，定义的同名函数，但是它们的参数必须有所区分，这样的函数将构成重载关系 注：函数能否重载和返回类型无关. #include <iostream> using namespace std; void func(int i){ cout << "func(int)" << endl; } void func(int a, i...
c/c++开发，无可避免的模板编程实践（篇一）-函数模板及类模板
技术需要分享
02-13 752
c/c++开发，无可避免的模板编程实践（篇一）,介绍函数模板及类模板的知识点及开发要点，给出实践源代码测试效果
C++ 语法 - 2. 引用 & 、内联函数 inline 、函数重载 、函数的缺省参数 、占位参数 - 解析
weixin_50920631的博客
04-20 88
【代码】2. 引用 & 、内联函数 inline 、函数重载 、函数的缺省参数 、占位参数 - 解析。
【C/C++】 类模板与模板类详解|函数指针\指针函数|函数模板和类模板|普通参数模板、类参数模板...
小鱼菜鸟的博客
10-04 310
目录 类模板与模板类详解 简洁 详细 类模板的使用 函数指针\指针函数\模板类\类模板 模板函数与函数模板 类模板与模板类详解 简洁 类模板：模板 模板类：实例 模板类是类模板实例化后的一个产物，说个具体点的例子吧，我们把类模板比作是一个做饼干的模子，而模板类就是用这个模子做出来的饼干，至于这个饼干是什么味道的就要看你自己在实...
C++：布尔类型bool，函数重载、参数缺省值、哑元参数、内联函数、引用
Hello, New World!
02-02 4843
"$: nautilus ." 打开文件夹 "$: nautilus jy/c++" 打开指定路径的文件夹 一、布尔类型 bool （C++98 新增的基础数据类型） bool 类型的变量有两个可能的值：1 / 0 bool 类型的常量有两个可能的值：true / false bool 类型的变量占用的字节数，因系统不同而不同，大多数系统为 1 字节。 1. bool 类型的赋值：
C++入门基础(万字总结）（建议收藏！！！）
热门推荐
IamGreeHand的博客
09-22 26万+
文章目录什么是C++C++的发展史C++关键字命名空间命名空间的定义1.命名空间的普通定义2.命名空间可以嵌套3. 同一个工程中允许存在多个相同名称的命名空间,编译器最后会合成同一个命名空间中。命名空间使用1.加命名空间名称及作用域限定符2.使用using namespace 命名空间名称引入3.使用using将命名空间中的成员引入C++中的输入和输出缺省参数全缺省半缺省参数函数重载函数重载的原理extern “C”引用引用的特征1.引用在定义时必须初始化2.一个变量可以有多个引用3.引用一旦引用了一个实体
使用C++实现计算器功能，可以实现加减乘除，需要用到内联、函数重载、new运算符、缺省参数
qq_63586680的博客
03-07 528
计算器加减乘除
【C++】STL—vector的使用
2301_77112794的博客
09-04 700
本文介绍了vector重点函数接口的使用
【C++】vector的简单模拟实现
2303_80828380的博客
09-05 1200
vector的简单模拟实现！！！
C语言 | Leetcode C语言题解之第389题找不同
m0_59237910的博客
09-07 489
C语言 | Leetcode C语言题解之第389题找不同
C语言——strcpy、sprintf与memcpy
最新发布
鲸落博客
09-09 701
该函数和printf()函数有很多相似之处，例如printf()将不同类型的数据格式化到终端，而sprintf()函数是将不同类型的数据格式化到字符串中。另外，和strcpy()函数一样，该函数也不会对目标缓冲区进行检查，容易造成溢出。它是一种非常通用的内存复制函数，不仅限于复制字符串，还可以复制任何类型的内存块。3. 未定义行为：程序可能会继续运行，但结果不可预测，可能会输出错误的结果或导致其他未预料的行为。如果memcpy复制字符串，要复制的字节数超过原内存块本身的内存数，会怎么样？
C++入门：缺省参数与函数重载解析
这份C++入门课件提供了对C++编程基础的深入理解，包括如何使用主调函数组织程序流程，如何利用内联函数优化性能，以及如何通过缺省参数和函数重载来提高代码的灵活性和可读性。对于初学者来说，这些概念是理解和掌握...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值