迹忆客 专注技术分享

在C++中，const关键字定义了那些在程序执行期间不会改变并保持不变的值。 对于变量及其保存的数据来说，这听起来非常简单。

但是，如何将函数声明为常量，以及函数中哪些内容需要保持不变？ 我们将在本文中回答所有这些问题以及更多内容，所以请继续阅读！

请注意，我们在这里查看的函数是属于类的函数，即成员函数。

C++ 类函数声明中的 const 关键字 在深入实际讨论之前，让我们正确理解问题陈述。

我们已经知道类可以有数据成员和成员函数。 这些成员函数通常在类内部声明如下 -

class Demo            //class
{
    public:
    int x;
    int showDemo();   //member function declaration
}

这里，成员函数showDemo()属于类Demo。 但是如果我们像这样在成员函数末尾添加 const 意味着什么 -

class Demo            //class
{
    public:
    int x;
    int showDemo() const;   //const member function declaration
}

让我们首先看看成员函数在 C++ 中通常的行为方式来理解这一点。

C++ 中成员函数的行为

看看下面给出的代码。 在这里，我们首先定义一个名为 Demo 的类，它有一个数据成员 Chocolates（其值设置为 2）和一个成员函数 Desert()。

在成员函数内部，连同欢迎语句，我们打印数据成员 Chocolates 的原始值，然后将该值加一。 此外，我们在下一条语句中打印巧克力的增量值。

最后，我们创建一个对象 demo，并从主块调用成员函数 Desert()。 此外，我们使用对象演示和点运算符打印巧克力的值。

#include<iostream>
using namespace std;

class Demo
{
    public:
        int chocolates = 2;
    public:
        void Desert()         //member function
        {
            cout << "Hello Chocolates" << endl;
            cout << "Before change: " << chocolates << endl;
            chocolates++;
            cout << "After change: " << chocolates << endl;
        }
};

int main()
{
    Demo demo;
    demo.Desert();
    cout << demo.chocolates << endl;
}

输出:

Hello Chocolates
Before change: 2
After change: 3
3

您可以看到，在这里，我们从成员函数内部更改了数据成员 Chocolates 的值。 为了更准确地强调变化，我们也从主块打印该变量的值，但我们仍然得到更新后的值，即 3。

因此，这个例子意味着我们可以以某种方式使用普通的成员函数来更改对象。

在这里，我们只有一个类和一个对象。 然而，在使用许多类和对象时，很可能会意外地对对象进行更改。

为了避免这种情况，我们使用C++的const成员函数。

C++ 中 const 成员函数的行为

看下面给出的例子。 这段代码和前面的代码是一样的，只是这次我们把const关键字放在了成员函数后面。

#include<iostream>
using namespace std;

class Demo
{
    public:
        int chocolates = 2;
    public:
        void Desert() const     //const member function
        {
            cout << "Hello Chocolates" << endl;
            cout << "Before change: " << chocolates << endl;
            chocolates++;
            cout << "After change: " << chocolates << endl;
        }
};

int main()
{
    Demo demo;
    demo.Desert();
    cout << demo.chocolates << endl;
}

输出:

In member function 'void Demo::Desert() const':
error: increment of member 'Demo::chocolates' in read-only object
   13 |             chocolates++;
      |             ^~~~~~~~~~

您可以通过将成员函数设置为常量来查看输出如何变化。 这次，巧克力的值没有增加，我们得到一个错误。

因此，这个例子意味着我们不能使用 const 成员函数以任何方式更改对象。

通过上面两个成员函数的比较，我们得出结论，在此类函数声明中使用 const 意味着任何类成员都不会发生任何变化。 当我们将 const 添加到方法中时，this 指针指向 const 对象，因此我们无法更改任何数据成员。

在我们了解了所有这些之后，我们可以说我们使用 const 成员函数来避免更改对象。 但是，你可能会想：const 对象有什么用？

当我们将一个对象声明为 const 时，它只能调用 const 成员函数。 这是因为 const 对象不能被修改，而这种不可修改性只能由 const 成员函数来保证。

看下面的例子。

在 Desert 类中，我们有两个成员函数，const Desert() 和 Desert()。 然后，在主块内，我们定义两个对象 d 和一个常量对象 dd。

请注意有关此示例的一些要点：

1. 我们有两个同名的成员函数。 唯一的区别是其中一个是 const 成员函数。
2. 我们有两个对象，其中之一是常量对象。
3. 我们从两个对象中调用成员函数 Desert()，而不指定哪个对象调用哪个函数。

#include<iostream>
using namespace std;

class Desert
{
    private:
        int cakes;
    public:
        void desert()
        {
            cout << "The first desert function." << endl;
        }

        void desert() const     // the const member function
        {
            cout << "The second const desert function." << endl;
        }
};

int main()
{
    Desert d;                  // object of class
    const Desert& dd = d;      // constant object of class
    d.desert();
    dd.desert();
}

输出:

The first desert function.
The second const desert function.

输出清楚地表明，普通成员函数 Desert() 是由普通对象 d 自动调用的。 同时，const 成员函数 Desert() const 由 const 对象 dd 自动调用。

如果我们从对象中删除 const 关键字，输出将会改变。

int main()
{
    Desert d;            // object of class
    Desert& dd = d;      // remove the constant keyword
    d.desert();
    dd.desert();
}

输出:

The first desert function.
The first desert function.

这次两个对象都调用第一个函数。 这证明了 const 对象调用了 const 成员函数。

请注意，这并不意味着我们不能在非常量对象上调用 const 成员函数。 但是，非常量函数只能由非常量对象调用。

到目前为止，一切都很好，但有一个例外的情况。 如果我们对类的任何数据成员使用可变量词，我们甚至可以在 const 方法中修改对象。

看这个例子。

#include<iostream>
using namespace std;

class Demo
{
    public:
        mutable int chocolates = 2;  //mutable quantifier
    public:
        void Desert() const         //const member function
        {
            cout << "Hello Chocolates" << endl;
            cout << "Before change: " << chocolates << endl;
            chocolates++;
            cout << "After change: " << chocolates << endl;
        }
};

int main()
{
    Demo demo;
    demo.Desert();
    cout << demo.chocolates << endl;
}

输出:

Hello Chocolates
Before change: 2
After change: 3
3

这次，我们不会像以前一样收到错误，因为我们将可变量词与数据成员巧克力一起使用。 如果我们想要计算一个方法被调用的次数，这通常很有帮助。

这都是关于 C++ 中的 const 成员函数。 您对示例的了解越多，到处做一些小的改变，您就会获得更多的清晰度！

总结

在本文中，我们讨论了 C++ 的 const 成员函数的概念。 const 成员函数可确保对象不会被意外修改，并且我们可以将它与 const 和非 const 对象一起使用。

但是，const 对象只能撤销 const 成员函数。 此外，对数据成员使用 mutable 关键字可以更改 const 成员函数的通常行为，并且通常用于计数目的。