C const - 《编程技术》

静态常量整型成员在class内部直接初始化
const区分技巧

const char* p = greeting; //指针可变，数据不可变
char* const p = greeting; //指针不可变，数据可变
const char* const p = greeting; //指针和数据均不可变
//const出现在星号的左边，表示所指之物是不可变的
//const出现在星号的右边，表示指针本身是不可变的

欲阻止一个变量被改变，可以使用const关键字。在定义该const变量时，通常需要对它进行初始化，因为以后就没有机会再去改变它了；
对指针来说，可以指定指针本身为const，也可以指定指针所指的数据为const，或二者同时指定为const；
在一个函数声明中，const可以修饰形参，表明它是一个输入参数，在函数内部不能改变其值；
对于类的成员函数，若指定其为const类型，则表明其是一个常函数，不能修改类的成员变量；(相当于指定this指针为const, const *this)

When you add the const keyword to a method the this pointer will essentially become a pointer to const object, and you cannot therefore change any member data. (Unless you use mutable, more on that later).
const修饰类的成员变量，表示成员常量，不能被修改。
对于const函数的重载，const对象只能调用const函数，非const对象优先调用非const函数。
const函数只能调用const函数，非const函数可以调用const函数。
类外定义的const成员函数，在定义和声明处都需要const修饰符。

/ 类
class A
{
private:
    const int a;                // 常对象成员，只能在初始化列表赋值
public:
    // 构造函数
    A() : a(0) { };
    A(int x) : a(x) { };        // 初始化列表
    // const可用于对重载函数的区分
    int getValue();             // 普通成员函数
    int getValue() const;       // 常成员函数，不得修改类中的任何数据成员的值
};
void function()
{
    // 对象
    A b;                        // 普通对象，可以调用全部成员函数、更新常成员变量
    const A a;                  // 常对象，只能调用常成员函数
    const A *p = &a;            // 指针变量，指向常对象
    const A &q = a;             // 指向常对象的引用
    // 指针
    char greeting[] = "Hello";
    char* p1 = greeting;                // 指针变量，指向字符数组变量
    const char* p2 = greeting;          // 指针变量，指向字符数组常量（const 后面是 char，说明指向的字符（char）不可改变）
    char* const p3 = greeting;          // 自身是常量的指针，指向字符数组变量（const 后面是 p3，说明 p3 指针自身不可改变）
    const char* const p4 = greeting;    // 自身是常量的指针，指向字符数组常量
}
// 函数
void function1(const int Var);           // 传递过来的参数在函数内不可变
void function2(const char* Var);         // 参数指针所指内容为常量
void function3(char* const Var);         // 参数指针为常量
void function4(const int& Var);          // 引用参数在函数内为常量
// 函数返回值
const int function5();      // 返回一个常数
const int* function6();     // 返回一个指向常量的指针变量，使用：const int *p = function6();
int* const function7();     // 返回一个指向变量的常指针，使用：int* const p = function7();

const Class_Name Object_name;
//当一个函数被声明为const，它既可以被const的object调用，也可以被non-const的object调用
//无论是声明成const的object还是声明成普通的object，都需要利用构造函数的初始化列表在初始化期间进行初始化
//When a function is declared as const, it can be called on any type of object, const object as well as non-const objects.
//Whenever an object is declared as const, it needs to be initialized at the time of declaration. however, the object initialization while declaring is possible only with the help of constructors.
#include<iostream>
using namespace std;
class Sticker
{
    private:
    double Perimeter() const;
    double Area() const;
    double Height:
    public:
    void GetDimensions();
    void Properties();
}
Sticker foo;
foo.Area(); // ok
foo.Properties(); // ok
const Sticker bar;
bar.Area(); // ok
bar.Properties(); // error, bar is const 
//如果使用const进行实例化，那么实例化的object是不可以调用非const成员函数的，因为编译器会去检查是否有对const进行修改的行为。

//A function becomes const when the const keyword is used in the function’s declaration. The idea of const functions is not to allow them to modify the object on which they are called. 
//It is recommended the practice to make as many functions const as possible so that accidental changes to objects are avoided.
#include<iostream> 
using namespace std; 
class Test { 
    int value; 
public: 
    Test(int v = 0) {value = v;} 
    // We get compiler error if we add a line like "value = 100;" 
    // in this function. 
    int getValue() const {return value;}   
}; 
int main() { 
    Test t(20); 
    cout<<t.getValue(); 
    return 0; 
} 
//output
20

non-const的function只能被non-const的object所调用
When a function is declared as const, it can be called on any type of object. Non-const functions can only be called by non-const objects.
如下例子会产生编译错误

#include<iostream> 
using namespace std; 
class Test { 
    int value; 
public: 
    Test(int v = 0) {value = v;} 
    int getValue() {return value;} 
}; 
int main() { 
    const Test t; 
    cout << t.getValue(); 
    return 0; 
} 
//Output
Passing 'const Test' as 'this' argument of 'int 
Test::getValue()' discards qualifiers

再看下面这个例子

filter_none
edit
play_arrow
brightness_4
// Demonstration of constant object,  
// show that constant object can only  
// call const member function 
#include<iostream> 
using namespace std; 
class Demo 
{ 
    int value; 
    public: 
    Demo(int v = 0) {value = v;} 
    void showMessage() 
    { 
        cout<<"Hello World We are Tushar, "
        "Ramswarup, Nilesh and Subhash Inside"
        " showMessage() Function"<<endl; 
    } 
    void display()const
    { 
        cout<<"Hello world I'm Rancho "
        "Baba Inside display() Function"<<endl; 
    } 
}; 
int main() 
{ 
   //Constant object are initialised at the time of declaration using constructor 
    const Demo d1; 
    //d1.showMessage();Error occurred if uncomment. 
    d1.display(); 
    return(0); 
} 
//Output
Hello world I'm Rancho Baba Inside display() Function

静态常量整型成员在class内部直接初始化

#include <iostream>
using namespace std;
template <typename T>
class testclass {
    public:
        static const int _datai = 5;
        static const long _datal = 3L;
        static const char _datac = 'c';
};
int main()
{
    cout << testclass<int>::_datai << endl;
    cout << testclass<int>::_datal << endl;
    cout << testclass<int>::_datac << endl;
}

#include <iostream>
using namespace std;
class A
{
public:
    int var1, var2;
    A()
    {
        var1 = 10;
        var2 = 20;
    }
    void fun() const // 不能在 const 修饰的成员函数中修改成员变量的值，除非该成员变量用 mutable 修饰
    {
        var1 = 100; // error: assignment of member 'A::var1' in read-only object
    }
};
int main()
{
    A ex1;
    return 0;
}

如果想达到一个类的成员函数不能修改类的成员变量，只需用 const 关键字来修饰该函数即可。

const区分技巧

区分各种const，只要从右往左读即可

int const *: pointer to const int //等价于const int*
int const* const: const pointer to const int
int *const: const pointer to int
int *const *:pointer to const  pointer to int