javaer学c++: const关键字

[size=medium]
c++中的const和java中的final类似, 表示不可变的意思, 但java中的final仅仅用在这几个地方:
（1）修饰变量, 如:
public final int age; // 不可变成员
public static final int TYPE_A = 1; // 常量
（2）修饰方法, 表示方法不可被Override覆盖, 即去除方法的多态性.
（3）修饰局部变量, 也是不可变.
（4）修饰类, 表示类不可被继承

而c++中的const功能就多了:
（1）修饰全局变量: 表示变量值不可修改
[/size]
Main.cpp

#include <iostream>
using namespace std;

const int g_int = 10;

int main(void)
{
    g_int = 11;
    cout << "g_int:" << g_int << '\n';
    return 0;
}

[size=medium]
编译的话会得到assignment of read-only variable 'g_int'的编译错误, 表示g_int的值是只读的, 不可修改.


（2）修饰局部变量: 表示变量值不可修改
[/size]
Main.cpp

#include <iostream>
using namesapce std;

int main(void)
{
    const int i = 10;
    i = 11;
    cout << "i:" << i << '\n';
    return 0;
}

[size=medium]
编译时会得到assignment of read-only variable 'i'的错误, 表示i是只读的, 值不可被修改.


（3）
（3-1）修饰指针变量的值: 表示指针变量的值不可修改, 也这样的变量也可以叫做"指针常量".
（3-2）修饰指针变量所指向的内容: 表示不能修改指针变量所指向的内容, 这样的变量也可以叫做. "常量指针"
[/size]
Main.cpp

void test(
    int * const p1, // 指针常量
    int const * p2, // 常量指针
    const int *p3  // 常量指针
)
{
    // 修改变量的值
    int i = 10;
    // p1 = &i; // 指针常量, 变量值不可修改
    p2 = &i;
    p3 = &i;

    // 修改所指内容
    *p1 = 10;
    // *p2 = 10; // 常量指针, 所指内容不可修改
    // *p3 = 10; // 常量指针, 所指内容不可修改
}

int main(void)
{
    int a = 10;
    int b = 20;
    int c = 30;
    test(&a, &b, &c);
}

[size=medium]
（4）
（4-1）修饰对象, 表示对象值不可修改
（4-2）修饰对象引用, 也表示对象值不可修改
[/size]
Main.cpp

struct Data
{
    int m_int;
}

void test(
    const Data obj1,
    Data const obj2, // obj1和obj2的效果相同
    const Data &obj3,
    Data const &obj4 // obj3和obj4的效果相同
    // Data & const obj5 // 没有这样的语法
)
{
    //obj1.m_int = 1;
    //obj2.m_int = 2;
    //obj3.m_int = 3;
    //obj4.m_int = 4;
}

int main(void)
{
    Data d1;
    Data d2;
    Data d3;
    Data d4;
    test(d1, d2, d3, d4);
    return 0;
}

[size=medium]
会得到编译错误, obj1-4的值均不可修改.


（5）放在方法的返回类型前:
（5-1）修饰基本数据类型的返回值, 如int, char, bool, 没有实际意义, 因为仅仅是一个值, 返回的值赋给某个变量后, 那个变量还是可以被修改.
[/size]
Main.cpp

#include <iostream>
using namespace std;

int constMethod()
{
    return 3;
}

int main(void)
{
    int i = constMethod();
    cout << "i:" << i << '\n';

    i = 2;
    cout << "i:" << i << '\n';
}

[size=medium]
可以正常编译并运行, 且第一次输出3, 第二次输出2.

（5-2）修饰指针类型的返回值
[/size]
Main.cpp

class Data
{
public:
    int m_int;
}


class Const
{
private:
    Data *m_pt;
public:
    void init(void) { m_pt = new Data(); }

    void finalize(void) { delete m_pt; }

    const Data * getPt_01() { return m_pt; } // 返回常量指针
    Data const * getPt_02() { return m_pt; } // 返回常量指针
    Data * const getPt_03() { return m_pt; } // 返回指针常量
}


int main(void)
{
    Const c;
    c.init();

    // error: invalid conversion from 'const Data*' to 'Data*', 常量指针无法赋值给普通指针, 因为普通指针可以修改指针所指内容, 而常量指针不可以
    // Data *pt_01 = c.getPt_01();
    // Data *pt_02 = c.getPt_02();
    Data *pt_03 = c.getPt_03();

    // 下面3个都可以
    const Data *pt_04 = c.getPt_01();
    const Data *pt_05 = c.getPt_02();
    const Data *pt_06 = c.getPt_03();

    c.finalize();
    return 0;
}

[size=medium]
（5-2）修饰引用类型的返回值
[/size]
Main.cpp

class Data
{
public:
    int m_int;
}

class Const
{
private:
    Data m_obj;
public:
    const Data & getObj_01()
    {
        return m_obj;
    }

    Data const & getObj_02()
    {
        return m_obj;
    }

    //Data & const getObj_03() // 没有这样的写法
}


int main(void)
{
    Const c;
    Data d_01 = c.getObj_01();
    Data d_02 = c.getObj_02();

    const Data d_03 = c.getObj_01();
    const Data d_04 = c.getObj_02();
    return 0;
}

[size=medium]
（6）放在方法的最后: 表示该方法不会修改对象的数据
[/size]
Main.cpp

class Const
{
private:
    int m_int;
public:
    void setInt(int i) const
    {
        m_int = i;
    }
}


int main(void)
{
    Const c;
    // c.setInt(2);
    return 0;
}

[size=medium]
会得到编译错误, error: assignment of member 'Const::m_int' in read-only object, 提示在只读方法上对变量m_int直行了赋值.


（5）修饰类成员变量: 表示成员变量值不可修改
[/size]
Const.h, [size=medium]注意const变量只能在初始化列表上进行初始化, 在构造器内部是不行的(那时c++编译器不认为是初始化了, 而是属于赋值阶段了)[/size]

#ifndef CONST_H_
#define CONST_H_

class Const
{
private:
    const int m_int;
public:
    Const(int i);

    void setInt(int i)
    {
        // error: assignment of read-only member 'Const::m_int'
        // m_int = i;
    }
}

#endif

Const.cpp

Const::Const(int i)
: m_int(i)
{
}

Main.cpp

#include "Const.h"

int main(void)
{
    Const c(1);
    c.setInt(2);
    return 0;
}

[size=medium]
Const.h会得到编译错误: error: assignment of read-only member 'Const::m_int', 提示m_int的值是只读的, 不可修改


（6）修饰类的static变量: 表示static变量值不可修改
[/size]
Const.h

#ifnded CONST_H_
#define CONST_H_

class Const
{
private:
    static const int s_int;
public:
    static void setInt(int i)
    {
        // error: assignment of read-only variable 'Const::s_int'
        //s_int = i;
    }
}

#endif

Const.cpp

const int Const::s_int = 10;

Main.cpp

#include "Const.h"

int main(void)
{
    Const c;

    c.setInt(11);
    Const::setInt(12);
    return 0;
}

[size=medium]
Const.h会遇到编译错误, error: assignment of read-only variable 'Const::s_int', 提示s_int是只读的, 其值不可修改.
[/size]