【C++入门篇】引用&&内联函数&&auto&&范围for&&nullptr
6.引用C语言中函数的传参有两种方式：
1.传值 2.传址
虽然这两种方式都可以实现函数传参但是却各自有着本身的优缺点：
传值：无法改变形参的值
传址：不是很形象而且不安全
在升级版C++中为了解决这种问题就利用了引用&
概念
引用不是新定义一个变量,而是给已存在变量取了一个别名
编译器不会为引用变量开辟内存空间,它和它引用的变量共用同一块内存空间,
引用的方法：
[*]类型& 引用变量名(对象名) = 引用实体；
例子1
#include<iostream>
using namespace std;
int main()
{
int a = 10;
//引用定义
int& b = a;
//取地址
int* pa = &a;
//编译器不会为引用变量开辟内存空间
cout << "&a = " << &a << endl;
cout << "&b = " << &b << endl;//引用变量和他引用的变量地址相同
cout << "pa =" << pa << endl;//pa是指针,保存的是a的地址
}
https://i-blog.csdnimg.cn/blog_migrate/c5a4e627ce246a6f958009ea47b36aff.png
引用在语法层面看,我们要明白成没有开辟新空间,就是对原来的变量取了一个别名
例子
void TestRef()
{
int a = 10;
int& ra = a;//<====定义引用类型
printf("%p\n", &a);
printf("%p\n", &ra);
}
注意：引用类型必须和引用实体是同种类型的
//err
int main()
{
int a = 10;
double& b = a;
}
https://i-blog.csdnimg.cn/blog_migrate/c39b86b8424c08d2fcdc4bbdc02dbd90.png
引用特性
[*]1.引用在定义时必须初始化
int a = 10;
int& b;//err必须初始化
https://i-blog.csdnimg.cn/blog_migrate/2898ff35e7145eb1b7752c3eb9492dfa.png
[*]2.一个变量可以有多个引用-类似一个人可以有多个代号
inta = 10;
int& b = a;
int& c = b;
int& d = a;
[*]3.引用一旦引用一个实体,再不能引用其他实体
int main()
{
int a = 10;
int& b = a;
cout << "b = " << b << endl;
cout << "&a = " << &a << endl;
int c = 20;
b = c;
//这里是把b变成c的别名还是把c的值赋给b？
cout << "b = " <<b<< endl;
cout << "&b = " << &b << endl;
return 0;
}
所以是把c的值赋给b ,引用一旦引用一个实体,再不能引用其他实体
https://i-blog.csdnimg.cn/blog_migrate/0e4d103013dc3ed70ef66ea8047bb6cc.png
[*]4.引用变量的名不能和别的变量名同名
int main()
{
int a = 10;
int& b = a;
double b = 1.1;//err
}
https://i-blog.csdnimg.cn/blog_migrate/f4e56e3ddd5e32f3706722b5f483c53a.png
总结：
[*]引用必须初始化
[*]一个变量可以有多个引用（就好比一个人可以有多个绰号）
[*]引用一旦引用实体,再不能引用其他实体
[*]不能创建引用数组
[*]不能创建引用的引用
[*]没有引用的指针
[*]可以取引用的地址（着实也就是取变量的地址）
[*]区别引用声明符&和地址运算符&,（出现在声明中的&是引用声明符其他的是地址运算符）
常引用
若加了const修饰的变量：称为常变量,还是变量,但是只可读,不可写(不可修改变量的值),
case 1: 权限放大 err
//b和a占用同一块空间
const int a = 10; //a ：只读
int& b = a; //b：可读可写
case2：权限不变：可以
const int a = 10;
const int& b = a;//a和b都是只读
int a = 10;
int& b = a;//a和b都是可读可写
case3:权限缩小 - 可以
int a= 10;//a：可读可写
const int& b = a; //b：只可读
对于类型不同的变量举行引用要加const：
因为类型不同的变量赋值会产生临时变量,这个临时变量是不能修改的,所以要用const修饰
https://i-blog.csdnimg.cn/blog_migrate/0044df4d8317ca56a17a3274f514ab9b.png
int main()
{
double d = 3.14;
//int& rd = d; //err类型不同
const int& b = d;//OK
return 0;
}
总结：
int a = 10;
int& b = a;//OK
//double& d = a;//err
const double& d = a;//OK
b就是a的别名,类型相同的引用不会创建临时变量
double&类型的引用 只能引用double类型的变量 要引用类型必须要划一
int和double之间可以隐式转换 编译器在这个过程中生成了一个临时变量 d引用的不是a ,而是引用的是生成的临时变量,因为临时变量具有常性 所从前面要加const
结论：
1.类型不同的变量举行引用要加const
2.const Type &可以接受任何类型的对象
int a = 10;
char c = 'a';
double d = 3.14;
//const int& i1 = a;//OK
//const int& i1 = c;//OK
//const int& i1 = d;//OK
验证不同类型,引用的不是本身,而是临时变量
https://i-blog.csdnimg.cn/blog_migrate/fac69ccbde99fb1808394582bc93d47f.png
例子
假设x是一个大对象或者是深拷贝的对象,那么只管利用引用传参,减少拷贝
而且如果函数中不改变传的参数,只管利用const引用传参
//引用传参
void func(int& x)
{
cout<< x <<endl;
}
int main()
{
const int a = 10;
const int&b = a;
func(a);//erra可读 引用传参给x,x是可读可写,权限放大,err
func(10);//err 10是常数只可读
}
https://i-blog.csdnimg.cn/blog_migrate/75d2582f2dade31ebbabf02f491fe75a.png
//引用传参,加上const修饰后
//x变成只可读了,权限不变,所以可以
void func(const int& x)
{
cout << x << endl;
}
int main()
{
const int a = 10;
const int& b = a;
func(a);//10
func(10); //10
}
#define M 10
int main()
{
const int& b = M;//ok,b：只可读 M：只可读 权限不变
// int& c = M;//err M是常数只可读,而c可读可写,权限扩大
}
引用的利用场景
1.引用做函数参数
case1：
//函数修饰名：_Z4swappipi
void Swap(int* p1,int* p2)//传地址
{
int tmp = *p1;
*p1 = *p2;
*p2 = tmp;
}
//函数修饰名：_Z4swapii
void Swap(int r1,int r2)//传值
{
int tmp = r1;
r1 = r2;
r2 = tmp;
}
//函数修饰名：_Z4swapriri
void Swap(int& r1,int& r2) //传引用
{
int tmp = r1;
r1 = r2;
r2 = tmp;
}
问1：上述三个互换函数构成函数重载吗
函数修饰名不同,构成函数重载,但是Swap(x,y)调用时会存在歧义,它不知道调用的是传值还是传引用
https://i-blog.csdnimg.cn/blog_migrate/51c45d37ccb496e774ecea67d19a7a99.png
传引用相当于把空间传过去,改变形参的内容,实参的内容也会发生改变
//r1,r2就是a,b的别名,r1,r2的改变就是改变a,b
void Swap(int& r1, int& r2) //传引用
{
int tmp = r1;
r1 = r2;
r2 = tmp;
}
int main()
{
int a = 1;
int b = 2;
cout << "a ="<< a<<" b = "<<b << endl;
Swap(a, b);
cout << "a =" << a << " b = " << b << endl;
return 0;
}
https://i-blog.csdnimg.cn/blog_migrate/b9c542b2f5bc5934e7b544c11ae78475.png
case2：二级指针 = = 传指针的引用
起首要知道：
函数内要改变整形变量的值：传一级指针
要改变一级指针的内容：传二级指针
但是利用指针的引用就不消这么贫苦,改变一级指针,只必要传一级指针的引用即可
//传一级指针
void func1(int* pa)
{
pa = (int*)malloc(sizeof(int)*4);
}
//传二级指针
void func2(int** ppa)
{
*ppa = (int*)malloc(sizeof(int) * 4);
}
//传引用
void func3(int*& pa)
{
pa = (int*)malloc(sizeof(int) * 4);
}
int main()
{
int* p = NULL;
cout << "p = " << p << endl; //NULL
func1(p);//传一级指针
cout << "p = " << p << endl;
func2(&p);//传二级指针
cout << "p = " << p << endl;
func3(p);//传引用
cout << "p = " << p << endl;
return 0;
}
函数内部为p开辟一块空间
传二级指针和传一级指针引用都可以改变一级指针的内容
https://i-blog.csdnimg.cn/blog_migrate/bed627208655be42f0ebd9dd22172eed.png
2.引用做返回值
起首,我们要知道：全部的传值返回都会生成临时变量(临时拷贝)
临时变量 (临时拷贝存在哪里)
[*]如果返回的变量比较小(4/8个字节),一样寻常是寄存器eax充当临时变量
[*]如果返回的变量比较大(如：结构体),临时变量存放在调用该函数的栈帧中
例子
//传值返回
int Add(int x, int y)
{
int c = x + y;
return c;
}
int main()
{
int ret = Add(1, 2);
cout << "ret = " << ret << endl;//3
return 0;
}
https://i-blog.csdnimg.cn/blog_migrate/f77b491cf2e02c5d9ad7a81c187fd4cd.png
假设用传引用返回
引用返回的寄义：不会生成c的拷贝返回,直接返回c的引用
传值返回：返回对象会拷贝给临时对象,临时对象做返回,现在用传引用返回,返回的是返回对象的引用(别名)
int& Add(int x, int y)
{
int c = x + y;
return c;
}
int main()
{
int ret = Add(1, 2);
cout << "ret = " << ret << endl;
}
https://i-blog.csdnimg.cn/blog_migrate/0a61c21739f6adf47c86414545528377.png
当前代码的问题：
[*]1.存在非法方法,因为Add函数返回的值是c的引用,所以Add函数栈帧烧毁之后,会去访问c位置的空间取值
[*]2.如果Add函数栈帧烧毁,清算空间,那么取c的值的时候就是随机值,给ret的就是随机值,这个取决于编译器的实现
[*]如果后序没有新的函数栈帧开辟或者新的函数栈帧不敷以覆盖c的内容,得到的还是c的值,否则就是随机值
https://i-blog.csdnimg.cn/blog_migrate/37fcab8c902bb682c276f507074be404.png
tmp是c的别名,相当于返回c的引用,如果c的空间被清掉,c的值酿成随机值,ret的值就会是随机值
如：后面的函数栈帧把原来c的空间被覆盖了
int& Add(int x,int y)
{
int c = x + y;
return c;
}
int main()
{
int& ret = Add(1,2);//ret也是c的引用
cout << "ret = " <<ret <<endl;
printf("11111\n");
cout << "ret = " << ret << endl;
return 0;
}
https://i-blog.csdnimg.cn/blog_migrate/54d086ecccf0bb089f109a419d89e42a.png
注意:此时ret也是c的引用
printf也是函数,会把原来c变量空间的栈帧覆盖,导致ret的值为随机值
注意：如果函数返回时,出了函数作用域,如果返回对象还未还给体系,则可以利用引用返回,如果已经还给体系了,则必须利用传值返回,
返回引用的话效率高 不消创建临时变量 只要返回的实体不会随着函数竣事而烧毁的话 都可以以引用的方式返回
通俗点说：就是出了作用域,变量还在的,就可以用引用的方式,可以进步效率
例子1：static的变量
//传引用返回
int& Count()
{
//n放在静态区,出了函数栈帧也不销毁,所以可以使用传引用返回
static int n = 0;
n++;
return n;
}
int main()
{
int a = Count();
cout << "a = " << a << endl; //1
a = Count();
cout << "a = " << a << endl; //2
return 0;
}
例子2：
//传引用返回
char& func(char* str, int i)
{
return str;
}
int main()
{
char arr = "Mango";
char c = func(arr, 3);
cout << "c = " << c << endl;//g
c = func(arr, 2);
cout << "c = " << c << endl;//n
}
出了作用域,str的空间没有被烧毁,所以可以用传引用返回,str这个是数组的空间
str不是局部变量 局部变量是在函数中创建的 str不是在函数中创建的
例子3
//方式1： ok
int& fun()
{
int* p =(int*)malloc(sizeof(int));
return *p;
}
//方式2： err
int*& fun()
{
int* p =(int*)malloc(sizeof(int));
return p;
}
方式1是正确的,方式2是错误的！
原因：p是局部变量,出了作用域就烧毁了,但是*p(malloc出来的空间还在),所以 return *p可以,return p 不可以
例子4：用引用返回实现可读可写
#define N 5
int& func(int i)
{
static int a;
return a;//返回的是a的别名
}
int main()
{
//读
for (size_t i = 0; i < N; i++)
{
//func返回的是a的别名
//相当于a = i + 1
func(i) = 1 + i;
}
//写
for (size_t i = 0;i < N;i++)
{
//func返回的是a的别名
//相当于打印a对应的值
cout << func(i) << " " ; // 1 2 3 4 5
}
return 0;
}
注意：若把引用取消就会报错
https://i-blog.csdnimg.cn/blog_migrate/7adc06df0a8a9a12f351ff7eed299517.png
原因：此时是值返回,会生成一个临时变量,返回的是a的临时变量,临时变量具有常性(是右值:不可以被修改)
右值：表达式的返回值,常量,可以认为是右值
右值的特点：右值不能被修改,如果引用一个不绝,要用const修饰
普通引用引的就是左值,const引用引的是右值
例子1：
https://i-blog.csdnimg.cn/blog_migrate/3e3346342a7d13a94b35253a1cd95866.png
例子2：
https://i-blog.csdnimg.cn/blog_migrate/7e6215cd9a8c7e93553f743d52fea393.png
例子3:表达式的返回值也是右值
int x1 = 1;
int x2 = 2;
int& r = x1+x2;
https://i-blog.csdnimg.cn/blog_migrate/f62aa68bfdee3aa4aaad685e53d2ba39.png
所以要写成：
const int& r = x1+x2;
传值,传引用的效率比较
以值作为参数或者返回值类型,在传参和返回期间,函数不会直接传递实参或者将变量本身直接返回,而是传递实参或者返回变量的一份临时的拷贝,
因此用值作为参数或者返回值类型,效率是非常低下的,尤其是当参数或者返回值类型非常大时,效率就更低
测试代码
//传值传参和传引用传参的效率对比
#include <time.h>
struct A{ int a; };
void TestFunc1(A a){}
void TestFunc2(A& a){}
void TestRefAndValue()
{
A a;
// 以值作为函数参数
size_t begin1 = clock();
for (size_t i = 0; i < 10000; ++i)
TestFunc1(a);
size_t end1 = clock();
// 以引用作为函数参数
size_t begin2 = clock();
for (size_t i = 0; i < 10000; ++i)
TestFunc2(a);
size_t end2 = clock();
// 分别计算两个函数运行结束后的时间
cout << "TestFunc1(A)-time:" << end1 - begin1 << endl;
cout << "TestFunc2(A&)-time:" << end2 - begin2 << endl;
}
值和引用作为返回值类型的性能比较
测试代码
//传值返回和传引用返回的对比
#include <time.h>
struct A{ int a; };
//a是全局结构体变量,出了函数还在,所以可以使用传引用返回
A a;//a的大小为4W字节
// 值返回 - 传值返回都会生成临时变量(临时拷贝),每次拷贝4W字节
A TestFunc1() { return a;}
// 引用返回 - 没有拷贝
A& TestFunc2(){ return a;}
void TestReturnByRefOrValue()
{
// 以值作为函数的返回值类型
size_t begin1 = clock();
for (size_t i = 0; i < 100000; ++i)
TestFunc1();
size_t end1 = clock();
// 以引用作为函数的返回值类型
size_t begin2 = clock();
for (size_t i = 0; i < 100000; ++i)
TestFunc2();
size_t end2 = clock();
// 计算两个函数运算完成之后的时间
cout << "TestFunc1 time:" << end1 - begin1 << endl;
cout << "TestFunc2 time:" << end2 - begin2 << endl;
}
传值和指针在作为传参以及返回值类型上效率相差很大,
==总结：==引用的作用主要体现在传参和传返回值
[*] 1.引用传参和传返回值,有些场景下面,可以进步性能(大对象+ 深拷贝对象)
[*] 2.引用传参和传返回值,输出型参数和输出型返回值,通俗来说,有些场景下,形参的改变可以改变形参（传引用,二者占用同一块空间）,有些场景下,引用返回,可以改变返回对象
[*] 不能返回栈空间上的引用
[*] 传值,传地址,传引用的效率比较
引用>地址>值
引用和指针的区别
在语法概念上引用就是一个别名,没有独立空间,和其引用实体共用同一块空间
在底层实现上现实是有空间的,因为引用是按照指针方式来实现的,
[*]引用和指针的汇编代码对比
int main()
{
int a = 10;
int& ra = a;
ra = 20;
int* pa = &a;
*pa = 20;
return 0;
}
https://i-blog.csdnimg.cn/blog_migrate/3a60283f093f5165eee6e2f78f9ba96b.png
结论
引用和指针的不同点:
[*]引用概念上定义一个变量的别名(没有开辟空间),指针存储一个变量的地址
[*]引用在定义时必须初始化,指针没有要求
[*]引用在初始化时引用一个实体后,就不能再引用其他实体,而指针可以在任何时候指向任何一个同类型
实体
[*]没有NULL引用,但有NULL指针
[*]在sizeof中寄义不同：引用结果为引用变量类型的大小,但指针始终是地址空间所占字节个数(32位平台下占4个字节,64位平台下占8个字节)
int a = 0;
int& b = a;
sizeof(b) ? ==> sizeof(b) == sizeof(a) == sizeof(int)
char c ='a';
char&d = c;
sizeof(d) -> sizeof(c) == sizeof(char) = 1
[*]引用自加即引用的实体增加1,指针自加即指针向后偏移一个类型的大小
[*]有多级指针,但是没有多级引用
[*]访问实体方式不同,指针必要显式解引用,引用编译器本身处理
[*]引用比指针利用起来相对更安全
相同点
底层的实现方式相同,都是按指针的方式实现
https://i-blog.csdnimg.cn/blog_migrate/499cdb92d72459102f0c87f27e645cc2.png
第一条汇编：把1放到a空间
后面的汇编都是一样的：取出a的地址放在寄存器eax中,把eax寄存器的值放到b变量中
如果要连续定义指针/引用,每个名字都必要以* / &开头
int a = 10;
int& b = a,&c = a;//c前面的&不可省略,不然c就是个变量,相当于int c = a;
//这个和指针也一样
int *a,b;//a是指针,b是变量
int*a,*b;//a,b都是指针
问：下面两个函数是否构成函数重载
void func(int* ps)
{
cout << " func(int* ps)" << endl;
}
void func(int& p)
{
cout << " func(int& p)" << endl;
}
int main()
{
int a = 10;
func(&a);
func(a);
}
二者构成函数重载,指针和引用是不同的类型,
https://i-blog.csdnimg.cn/blog_migrate/3bbf8e1c4f23780c0e2ce5ab7a166b76.png
指针利用更复杂,更容易堕落
void f1(int* ps)
{
*ps = 10;
}
void f2(int& p)
{
p = 10;
}
int main()
{
int a = 10;
//正常传参
f1(&a);
f2(a);
//引起f1程序崩溃的方法
f1(NULL);
f1(0);
//但是如果按上述方式传给f2-直接报错,在编译层就检查出来了
f2(NULL);
f2(0);
return 0;
}
利用指针要思量空指针,野指针等等问题,指针太机动了,所以相对而言,没有引用安全
相同类型之间赋值不会产生临时变量,不同类型转化赋值会产生临时变量,临时变量具有常属性
int a = 10;
int b = a;//不会产生临时变量
double d = a;//会产生临时变量
函数返回值,表达式会产生临时变量
int a = 10;
int b = 5;
int c = a+b;//会产生临时变量
int test()
{
int a = 10;
return a;//会产生临时变量
}
7.内联函数
概念
以inline修饰的函数叫做内联函数,编译时C++编译器会在调用内联函数的地方展开,没有函数压栈的开销,内联函数提升程序运行的效率
内联函数的引入
调用函数,必要创建栈帧,栈帧中要保存一些寄存去,竣过后又要规复,这些都是有消耗的,对于频繁调用的函数,可以优化！
int Add(intx,int y)
{
int ret = x+ y;
return ret;
}
int main()
{
Add(1,2);
Add(1,2);
Add(1,2);
Add(1,2);
return 0;
}
C中的优化方式：可以利用宏
宏是单纯的文本替换,效率高
写两个数相加的宏-技巧：宏的原理是替换,本身替换进去看对不对
下面是错误写法
#define Add(int x,int y) {return x+y;}
#define Add(x,y) x+y; //1
#define ADD(x,y) x+y//2
#define Add(x,y) (x+y)//3
对于写法0：宏是直接举行文本替换,所以不消写类型吸收
函数调用把实参传给形参才必要吸收参数
对于写法1：宏后面不加分号
cout<<Add(1,2)<<endl;//替换后：cout<<x+y;<<endl;
<<前有分号,编译时会发生错误,
对于写法2：运算结果可能堕落
cout<<Add(2,3)*10<<endl;//替换后：cout<<2+3*10<<endl
打印结果为：32,而我们想要得到的结果是5*10 = 50
对于写法3：运算优先级不同,可能导致结果堕落
cout<<Add(a|b,a&b)<<endl; //替换之后：cout<<(a|b + a& b)<<endl
+的优先级更高,相当于a|(a+b)&b,结果错误
正确写法
#define Add(x,y) ((x)+(y))
C++优化方式：利用内联函数
利用内联函数之后,在release模式下,函数不会创建栈帧,直接调用该函数的地方举行展开
https://i-blog.csdnimg.cn/blog_migrate/40640d40332f02b23af806e63db07639.png
https://i-blog.csdnimg.cn/blog_migrate/9c318411f085859147c437123ce284c4.png
内联函数会在调用位置自动展开
如果在上述函数前增加inline关键字将其改成内联函数,在编译期间编译器会用函数体替换函数的调用,
查看方式：
[*]在release模式下,查看编译器生成的汇编代码中是否存在call Add
[*]在debug模式下,必要对编译器举行设置,否则不会展开
https://i-blog.csdnimg.cn/blog_migrate/dc088a40df9119012bacc3025f799677.png
特性 :在编译阶段,会将内联函数展开 -----将函数调用直接利用函数体举行替换
[*] inline是一种以空间换时间的做法,省去调用函数额开销,所以代码很长或者有循环/递归的函数不适宜利用作为内联函数
[*]代码很长：10行以上(取决于编译器的不同)
[*]为什么是以空间换时间：
inline void func()
{
//假设编译后是10行代码
}
假设有1000次调用func函数,展开和不展开时,编译后是多少行代码
[*]不展开时候： 10(func编译后的10行)+ 1000(1000次call func() )
[*]展开的时候： 10*1000次(每次调用都展开,共调用1000次)
综上：长代码函数 和递归函数不适合展开,调用的地方很多,展开后程序可能会变的很大
2.inline对于编译器而言只是一个发起,编译器会自动优化,如果定义为inline的函数体内有循环/递归等等,编译器优化时会忽略掉内联,
3.inline不发起声明和定义分离,分离会导致链接错误,因为inline被展开,就没有函数地址了,链接就会找不到,
内联函数会被认为在调用的地方直接展开,所以内联函数不会生成函数的地址,不存在链接的时候要去找内联函数的地址,在调用的时候就展开了
例子：
https://i-blog.csdnimg.cn/blog_migrate/20554df9020f57089a7e16384e41ad98.png
结论：短小,频繁调用的函数发起定义成inline(内联函数)
面试题：宏的优缺点
优点
[*]1.增强代码的复用性,
[*]2.进步性能
缺点
[*]1.不方便调试宏,（因为预编译阶段举行了替换）
[*]2.导致代码可读性差,可维护性差,容易误用,
[*]3.没有类型安全的检查,
C++有哪些技术替换宏
[*]1.常量定义换用const
[*]2.函数定义换用内联函数
8.auto关键字(C++11)
简介：
在早期C/C++中auto的寄义是：利用auto修饰的变量,是具有自动存储器的局部变量
C++11中,标准委员会赋予了auto全新的寄义即：auto不再是一个存储类型指示符,而是作为一个新的类型
指示符来指示编译器,auto声明的变量必须由编译器在编译时期推导而得,
注意事项
利用auto定义变量时必须对其举行初始化,在编译阶段编译器必要根据初始化表达式来推导auto的现实类
型,因此auto并非是一种“类型”的声明,而是一个类型声明时的“占位符”,编译器在编译期会将auto替换为
变量现实的类型,
typeid:打印变量的类型
int main()
{
int a = 10;
//auto:自动推导变量的类型
auto c = a;
auto d = 'a';
auto x = 10.10;
//typeid打印变量的类型
cout << typeid(c).name() << endl;//int
cout << typeid(d).name() << endl;//char
cout << typeid(x).name() << endl;//double
return 0;
}
注意：推导时：会舍弃const属性,但是指针不会
https://i-blog.csdnimg.cn/blog_migrate/fbcbb168f1343a39c40897394188b4e0.png
https://i-blog.csdnimg.cn/blog_migrate/b73ad6d46b5acd0925acffa3b5408f70.png
a是const修饰的,不可以修改!
auto可以识别结构体类型
https://i-blog.csdnimg.cn/blog_migrate/9dd656bacb3d982f28fdcc8c49cfff18.png
auto利用规则
1.auto与指针和引用结合起来利用
用auto声明指针类型时,用auto和auto*没有任何区别,但用auto声明引用类型时则必须加&
int main()
{
int x = 10;
auto a = &x;
auto* b = &x;
auto& c = x;//c是x的别名
cout << typeid(a).name() << endl;
cout << typeid(b).name() << endl;
cout << typeid(c).name() << endl;
return 0;
}
https://i-blog.csdnimg.cn/blog_migrate/1b783f5b377be4dcd695b2f485ffb4fe.png
2.在同一行定义多个变量
当在同一行声明多个变量时,这些变量必须是相同的类型,否则编译器将会报错,因为编译器现实只对
第一个类型举行推导,然后用推导出来的类型定义其他变量,
https://i-blog.csdnimg.cn/blog_migrate/e8dd4eb294f04470d9b23e577ad31b3e.png
//在同一行定义多个变量
auto x = 10, y = 20;
auto不能独立定义
auto i;//err
https://i-blog.csdnimg.cn/blog_migrate/add97b292bb754410b5cb8a9a04c6b67.png
auto不能推导的场景
1.auto不能作为函数的参数
// 此处代码编译失败,auto不能作为形参类型,因为编译器无法对a的实际类型进行推导
void TestAuto(auto a) //err
{}
2.auto不能直接用来声明数组
void TestAuto()
{
int a = {1,2,3};
auto b = {4,5,6};//err
}
3.为了避免与C++98中的auto发生肴杂,C++11只保留了auto作为类型指示符的用法
4.auto在现实中最常见的优势用法就是跟以后会讲到的C++11提供的新式for循环,另有lambda表达式等
举行共同利用,
9.基于范围的for循环(C++11)
语法
对于一个有范围的聚集而言,由程序员来说明循环的范围是多余的,有时候还会容易犯错误,因此C++11中
引入了基于范围的for循环,for循环后的括号由冒号“：”分为两部分：第一部分是范围内用于迭代的变量,
第二部分则表示被迭代的范围,
int main()
{
int arr[] = { 1,2,3,4,5,6 };
int sz = sizeof(arr) / sizeof(arr);
//C/C++遍历数组
for (int i = 0; i < sz; i++)
{
cout << arr << endl;
}
printf("end\n");
//C++11 范围for
//自动依次取数组arr中的元素赋给e
for (auto e : arr)
{
cout << e << endl;
}
/*这样也属于范围for,用auto自动推导更优
for(int x : arr)
{
cout << x << endl;
}
*/
return 0;
}
https://i-blog.csdnimg.cn/blog_migrate/ece16a173d06ce0b2e9fe13a8a6e0275.png
注意：与普通循环类似,可以用continue来竣事本次循环,也可以用break来跳出整个循环,
想利用范围for,把数组的每个值+1
//err
int main()
{
int arr[] = { 1,2,3,4,5,6 };
//C++11 范围for
//自动依次取数组arr中的元素赋给e
for (auto e : arr)
{
e++;
}
for (auto e : arr)
{
cout << e << endl;
}
return 0;
}
https://i-blog.csdnimg.cn/blog_migrate/f0645d867efb9b9adcbc6891a86f5f2e.png
e是局部变量,e++了,但是不影响数组内里的元素的值,相当于值传递
解决办法：用引用
int main()
{
int arr[] = { 1,2,3,4,5,6 };
//C++11 范围for
//自动依次取数组arr中的元素赋给e
//让数组每个值+1
for (auto& e : arr)
{
e++;
}
for (auto e : arr)
{
cout << e << endl;
}
return 0;
}
https://i-blog.csdnimg.cn/blog_migrate/18eb8c70f537920b6f0b8337b22ec956.png
此时e++就是数组元素的值++
提出疑问：这个arr,arr什么的别名不全都是e了吗?
解答：可以认为e的生命周期是一次循环,不是整个循环,每次e代表的只是一个元素的别名
ERR写法
for(auto* e : arr)
{
//e++
}
https://i-blog.csdnimg.cn/blog_migrate/a8f5fea3419e54f9ef55444c3a134dff.png
取出的数组中的每个数据是int类型,int类型赋值给int*类型,err
范围for的利用条件：
1.for循环迭代的范围必须是确定的
对于数组而言,就是数组中第一个元素和末了一个元素的范围；对于类而言,应该提供begin和end的
方法,begin和end就是for循环迭代的范围,
范围for：自动判断竣事
注意：以下代码就有问题,因为for的范围不确定
void TestFor(int* a)
{
for (auto& e : a)
{
cout << e << endl;
}
}
范围for内里必须是数组名
数组传参降级为指针
2.迭代的对象要实现++和==的操作,(关于迭代器这个问题,以后会讲,现在大家了解一下就可以了)
10.指针空值nullptr(C++11)
C++98中的指针空值
在良好的C/C++编程风俗中,声明一个变量时最好给该变量一个符合的初始值,否则可能会出现不可预料的
错误,比如未初始化的指针,如果一个指针没有合法的指向,我们基本都是按照如下方式对其举行初始化：
NULL现实是一个宏,在传统的C头文件(stddef.h)中,可以看到如下代码：
https://i-blog.csdnimg.cn/blog_migrate/b1afe47b166924282bd4d5f11a12297c.png
_cplusplus是c++程序的标识符,这里是条件编译！如果是C++文件,NULL被认为是0,否则(C语言)NULL被认为是指针
可以看到,NULL可能被定义为字面常量0,或者被定义为无类型指针(void*)的常量,不论采取何种定义,在
利用空值的指针时,都不可避免的会遇到一些贫苦,比如：
void f(int)
{
cout << "f(int)" << endl;
}
void f(int*)
{
cout << "f(int*)" << endl;
}
int main()
{
f(0);
f(NULL);
f((int*)NULL);
return 0;
}
https://i-blog.csdnimg.cn/blog_migrate/c9285c7fe949f2a5f56186cee26d5043.png
程序本意是想通过f(NULL)调用指针版本的f(int*)函数,但是由于NULL被定义成0,因此与程序的初志相悖,
在C++98中,字面常量0既可以是一个整形数字,也可以是无类型的指针(void*)常量,但是编译器默认环境下
将其当作是一个整形常量,如果要将其按照指针方式来利用,必须对其举行强转(void *)0,
f(nullptr); -> 打印f(int*)
注意点：
1.在利用nullptr表示指针空值时,不必要包含头文件,因为nullptr是C++11作为新关键字引入的,
2.在C++11中,sizeof(nullptr)与 sizeof((void*)0)所占的字节数相同,
https://i-blog.csdnimg.cn/blog_migrate/fd282e52bb1b2bd1ffb261a4a2758bba.png
3.为了进步代码的健壮性,在后续表示指针空值时发起最好利用nullptr,
C语言环境下,NULL没问题,因为并支持函数重载！
为了方便,后续可以用用nullptr取代NULL,nullptr就是空指针(void *)0
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。
页:
[1]