C++ 中的const关键字

C++ 中的`const`关键字

原文：https://www.studytonight.com/cpp/const-keyword.php

常量是不变的东西。在 C 语言和 C++ 中，我们使用关键字const使程序元素保持不变。const关键字可以在 C++ 程序的许多上下文中使用。它可以用于:

变量
两颗北极指极星
函数参数和返回类型
类数据成员
班级成员功能
物体

1)c++ 中的常量变量

如果使用const关键字将任何变量设为常量，则不能更改其值。此外，常量变量必须在声明时初始化。

int main
{
    const int i = 10;
    const int j = i + 10;     // works fine
    i++;    // this leads to Compile time error   
}

在上面的代码中，我们将i设为常量，因此如果我们试图改变它的值，我们将会得到编译时错误。虽然我们可以用它来替代其他变量。

2)c++ 中带`const`关键字的指针

指针也可以使用 const 关键字来声明。当我们将const与指针一起使用时，我们可以通过两种方式来实现，要么我们可以将const应用于指针所指向的内容，要么我们可以将指针本身设为常量。

指向`const`变量的指针

这意味着指针指向一个const变量。

const int* u;

这里，u是一个可以指向const int类型变量的指针。我们也可以这样写，

char const* v;

它仍然有同样的意义。在这种情况下，v也是指向const类型的char的指针。

指向const变量的指针非常有用，因为这可以用来使任何字符串或数组不可变(即它们不能被更改)。

`const`指针

要使指针恒定，我们必须将const关键字放在*的右边。

int x = 1;
int* const w = &x;

这里，w是一个指针，也就是const，指向一个int。现在我们不能改变指针，这意味着它将总是指向变量x，但是可以通过改变x的值来改变它所指向的值。

指向变量的常量指针在需要可以改变值但不能在内存中移动的存储时非常有用。因为指针总是指向同一个内存位置，因为它是用const关键字定义的，但是那个内存位置的值是可以改变的。

注:我们也可以有一个const指针指向一个const变量。

const int* const x;

3) `const`函数参数和返回类型

我们可以将函数的返回类型或参数设为const。那我们就不能改变任何一个。

void f(const int i)
{
    i++;    // error
}

const int g()
{
    return 1;
}

需要记住的几个要点

对于内置数据类型，返回一个const或非常量值，没有任何区别。
```
const int h()
{
    return 1;
}

int main()
{
    const int j = h();
    int k = h();
}
```
j和k都将被赋值1。不会出现错误。
对于用户定义的数据类型，返回const，将阻止其修改。
程序执行时创建的临时对象总是const类型。
如果一个函数有一个非常量参数，在进行调用时就不能给它传递const参数。
```
void t(int*) 
{ 
    // function logic
}
```
如果我们给函数t传递一个const int*参数，它会给出错误。
但是，具有const类型参数的函数可以被传递一个const类型参数和一个非常量参数。
```
void g(const int*) 
{
    // function logic
}
```
这个函数可以有int*以及const int*类型的参数。

4)将类数据成员定义为`const`

这些是类中的数据变量，它们是使用const关键字定义的。它们在声明过程中不会初始化。它们的初始化在构造器中完成。

class Test
{
    const int i;
    public:
    Test(int x):i(x)
    {
        cout << "\ni value set: " << i;
    }
};

int main()
{
    Test t(10);
    Test s(20);
}

在这个程序中，i是一个常量数据成员，在每个对象中都有它的独立副本，因此它是用构造器用每个对象初始化的。一旦初始化，它的值就不能改变。以上初始化类成员的方式在 C++ 中称为 初始化列表 。

5)将类对象定义为`const`

当使用const关键字声明或创建对象时，在对象的生命周期内，其数据成员永远不能更改。

语法:

const class_name object;

例如，如果在上面定义的类Test中，我们想要定义一个常量对象，我们可以这样做:

const Test r(30);

6)将类的成员函数定义为`const`

成员函数从不修改对象中的数据成员。

语法:

return_type function_name() const;

常量对象和常量成员函数示例

class StarWars
{
    public:
    int i;
    StarWars(int x)    // constructor
    { 
        i = x; 
    }

    int falcon() const  // constant function
    { 
        /* 
            can do anything but will not
            modify any data members
        */
        cout << "Falcon has left the Base";
    }

    int gamma()
    { 
        i++; 
    }
};

int main()
{
    StarWars objOne(10);        // non const object
    const StarWars objTwo(20);      // const object

    objOne.falcon();     // No error
    objTwo.falcon();     // No error

    cout << objOne.i << objTwo.i;

    objOne.gamma();     // No error
    objTwo.gamma();     // Compile time error
}

猎鹰已经离开基地猎鹰已经离开基地 10 20

这里我们可以看到，const成员函数从不改变类的数据成员，它既可以和const一起使用，也可以和非常量 objecta 一起使用。但是const对象不能与试图改变其数据成员的成员函数一起使用。

`mutable`关键字

mutable关键字与类的成员变量一起使用，即使对象是const类型，我们也要更改。因此，mutable对象的数据成员可以被修改。

class Zee
{
    int i;
    mutable int j;
    public:
    Zee()
    {
        i = 0; 
        j = 0;
    }

    void fool() const
    { 
        i++;    // will give error
        j++;    // works, because j is mutable
    }
};

int main()
{
    const Zee obj;
    obj.fool();
}

1)c++ 中的常量变量

2)c++ 中带const关键字的指针

指向const变量的指针

const指针

3) const函数参数和返回类型

需要记住的几个要点

4)将类数据成员定义为const

5)将类对象定义为const

6)将类的成员函数定义为const

常量对象和常量成员函数示例

mutable关键字