C89:论常量(const)

一.Const常量

1.作用

Const修饰的数据类型是指常类型,常类型的变量或对象的值是不能被更新的

用来提高程序的安全性和可靠性(其实我一般都觉得可加可不加,但是加了代码当然更好啦)

它推出的初始目的是为了取代预编译指令,因为const定义的常量在程序运行中只有一份拷贝,而#define定义的常量在内存中有若干个拷贝

非Const类型可以赋值给Const类型,而Const类型不能赋值给非Const类型
Const修饰的数据类型必须赋初值

2.修饰内置类型变量

//(1)基本类型
int A;            //变量
const int a=1;    //常量
a=2;              //错误,常量不可变
 
int const b=2;    //常量
b=3;              //错误,常量不可变
 
 
 
//(2)指针判断const在*左边还是右边结合
const int* p=&A;            //常量数据,变量指针
int const* p=&A;            //常量数据,变量指针
p=&a;                       //正确,变量指针可以变
*p=a;                       //错误,常量数据不能变
 
 
int* const p=&A;            //变量数据,常量指针
p=&a;                       //错误,常量指针不能变
*p=a;                       //正确,变量数据可以变
 
 
const int* const a=&A;      //常量数据,常量指针
a=&a;                       //错误
*a=a;                       //错误 

3.修饰函数参数

//值传递
void A(const int a){     //因为是两块不同的内存,只能锁定函数内的参数变量内存无法修改
    a=3;                 //错误,无法进行修改
}  
 
//引用传递
void A(const int& a){    //引用的原来的数据内存,该内存的值不能变
    a=3;                 //错误,无法进行修改
}  
 
 
//指针传递
void A(const int* a){    //指向的数据不能变,表明该指针无法修改指向内存的值
    int b=1;
    a=&b;        //正确,传递进来的指针变量可以变
    *a=2;        //错误,传递进来的指针变量所指向的值不能变
}  
 
//注意:指针传递的本质也是值传递,任何对形参的指针变量的改变都不会影响到实参的指针变量,只有对形参的指针变量所指向的内存进行修改,才会影响到实参的指针变量所指向的内存
void A(int* const a){
    int b=1;
    a=&b;        //错误,传递进来的指针变量不能变
    *a=2;        //正确,传递进来的指针变量所指向的值不能变
}

4.修饰返回值

//值传递
const int a(){}      //无意义,返回值加上常量对形参和实参并不会有任何作用和改变
 
//引用传递
const int& a(){}    //会报警告,不建议这么写
 
 
//指针传递    
const int* A(const int* p){    //用常量指针做返回值,用来接收的指针也必须是常量指针
    return p;
}
 
int B(){
    int data=5;
    const int* p=&data;
    p=A(p);    //返回常量指针
}
 
int* const A(){...}  //无意义,这么写对形参和实参并不会有任何作用和改变
                     //因为指针变量被返回之后,自身的改变已经无意义,重要的是它指向的内存是不是常量
 
 
//注意,非成员函数不允许用const修饰函数
int* A()const{...}    //错误,普通函数不能用const进行限定
 
//注意,const int*无法转换为int*,常量指针无法转换为变量指针
//但是,int*可以转换为const int*,变量指针可以转换为常量指针

5.修饰成员函数

注意:const修饰成员函数这个功能只有在C++有

int A() const{}    //错误,普通函数无法加上限定符,只能修饰成员函数
 
 
class A{
    
public:
    
    //对调用的成员变量和成员函数进行限定
    //const修饰的成员函数不能修改任何成员变量(除了mutable修饰的变量)
    //const修饰的成员函数不能调用非const成员函数,因为非const成员函数会修改成员变量
    void a()const;
    
 
};