C++ const

目的: 值代替。 

预处理宏定义的缺点: 只做文本替换，并没有类型检查，这样会产生风险。


      

内存存储形式，常量折叠

常量的定义会保存在符号表中，可折叠的常量像宏一样，在预编译阶段对常量的引用一律被替换为常量所对应的值。但在运行时常量也是会被分配内存空间的。

下面的程序可以说明。 

    int main()  
    {  
        const int i=0;
        int *j = (int *) &i;
        *j=1;
        printf(" addr_i=%d\n addr_j=%d\n val_i=%d\n val_j=%d\n",&i,j,i,*j);
        return 0;  
    }

运行时指针j是可以取得常量i的地址，但无法修改地址中的值，原因是预编译时常量i已经通过常量折叠进行了替换，
在运行时用到i的地方已经替换为0，但i在内存中还是被分配了空间的。

使用形式:

    1) 普通常量

        const int ArrSize=10;
        int arr[ArrSize];

    2) 常量集合

   常量也可以用于集合，但集合无法被放入符号表中，必须分配内存。此时常量的含义是 "不能改变的一块存储"。

        // 正确
const int SizeArr[] = {1,2,3,4};

// 下面的使用方法是错误的
                float farr[SizeArr[2]];   //错误
原因： 常量集合SizeArr无法被保存到符号表中，所以预编译时无法对SizeArr[2]进行替换。

                从编译时提示的错误信息也可以看的很清楚
                error C2057: expected constant expression
                error C2466: cannot allocate an array of constant size 0
                error C2133: 'farr' : unknown size

    3) 指针

                指向const指针    const int* x;     int const* x;
一个指针，指向一个const 变量， 不需要初始化，可以指向不同的常量。  地址可变：：值不可变

        const int i=10;
        const int j = 100;

        const int* x;
    
	x = &i;
	cout << *x << endl;

        x = &j;
	cout << *x << endl;

	*x = 5;   //  错误 error C3892: 'x' : you cannot assign to a variable that is const

        const 指针    int* const x;

指针本身为const指针，指针指向的地址不能改变，必须初始化。   地址不可变：：值可变

        int i = 5;
	int* const x = &i;

        *x = 15;
	cout << *x << endl;         // output : 15

        i = 25;
	cout << *x << endl;         // output : 25

4) 函数参数和返回值

   const 参数:    void fun1(const int i)
   void fun1(const int i)
    {
   i++;    // 错误  error C3892: 'i' : you cannot assign to a variable that is const
    }
           当以穿值方式向函数中传递参数时，会发生创建副本的情况，const也作为副本的一部分在函数中生效。


    但把这个过程呈现出来更好些，效果是一样的。
   void fun1(int i)
    {
   const int ic = i;
    }

            但函数接口如果是传引用或指针，如果不希望被修改最好还是用const。

   const 返回值:

       const 如果用于简单类型的返回值，并没有太大意义。 例如：
    const int fun2()
    {
   return 0;
    }


    用于用户自定义类型的比较有意义的。 例如:

        class X
        {
	    int _i = 0;
	public:
	    X(int i):_i(i){};
	    void modify(){_i++;}
	};
		
	X func3(){return X();}
	const X func4(){return X();}
		
	void func5(X &x){x.modify();}
		
	void main()
	{
	    func3() = X(1);
	    func3().modify();
	    func5(func3());
			
	    func4() = X(1);    // 错误
	    func4().modify();  // 错误
	    func5(func4());    // 错误
	}

这里对于返回对象为const的是无法进行修改的，在实际应用中是有意义的。

如果传递的参数为指针或地址，如果不希望参数在函数执行过程中被改变，尽可能的用const进行修饰。

类中的const类型

    错误的使用

    class A
    {
    private:
        const int _size=100;     // 非 static 的 const型无法在类中被初始化
        int _arr[_size];         // 所以此处也无法确定数组的大小
    public:
        A(){};
    };

    正确的使用

    class A
    {
    private:
        const int _size;
        int *_arr;
    public:
        A() : _size(100){_arr = new int[_size]};
    };

    class A
    {
    private:
        enum {_size=100};
        int _arr[_size];
    public:
        A(){};
    };

   const 对象和成员函数

    有个对象，如果被定义为const，在应用的过程中，它的行为应该是怎样的？
    怎样保证 const 对象在调用它自身的成员函数时保证对象不会被改变?

    例如一个类 B

    class B
    {
    private:
        int _i;
    public:
        B(int i): _i(i) {};
        void add();
        int const_add() const;    // const 成员函数
        void show() const;        // const 成员函数
    };

    void B::add()  {  _i++;  }

    void B::show() const
    {  cout << _i << endl;  }

    int B::const_add() const
    {
       //_i++;                    // 错误： 在const 成员函数中尝试改变对象的成员变量
       return _i;
    }

    int main()
    {
        B b(2);
        const B cb(4);

        b.add();
        b.const_add();
        b.show();

        cb.add();                 // 错误： cb 为 const 类型，不能通过cb的成员函数修改cb。
        cb.const_add();
        cb.show();

        return 0;
    }

    如何修改const 对象中的成员变量，使用关键字 mutable

    class Y
    {
        int _i;
        mutable int _j;
    public:
        Y(){};
        void addi() const;
        void addj() const;
    };


    void Y::addi() {_i++;}       // 错误:  通过const 成员函数修改成员变量
    void Y::addj() {_j++;}       // 正确:  _j 为mutable类型，可以跳过 const 限制

    int main()
    {
        const Y cy;
        cy.addi();
        cy.addj();

        return 0;
    }