总结const与指针和引用的关系
一、总结const与指针的关系
4种const位置
int a=10,int b=20;
int *p1=&a; //自由的指针
int const *p2=&a;
const int *p2=&a; //约束指向的能力，指向为常性
int *const p3=&a; //p3自身为常性
const int * const p4=&a; //约束自身和指向
能力只能进行收缩而不能扩张
int a=10,b=20;
const ints=&a;//约束s指向
int p1=s; //错误，通过p1可以改变s的值，能力扩张
int const*p2=s;
int *const p3=s; //错误
const int *const p4=s;
int a=10,b=20;
int *const s=&a;
int p1=s;
int constp2=s;
int *const p3=s;
const int *const p4=s;
以上都可以编译通过
const int a=10; //常性变量a
int *p=&a; //编译不通过
const int *p=&a; //ok
int p=(int)&a;
C++和C对常变量的编译
C++编译：
#include<iostream>
using namespace std;
int main()
{
const int a = 10;
int b = 0;
int* p=(int*)&a;
*p = 100;
b = a;//编译器看见a是常量时，在编译时把b替换为10
cout << "a=" << a << "b=" << b << "*p=" << *p << endl;
return 0;
}
C++编译规则，将const int a（常变量）当作常量，在编译时直接将a替换为10把10赋值给b，而不是将a的值读取出来赋给b。
C编译：
#include<stdio.h>
int main()
{
const int a = 10;
int b = 0;
int* p=(int*)&a;
*p = 100; //通过*p改变a的值
b = a;//从内存中取值，将a的值100赋值给b
printf("a=%d b=%d *p=%d\n", a, b, *p);
return 0;
}
C编译，通过*p改变a的值，从内存中取值将a的值100赋值给b.
怎么知道程序是被C方式编译还是被C++方式编译？
通过系统提供的宏 #ifdef __cplusplus
#ifdef __cplusplus //此宏名按照C++的方式编译
#include<iostream>
using namespace std;
#else
#include<stdio.h>
#endif
int main()
{
const int a = 10;
int b = 0;
int* p=(int*)&a; //ok
int *s=const_cast<int*>(&a); //去常性强转
*p = 100;
b = a;
#ifdef __cplusplus
cout << "a=" << a << "b=" << b << "*p=" << *p << endl;
#else
printf("a=%d b=%d *p=%d\n", a, b, *p);
#endif
return 0;
}
二、总结const与引用的关系
引用 （别名）
类型 &引用变量名称=变量名称。
引用在定义时必须初始化，没有所谓的空引用和引用的引用。
为什么引用在定义时必须给与初始化？
int a=10;
int &b=a;相当于int *const b=&a;
int *const b; b的自身属性为常性，b=&a错误，所以必须在定义时给与初始化。
int a=10;
int &b=a; //给变量a起别名
常引用
const int a=10;
int &b=a; //错误, 普通引用不能引用常变量，因为对b的改变会改变a, 但a是一个常性。
const int &b=a; //ok
int &c=(int&)a; //ok
引用和指针
int a=10,b=20;
int *p=&a;
int *s=p;
int *& rs=p;
int a=10,b=20;
int *s=&a;
int *& p1=s;
const int *& p2=s; // *p2=100；error *p2不能改变a的值，因为const 修饰p2的指向，如果p2=&b,s也要指向b,因为p2是s的别名。
int *const &p3=s; //*p3=100; ok p3=&b; error
const int *const &p4=s; //只能读取所指之物的值。
int *& const p3=s; 此处const 修饰引用，无意义。
引用本身属于常性。
int a=10,b=20;
const int *s=&a; //s指针指向为常性
int *& p1=s; //error，p1指向的改变会对s指向改变，能力扩展了。
const int *& p2=s;
int *const &p3=s; //error
const int *const &p4=s; //只能读取所指之物的值。
int a=10,b=20;
int *const s=&a; //s指针自身为常性
int *& p1=s; //error, p1改变会影响s改变，p1=&b影响s=&b,能力扩展了
const int *& p2=s; // error
int *const &p3=s; // ok
const int *const &p4=s; // ok
引用和指针的区别
从语义上来看，引用就是一个变量的别名，相当于给一个实体起了两个名字。
从底层来看，引用相当于一个自身为常性的指针。
int a=10;
int &b=a;相当于int *const b=&a;
引用相对安全。
引用的本质
引用是指针的语法层概念。
指针需要判空，引用没有空引用。
引用在底层是按照指针来处理的。
函数的返回类型是引用类型
#include<iostream>
using namespace std;
int fun()
{
int a = 10;
return a;
}
int& funref()
{
int a = 20;
return a;
}
int main()
{
int x = fun();
int y = funref();
int& z = funref();
cout << x << " " << y <<" "<<z<< endl;
return 0;
}
不允许对局部变量进行引用返回。
引用返回实际上返回的是局部变量的地址。
当函数结束时，分配给函数的空间会被回收，返回地址 错误。
虽然可能会得到正确的值，但是是从已失效的空间返回的，这是不允许的。
不能从已失效空间获取值。
== 当函数的生存期不会影响到变量的生存期，才可以用引用返回。
当变量是静态局部变量，或全局变量，或以引用传进去的变量时，可以用引用返回。==
#include<iostream>
using namespace std;
int* fun()
{
int ar[10] = { 12,23,34,45,56,67,78,89,90,100 };
return ar;
}
int main()
{
int* p = fun();
for (int i = 0; i < 10; i++)
{
printf("%p=>%d\n", p, *p);
p += 1;
}
return 0;
}
ar是数组首元素的地址，将它放到临时量，fun函数return后，分配的栈帧会被销毁；
main函数中，p虽然指向栈的空间，但这个空间已经还给系统了，是失效指针；
调用printf函数时，会把主函数上面的栈分配给printf函数，将原有空间进行骚扰，将原来定义数组的值覆盖。
程序运行，打印出随机值。
