1.函数重载
1.1概念
函数重载是一种特殊的情况,C++允许在 同一作用域中声明几个功能类似的同名函数,这些同名函数的 形参列表(参数个数、类型、类型顺序)不同,常用来处理实现功能类似数据不同的问题。
1.2示例
#include<iostream>
using namespace std;
//参数类型不同
int Mul(int a, int b)
{
cout << "int Mul(int a, int b)" << endl;
return a * b;
}
double Mul(double a, double b)
{
cout << "double Mul(double a, double b)" << endl;
return a * b;
}
//参数个数不同
void Func(int a)
{
cout << "Func(int a)" << endl;
}
void Func(int a, int b)
{
cout << "Func(int a, int b)" << endl;
}
//参数顺序不同
void f(double a, char b)
{
cout << "f(double a, char b)" << endl;
}
void f(char b, double a)
{
cout << "f(char b, double a)" << endl;
}
int main()
{
Mul(1, 2);
Mul(2.3, 4.5);
Func(5);
Func(5, 6);
f(5.6, 'e');
f('e', 5.6);
return 0;
}
1.3特别注意!
- 返回值不同,无法区分,返回值不是重载的条件
- 在main()函数中调用Func(),虽构成重载,但会引歧义。但如果调用Func(30)不会引起歧义。想要解决这个问题,可以用命名空间将函数包裹进去。
1.4为什么C++支持函数重载,而C语言不支持?
因为C++运行的时候有函数名修饰,但C语言直接用的函数名,所以无法区分。
C++:
C语言:
2.引用
2.1概念
引用不是新定义一个变量,而是 给已存变量取了一个别名,编译器不会为引用变量开辟内存空间,它和它引用的变量 共用同一块内存空间。
比如:
a是我们定义的变量,b是a引用的变量,也就是a的别名,会发现a和b的使用空间是相同的。同时改变b的值也会改变a的值。
2.2格式
类型& 引用变量名=引用实体;
void TestRef() { int a = 10; int& ra = a;//<====定义引用类型(a的别名) int& c = ra;//也可以给别名取别名 }
注意:引用类型必须和引用实体是同一种类型!
2.3引用特性
- 引用在定义时必须初始化
- 一个变量可以有多个引用
- 引用一旦引用一个实体,再不能引用其他实体
int main() { int a = 1; int c = 2; //int& b;报错->没有初始化 int& b = a; //&b = c;报错->表达式必须是可修改的左值 }
2.4常引用
const int a = 10; //int& ra = a; // 该语句编译时会出错,a为常量
1.权限放大,a是只读,ra为a的别名,ra是可读可写的,所以报错。
2.但是权限的缩小是没问题的
void test() { int x = 0; int& y = x; const int& z = x; }
那么这种情况是不是权限的放大呢?
const int m = 0; int p = m;
答案是不是,两者的地址不同,这只是把m的值拷贝给p,p的值的改变并不会影响m。
int main() { double d = 3.14; //类型转换 int i = d; int& r = d; return 0;//报错:无法从“double”转换为“int&” }
3.从代码可以看出,这是类型转换,在类型转换中会存在临时变量,临时变量具有常性,所以要用const修饰。
int main() { double d = 3.14; int i = d; //int& r = d;//报错:无法从“double”转换为“int&” const int& r = d; return 0; }
3.引用和指针
3.1共同点
在语法概念上引用就是一个别名,没有独立空间,和其引用实体公用同一块空间。这底层实现上实际是有空间的,因为 引用是按照指针方式来实现的。
int main()
{
int a = 10;
int& ra = a;
ra = 20;
int* pa = &a;
*pa = 20;
return 0;
}
我们看上面代码的引用和指针汇编代码对比:
所以我们以前用的指针可以用引用代替,比如:
void Swap(int& a, int& b)
{
int tmp = a;
a = b;
b = tmp;
}
int main()
{
int x = 1, y = 2;
Swap(x, y);
return 0;
}
这里的a,b就是x,y的别名,其实可以理解为把x,y传到Swap函数里了,直接对x,y进行交换。
再提一点,也可以给指针变量取别名:
void test4()
{
int x = 0;
int* p = &x;
int*& q = p;
q = NULL;//p、q都为空
}
3.2不同点
- 引用概念上定义一个变量的别名,指针存储一个变量地址
- 引用在定义是必须初始化,指针没有要求
- 引用在初始化时引用一个实体后,就不能再引用其他实体,而指针可以在任何时候指向任何一个同类实体
- 没有NULL引用,但有NULL指针(但是以下情况是可以的:)
int main() { int* p = NULL; int*& pq = p; cout << pq << endl; }
- 在sizeof中含义不同:引用结果为引用类型的大小,但指针始终是地址空间所占字节个数(32位占4个字节)
- 引用自加即引用实体加1,指针自加即指针向后偏移一个类型的大小
- 有多级指针,但没多级引用
4.内联函数
以 inline修饰的函数叫做 内联函数,编译时 C++编译器会在调用内联函数的地方展开,没有函数调用建立栈帧的开销,提升程序运行的效率。
inline int Add(int x, int y)
{
return x + y;
}
int main()
{
int ret = Add(3, 5);
cout << ret << endl;
}
普通函数:
4.1特性
- 内联函数是以空间换空间的做法。
- 内联函数用于函数规模较小,不是递归、且频繁调用
- 内联函数声明和定义不建议分开,会导致错误
5.auto关键字
5.1auto的特性
auto在定义变量时,可以由编译器自动识别类型。
5.2auto使用规则
- 用auto声明指针类型时,用auto和auto*没有任何区别,只是如果带*,必须是指针,不能是其他类型。
int main() { int x = 10; auto a = &x; auto* b = &x; auto& c = x; cout << typeid(a).name() << endl; cout << typeid(b).name() << endl; cout << typeid(c).name() << endl; *a = 20; *b = 30; c = 40; return 0; }
- 当在同一行声明多个变量时,这些变量必须是相同类型。
void TestAuto() { auto a = 1, b = 2; auto c = 3, d = 4.0; // 该行代码会编译失败,因为c和d的初始化表达式类型不同 }
5.3auto不能使用的场景
- auto不能作为函数的参数
// 此处代码编译失败,auto不能作为形参类型,因为编译器无法对a的实际类型进行推导 void TestAuto(auto a) {}
- auto不能直接声明数组
void TestAuto() { int a[] = {1,2,3}; auto b[] = {4,5,6};//报错 }
6.C++->范围for
对于一个有范围的集合而言,由程序员来说明循环的范围是多余的,有时候还会容易犯错误。因 此C++11中引入了基于范围的for循环。for循环后的括号由冒号“ :”分为两部分:第一部分是范 围内用于迭代的变量,第二部分则表示被迭代的范围。
void TestFor()
{
int array[] = { 1, 2, 3, 4, 5 };
//使用auto会自动取数组中的值赋给e,自动++,自动判断结束。
for(auto& e : array)
e *= 2;
for(auto e : array)
cout << e << " ";
return 0;
}