C++： 总结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函数，将原有空间进行骚扰，将原来定义数组的值覆盖。
程序运行，打印出随机值。