【C++] 认识C++（二）

爱编程的小马.

已于 2024-07-31 20:43:04 修改

阅读量798

点赞数 22

分类专栏： C++ 文章标签： c++ 开发语言

于 2024-07-31 00:01:46 首次发布

本文链接：https://blog.csdn.net/s1mplewo/article/details/140808655

版权

C++ 专栏收录该内容

5 篇文章 0 订阅

订阅专栏

前言

📚作者简介：爱编程的小马，是一名大厂后端c++程序员。

📚本文收录于C++系列，本专栏主要是分享我所了解的c++知识，带领大家慢慢从了解c++到认识c++，持续更新！

📚相关专栏Linux正在发展，敬请期待！

📚本文主要内容：正式引入C++特有功能，主要是函数重载，引用，auto运算符等等..

1.认识C++

1.1 函数重载

1.1.1 定义

函数重载：函数重载是C++的一个特殊情况，C++允许在同一作用域中声明几个功能类似的同名函数，这些同名函数的形参列表（形参顺序不同，个数不同，形参类型不同），常常用来处理功能类似但是数据类型不同的数值。

函数重载简单理解就是一词多义，一个函数名，其形参不同，可以实现不同的函数功能。

1.1.2 函数重载的使用场景

1、形参顺序不同

#include<iostream>

using namespace std;

void Test1(char a, int b)
{
	cout << "void Test1(char a, int b)" << endl;
}

void Test1(int a, char b)
{
	cout << "void Test1(int a, char b)" << endl;
}
int main()
{
	//1、函数形参顺序不同
	int a =1 ;
	char b = 'a';
	Test1(a,b);
	Test1(b, a);
	return 0;
}

2、形参个数不同

#include<iostream>

using namespace std;



void Test2(int a)
{
	cout << "void Test2(int a)" << endl;
}

void Test2(int a , double b)
{
	cout << "void Test2(int a , double b)" << endl;
}
int main()
{
    //2、参数个数不同
	int a =1 ;
	char b = 'a';
	double c = 3.14;
	Test2(a);
	Test2(a,c);
	return 0;
}

3、形参类型不同

#include<iostream>

using namespace std;



void Test3(int a)
{
	cout << "void Test3(int a)" << endl;
}

void Test3(char a)
{
	cout << "void Test2(char a)" << endl;
}
int main()
{
	//3、参数类型不同
	int a =1 ;
	char b = 'a';
	double c = 3.14;
	Test3(a);
	Test3(b);
	return 0;
}

1.1.3 函数重载的应用

接下来我举个例子，比方说之前讲过的加法，可以整数加，小数加，那怎么办？以前就定义add1,add2,add3等等，现在不需要了，函数重载可以很好的帮助我们解决这个问题。

//整数+整数
int Add(int a, int b)
{
	return a + b;
}

//整数+小数
double Add(int a, double b)
{
	return a + b;
}

double Add(double a, int b)
{
	return a + b;
}

//小数+小数
double Add(double a, double b)
{
	return a + b;
}
int main()
{
	int a = 10;
	int b = 20;
	double c = 3.1415;
	double d = 9.666;
	cout << Add(a, b) << endl; //30
	cout << Add(a, c) << endl; //13.1415
	cout << Add(c, b) << endl; //23.1415
	cout << Add(c, c) << endl; //6.283
	cout << Add(c, d) << endl; //12.8075
	return 0;
}

2.1 引用

2.1.1 引用的定义

引用不是一个新变量，而是给已经存在的变量起了一个别名，编译器不会为其开辟新的空间（实际上是需要的），它和它引用的变量占用同一块物理空间。

类型& 引用变量名 = 类型变量

注意：引用类型和引用对象必须是同一个类型。

//引用的特性：
//1、引用必须初始化
//2、一个变量可以有多个引用
//3、引用一旦引用一个实体，就不能引用其他实体
int main()
{
	int a = 10;
	int b = 0;
	int& pa = a;
	int& pb = a;
	pa = b;//只是赋值，不是引用
	cout << "a=" << a <<" " << "pa=" << pa <<" " << "pb= " << pb << endl;
	cout << "b=" << b << endl;
	pa++;
	cout << "a=" << a << " " << "pa=" << pa << " " << "pb= " << pb << endl;
	cout << "b=" << b << endl;
	return 0;
}

