【c++】类中的const成员

const成员变量

举个例子

#include <iostream>
using namespace std;

class A
{
    public:
        A(int size) : SIZE(size) {};
    private:
        const int SIZE;
};

int main()
{
    A a(100);
}

说明

• 在类中声明变量为const类型，可是不能够初始化
• const常量的初始化必须在构造函数初始化列表中初始化，而不能够在构造函数函数体内初始化

可是

 此时的const变量属于具体的一个对象，如何在整个类中都恒定不变呢？

 答案是利用枚举，举例

#include <iostream>
using namespace std;

class A
{
    private:
        enum {SIZE = 100};
    public:
        int array[SIZE];
};

int main()
{
    A a;
}

枚举常量不会占据对象的存储空间，在编译时被所有求值

可是，它隐含的数据对象类型为整形，不能表示其余类型。

问题

如何定义在类中定义非整形常量？（待解决）

 

话说有几个地方必须在构造函数的初始化列表中(详见)：

1. 类的const常量
2. 类的引用类型成员
3. 没有默认构造函数的类类型成员
4. 若是类存在继承关系，派生类必须在其初始化列表中调用基类的构造函数

 

const成员函数

任何不修改数据成员的函数都应该声明为const类型。若是在编写const成员函数时，不慎修改了数据成员，或调用了其余非const成员函数，编译器就会指出错误。

示例说明

#include <iostream>
using namespace std;
class Stack
{
    public:
        void Push(int item);
        int Pop(void);
        int GetCount(void) const;
    private:
        int m_num; 
        int m_data[100];
};

int Stack::GetCount(void) const
{
    ++m_num;     //编译错误，企图修改数据成员
    Pop();       //编译错误,企图调用非const函数
    return m_num;
}

 

同一个类中，能够仅经过是不是const定义两个函数名字、参数、返回值彻底相同的两个成员函数，例如：

#include <iostream>
using namespace std;

class A
{
    public:
        A(int v): val(v) {}
        void print_val() { cout << "not const:" << val << endl;}
        void print_val() const { cout << "const print_val:" << val << endl;}
    private:
        int val;
};
int main(int argc ,char **argv)
{
    A b(45);
    b.print_val();

    const A a(12);
    a.print_val();
}

输出

结论

同函数名、参数、返回值能够仅经过是否为const来定义为类的两个成员函数。在调用时，const对象调用const成员函数，非const对象调用非const成员函数。

问题 1：

不能够在const函数中改变成员变量的值，那么有没有办法改变？

答案是能够的，把成员变量声明为mutable类型。看程序

#include <iostream>
using namespace std;

class A
{
    public:
        A(int v): val(v) {}
        void print_val() { cout << "not const:" << val << endl;}
        void print_val() const { val++; cout << "const print_val:" << val << endl;}
    private:
        mutable int val;
};
int main(int argc ,char **argv)
{
    A b(45);
    b.print_val();

    const A a(12);
    a.print_val();
}

结果

 

问题2：

当类中只有const函数，非const对象是否能够调用const函数？

答案是能够的，程序

#include <iostream>
using namespace std;

class A
{
    public:
        A(int v): val(v) {}
//        void print_val() { cout << "not const:" << val << endl;}
        void print_val() const { val++; cout << "const print_val:" << val << endl;}
    private:
        mutable int val;
};
int main(int argc ,char **argv)
{
    A b(45);
    b.print_val();

    const A a(12);
    a.print_val();
}

结果

可是：还有非const函数时，非const对象不能够调研那个const函数（不然，类的数据变量就会发生变化）。

 

问题3：

当类中存在只有 是否为const 不一样的两个函数时，const函数是否能够暂时调用那个非const函数？

答案是能够的。用const_cast将转化掉表达式的const性质

#include <iostream>
using namespace std;

class A
{
    public:
        A(int v): val(v) {}
        void print_val() { cout << "not const:" << val << endl;}
        void const print_val() const { cout << "const print_val:" << val << endl;}
    private:
        int val;
};
int main(int argc ,char **argv)
{
    A b(45);
    b.print_val();

    const A *a = new A(45);
    const_cast<A*>(a)->print_val();
    a->print_val();
}

结果

注意

单纯用类转化不行

const A a(45);
const_cast<A> a.print_val();

报错

问题4：返回类型是const是怎么回事？

const返回类型只有在修饰指针或引用是才有用。单凭const返回类型不能够重载。