const关键字总结

标签：存储   编译器   const成员函数   整数   private   内容   char   它的   bool   

const关键字

被const修饰的变量是不能改变的
const修饰变量时，必须在声明变量的同时给出初始化(类中的const成员变量不一样)

顶层const与底层const

顶层const

定义为变量本身是一个常量，因此对一切的内置类型常量而言，所有的const都是顶层const
对指针来说，常量指针是顶层const，对于引用则没有顶层const的概念。

底层const

只在指针和引用上有效，其定义是该指针指向或该引用绑定的对象是常量。
因此：顶层const和底层const，引用只有底层const。

int main()
{
    int a = 10;
    int aa = 100;

    const int *b = &a;  //底层const指针
    *b = 20;    //错误，底层const指针不可以修改指向的值
    b = &aa;    //正确，底层const指针可以指针的指向

    int * const c = &a;     //顶层const指针
    *c = 20;    //正确，顶层const指针可以修改指针指向的值
    c = &b; //错误，顶层const指针不能修改指针的指向

    b = c;  //底层const指针可以指向顶层const指针(顶层const可以赋值给底层const)
    c = b;  //底层const指针不可以赋值给顶层const指针

    const int& e = a;   //引用的底层const
    e = 1000;   //错误，引用的底层const不能修改值

    const int* const f = &aa;   //同时被顶层和底层const封锁的指针既不能修改其指向，也不能修改其指向的内容

    return 0;
}

const与函数

成员函数后使用const

就不能对此方法生命周期外的变量值修改，可以保护成员变量不被方法修改

class Example
{
public:
    int getData() const
    {
        m_data = 100;    //错误，成员函数后使用const，不能对该方法生命周期外的变量值修改，保护了成员变量
        return m_data;
    }
private:
    int m_data;
};

函数成员前加const

保证在外部调用该方法后，返回值不会被篡改

class Example
{
public:
    const int* getData() const
    {
        return &m_data;
    }
private:
    int m_data;
};

int main(int argc, char* argv[])
{
    Example e;
    *e.getData()=100;   //错误，函数前加了是const，返回值不能被篡改
    return 0;
}

const与mutable

mutable 是为了突破 const 的限制而设置的。可以用来修饰一个类的成员变量。被 mutable 修饰的变量，将永远处于可变的状态，即使是 const 函数中也可以改变这个变量的值。

class Example
{
public:
    int getData() const
    {
        m_isdone = true;    //正确，被mutable修饰的类的成员变量，即使在被const修饰的成员函数中也能被修改
        return m_data;
    }
private:
    int m_data;
    mutable bool m_isdone;
};

const与类和对象

类的const对象只能调用类的const成员函数，类的非const对象可以调用const成员函数和非const成员函数

class Example
{
public:
    int getData() const
    {
        return m_data;
    }
private:
    int m_data;
};

int main(int argc, char* argv[])
{
    const Example e1;
    e1.getData();

    Example e2; //正确，类的非const成员可以调用const成员函数和非const成员函数
    e2.getData();

    return 0;
}

不能在类声明中初始化const数据成员，因为类的对象未被创建时，编译器不知道const成员的值是什么。const数据成员的初始化只能在类构造函数的初始化表中进行！

class Example
{
public:
    Example(int data):m_data(data){}    //const成员的初始化只能在类构造函数的初始化表中进行
private:
    const int m_data;   //const成员
};

int main(int argc, char* argv[])
{
    Example e1(10);
    return 0;
}

想要在类中建立恒定的常量，应该用类中的枚举常量来实现。

class Example
{
public:
    Example():m_data(DATA1){}
private:
    enum {DATA1=100,DATA2=200}; //枚举常量成员
    int m_data;
};

int main(int argc, char* argv[])
{
    Example e1();
    
    return 0;
}

枚举常量不会占用对象的存储空间，它们在编译时被全部求值。枚举常量的缺点是：它的隐含数据类型是整数，其最大值有限，且不能表示浮点数。

?

const关键字总结

标签：存储   编译器   const成员函数   整数   private   内容   char   它的   bool   

原文地址：https://www.cnblogs.com/WindSun/p/11434431.html