2.1.2 常引用


int main()
{
	//const int a = 10;
	这样子是不行的，因为涉及到权限的放大，我们注意，权限可以缩小
	可以平移，但是不能放大
	//int& b = a;
	//正确是这样的，使用常引用
	const int a = 10;
	const int& b = a;
	return 0;
}

2.1.3 引用的使用场景

1、做参数

比方说咱们的两个整数交换，使用引用就特别的方便

void Swap(int& x, int& y)
{
	int tmp = x;
	x = y;
	y = tmp;
}

int main()
{
	int a = 2;
	int b = 3;
	cout << "a=" << a << " " << "b=" << b << endl;
	Swap(a, b);
	cout << "a=" << a << " " << "b=" << b << endl;

	return 0;
}

2、做返回值


int& Test()
{
	static int a = 10;
	a++;
	a++;
	a++;
	return a;
}
int main()
{
	int& b = Test();
	Test();
	cout << b << endl;
	return 0;
}

有很多同学就要问了，为什么要加static静态变量呢？其实大家看下面这个例子

int& Add(int a, int b)
{
    int c = a + b;
    return c;
}
int main()
{
    int& ret = Add(1, 2);
    Add(3, 4);
    cout << "Add(1, 2) is :" << ret << endl;
    return 0;
}

这个的输出结果是下图

为什么？是这样的，因为整型c是一个临时变量，也就是在栈区的，函数销毁就一起销毁了，这个时候使用引用，相当于还在使用这一块被销毁的区域，那么在调用该函数时，就出问题了。

总结：

1、如果出了函数，返回的变量还在，可以使用传引用返回，否则，一定要使用传值返回

2、引用是一个变量的别名，指针是存储一个变量的地址

3、引用在引用一个实体之后，不能再引用其他变量，指针可以任何时候指向同类型的变量

4、没有空引用，但有空指针

3.1 内联函数

3.1.1 内联函数的定义

和宏类似，内联函数会在其使用的地方展开，提升函数调用效率。

比方说，大家写一下C语言中宏函数的加法定义，考一考大家的C语言的功底

#include<stdio.h>


#define Add(a , b) ((a)+(b)) 
int main()
{
	printf("%d\n",Add(1, 3));
	return 0;
}

是不是很多坑啊，会漏括号，麻烦，C++干脆就使用函数来代替这个功能了

inline int Add(int x, int y)
{
	return x + y;
}

int main()
{
	int ret = Add(1, 3);

	return 0;
}

宏的优点：

1、复用性高

2、效率高

宏的缺点：

1、不好调试（在预处理的时候会展开）

2、代码可读性差

3、没有安全性的检查

4.1 auto关键字

4.1.1定义

C++11中，标准委员会赋予了auto全新的含义即：auto不再是一个存储类型指示符，而是作为一个新的类型指示符来指示编译器，auto声明的变量必须由编译器在编译时期推导而得。

注意：使用auto定义变量时必须对其进行初始化，在编译阶段编译器需要根据初始化表达式来推导auto 的实际类型。因此auto并非是一种“类型”的声明，而是一个类型声明时的“占位符”，编译器在编译期会将auto替换为变量实际的类型。

4.1.2 auto的使用场景

auto使用在数组中特别舒服，一起来看个例子

int main()
{
	int arr[] = { 1,2,3,4,5 };
	//打印该数组
	for (int i = 0; i < sizeof(arr) / sizeof(int); i++)
	{
		cout << arr[i] << " ";
	}
	//方法二 指针
	cout << endl;
	for (int* parr = arr;parr < arr+sizeof(arr)/sizeof(int);parr++)
	{
		cout << *(parr) << " ";
	}
	//方法三 auto
	cout << endl;
	for (auto d: arr)
	{
		cout << d << " ";
	}
	for (auto& d : arr)
	{
		d*=2;
	}
	cout << endl;
	for (int* parr = arr; parr < arr + sizeof(arr) / sizeof(int); parr++)
	{
		cout << *(parr) << " ";
	}
	return 0;
}