C++,常量,const,constant,引用,指针,形参,实参,函数,返回值

关键字：C++,常量,const,constant,引用,指针,形参,实参,函数,返回值

 

const常量可以传值给变量,const常量本身的值不能修改

    1.不能将const修饰的任何对象、引用和指针作为赋值表达式的左值。
const int cx=100;
const int & rcx=cx;
const int * pcx=&cx;
cx=200;                 //error
rcx=200;                //error
*pcx=200;               //error

    2.const类型的对象不能直接被non-const类型的别名所引用。
(1)不能将const类型的对象传递给non-const类型的引用。
const int cx=100;
int & rx=cx;            //error
(2)不能将const类型的实参传递给形参为non-const类型引用的函数。
void f(int a)
{
}
void g(int & ra)
{
}
const int cx=100;
f(cx);                  //ok
g(cx);                  //error
(3)不能将const类型的对象作为non-const类型引用的函数返回值。
int & f(const int & rca)
{
return rca;       //error
}
int x=100;
f(x);

    3.可以使用const类型别名引用non-const对象。此时通过const引用不能修改对象，但对象可以通过non-const引用被修改。
int x=100;
int & rx=x;
const int & rcx=x;      //ok
x=200;
rx=200;
rcx=200;                //error

    4.指针的属性有两个：指针的类型和指针本身的常量性。其中，指向const对象与指向non-const对象，是不同的指针类型。
int x=100;
const int * pcx=&x;     //[1]
int * px=&x;            //[2]
int y=100;
int * const cpy=&y;     //[3]
int * py=&y;            //[4]
[1][2]两个指针的类型不同；[3][4]两个指针的常量性不同。
对象与指向对象的指针的规则类似于对象与引用。即，const类型的对象不能直接被non-const类型的指针所指示（同2）；可以使用const类型的指针指向non-const对象（同3）。

    5.可以将相同类型（包括常量性）的const指针值赋给non-const指针。
int x=100;
int * px;
const int * pcx=&x;
px=pcx;                 //error
int * const cpx=&x;
px=cpx;                 //ok

    6.若函数的返回值为内建类型或是指针，则该返回值自动成为const性质。但自定义类型则为non-const性质。
int f()                 //相当于返回const int
{
return 100;
}
int * g(int & ra)       //相当于返回int * const
{
return &ra;
}
class CTest
{
int n;
public:
CTest(int n){this->n=n;}
};
CTest h()               //返回的就是CTest
{
return CTest(200);
}

        f()=200;                //error

        int x=100;
int y=200;
int * px=&x;
g(y)=px;                //error
*g(y)=x;                //ok，从这点可以看出g()返回的不是const int *

CTest t(100);
h()=t;                  //ok，但却是完全错误的、危险的做法
//所以h()的正确写法是返回const CTest