【C++】const用法详解及其本质分析

一、const的用法

  const是不改变的。在C和C++中，我们使用关键字const来使程序元素保持不变。const关键字可以在C++程序的许多上下文中使用。它可以用于：

变量	指针	函数参数和返回类型
类数据成员	类成员函数	对象

1) const变量

  如果你用const关键字做任何变量，你就不能改变它的值。同样，必须在声明的时候初始化常数变量。

Example:

int main
{
    const int i = 10;
    const int j = i + 10;     // works fine
    i++;    // this leads to Compile time error   
}

  在上面的代码中，我们使 i 成为常量，因此如果我们试图改变它的值，我们将得到编译时错误。尽管我们可以用它来代替其他变量。

  

2)指针与const关键字

  指针也可以使用const关键字来声明。当我们使用const和指针时，我们可以用两种方式来做：可以把const应用到指针指向的地方，或者我们可以使指针本身成为一个常数。 

①指向const变量的指针：

  这意味着指针指向一个const变量。

const int* u;

  在这里，表示u是一个指针，可以指向const int类型变量。我们也可以这样写，

char const* v;

表示v是指向const类型的char的指针。

指向const变量的指针非常有用，因为它可以用来使任何字符串或数组不可变

②const指针

  为了使指针保持不变，我们必须把const关键字放到右边。

int x = 1;
int* const w = &x;

  这里，w是一个指针，它是const，指向一个int，现在我们不能改变指针，这意味着它总是指向变量x但是可以改变它指向的值，通过改变x的值。

    当你想要一个可以在值中改变但不会在内存中移动的存储器时，常量指针指向一个变量是很有用的。因为指针总是指向相同的内存位置，因为它是用const关键字定义的，但是那个内存位置的值可以被更改。

3）const函数参数和返回类型

void f(const int i)
{
    i++;    // error
}

const int g()
{
    return 1;
}

注意几个要点：

①对于建立在数据类型中，返回const或非const值，不会有任何影响。

const int h()
{
    return 1;
}

int main()
{
    const int j = h();
    int k = h();
}

j和k都将被赋值为1。不会出现错误。

②对于用户定义的数据类型，返回const，将阻止它的修改。

③在程序执行时创建的临时对象总是const类型。

 ④如果一个函数有一个非const参数，它在发出调用时不能传递const参数。

void t(int*) 
{ 
    // function logic
}

 如果我们把一个const int参数传递给函数t，会出现错误。

⑤但是，一个具有const类型参数的函数，可以传递一个const类型参数以及一个非const参数。

void g(const int*) 
{
    // function logic
}

这个函数可以有一个int，也可以有const int类型参数。

4）将类数据成员定义为const

  这些是类中的数据变量，使用const关键字定义。 它们在声明期间未初始化。 它们的初始化在构造函数中完成。

class Test
{
    const int i;
    public:
    Test (int x)
    {
        i = x;
    }
};

int main()
{
    Test t(10);
    Test s(20);
}

  在这个程序中，i 是一个常量数据成员，在每个对象中它的独立副本将会出现，因此它使用构造函数对每个对象进行初始化。一旦初始化，它的值就不能改变

5）把类对象定义为const

  当一个对象被声明或使用const关键字创建时，它的数据成员在对象的生命周期中永远不会被改变。

语法：

const class_name object;

  例如，如果在上面定义的类测试中，我们想要定义一个常数对象，我们可以这样做：

const Test r(30);

6）将类的成员函数定义为const

  const成员函数决不会修改对象中的数据成员。

语法：

return_type function_name() const;

const对象和const成员函数的例子：

class StarWars
{
    public:
    int i;
    StarWars(int x)    // constructor
    { 
        i = x; 
    }

    int falcon() const  // constant function
    { 
        /* 
            can do anything but will not
            modify any data members
        */
        cout << "Falcon has left the Base";
    }

    int gamma()
    { 
        i++; 
    }
};

int main()
{
    StarWars objOne(10);        // non const object
    const StarWars objTwo(20);      // const object

    objOne.falcon();     // No error
    objTwo.falcon();     // No error

    cout << objOne.i << objTwo.i;

    objOne.gamma();     // No error
    objTwo.gamma();     // Compile time error
}

输出结果：

Falcon has left the Base

Falcon has left the Base

10 20

  在这里，我们可以看到，const成员函数永远不会改变类的数据成员，并且它可以与const和非const对象一起使用。但是const对象不能与试图改变其数据成员的成员函数一起使用。

---

 

二、关于const的疑问：

1.const什么时候为只读变量？

2.const什么时候是常量？

const常量的判别标准：

1.只有字面量初始化的const常量才会进入符号表

2.使用其他变量初始化的const常量仍然是只读变量

3.被volatile修饰的const常量不会进入符号表

注意：

1.const引用的类型与初始化变量的类型相同时：初始化变量成为只读变量

2.const引用的类型与初始化变量的类型不相同时：初生成一个新的只读变量

Example:

#include <stdio.h>

int main()
{
    const int x = 1; //字面量初始化，此时x为常量，进入符号表
    const int& rx = x; //rx代表只读变量
    
    int& nrx = const_cast<int&>(rx); //去掉rx的只读属性
    
    nrx = 5;  //改变了nrx内存空间的值
    
    printf("x = %d\n", x); // 1
    printf("rx = %d\n", rx);  //  5
    printf("nrx = %d\n", nrx);  // 5
    printf("&x = %p\n", &x);  // &x = 002CFD80
    printf("&rx = %p\n", &rx);  // &x = 002CFD80
    printf("&nrx = %p\n", &nrx);  // &x = 002CFD80
    //输出的地址相同，说明了x、rx、nrx代表同样的内存空间
	
    volatile const int y = 2;//volatile代表易变的
    int* p = const_cast<int*>(&y);
    
    *p = 6;
    
    printf("y = %d\n", y);  //y = 6
    printf("p = %p\n", p);  //p = 001BF928
    
	//判别是否是常量是编译器在编译时能不能确认它的值
    const int z = y;
    
    p = const_cast<int*>(&z);
    
    *p = 7;
    
    printf("z = %d\n", z); // z = 7
    printf("p = %p\n", p); //p = 001BF910
    
    
    char c = 'c'; 
    char& rc = c;
    const int& trc = c;
    
    rc = 'a';
    
    printf("c = %c\n", c); // c = a
    printf("rc = %c\n", rc);// rc = a
    printf("trc = %c\n", trc);//trc = c
    //变量c是char类型，而trc是int类型，所以生成了一个新的只读变量


    return 0;
}

输出结果：

 

References：

1）唐佐林《C++深度解析教程》 

2）https://www.studytonight.com