816

在这样的声明中是什么意思const？让const我很困惑。

class foobar
{
  public:
     operator int () const;
     const char* foo() const;
};
4

12 回答 12

1064

当您将const关键字添加到方法时，this指针本质上将成为指向const对象的指针，因此您无法更改任何成员数据。（除非您使用mutable，稍后会详细介绍）。

关键字是函数签名的const一部分，这意味着您可以实现两种类似的方法，一种在对象为 时调用const，另一种不是。

#include <iostream>

class MyClass
{
private:
    int counter;
public:
    void Foo()
    { 
        std::cout << "Foo" << std::endl;    
    }

    void Foo() const
    {
        std::cout << "Foo const" << std::endl;
    }

};

int main()
{
    MyClass cc;
    const MyClass& ccc = cc;
    cc.Foo();
    ccc.Foo();
}

这将输出

Foo
Foo const

在非常量方法中，您可以更改实例成员，这在const版本中是无法做到的。如果将上面示例中的方法声明更改为下面的代码，则会出现一些错误。

    void Foo()
    {
        counter++; //this works
        std::cout << "Foo" << std::endl;    
    }

    void Foo() const
    {
        counter++; //this will not compile
        std::cout << "Foo const" << std::endl;
    }

这并不完全正确，因为您可以将成员标记为mutable，const然后方法可以更改它。它主要用于内部计数器和东西。解决方案是下面的代码。

#include <iostream>

class MyClass
{
private:
    mutable int counter;
public:

    MyClass() : counter(0) {}

    void Foo()
    {
        counter++;
        std::cout << "Foo" << std::endl;    
    }

    void Foo() const
    {
        counter++;    // This works because counter is `mutable`
        std::cout << "Foo const" << std::endl;
    }

    int GetInvocations() const
    {
        return counter;
    }
};

int main(void)
{
    MyClass cc;
    const MyClass& ccc = cc;
    cc.Foo();
    ccc.Foo();
    std::cout << "Foo has been invoked " << ccc.GetInvocations() << " times" << std::endl;
}

这将输出

Foo
Foo const
Foo has been invoked 2 times
于 2009-04-15T13:49:27.367 回答
201

const 意味着该方法承诺不会改变类的任何成员。即使对象本身被标记，您也可以执行被标记的对象成员const：

const foobar fb;
fb.foo();

将是合法的。

请参阅C++ 中“const”有多少和哪些用途？了解更多信息。

于 2009-04-15T13:29:34.607 回答
51

const限定符意味着可以对 的任何值调用方法foobar。当您考虑在 const 对象上调用非常量方法时，差异就出现了。考虑您的foobar类型是否具有以下额外的方法声明：

class foobar {
  ...
  const char* bar();
}

该方法bar()是非常量的，只能从非常量值访问。

void func1(const foobar& fb1, foobar& fb2) {
  const char* v1 = fb1.bar();  // won't compile
  const char* v2 = fb2.bar();  // works
}

背后的想法const是标记不会改变类内部状态的方法。这是一个强大的概念，但在 C++ 中实际上是不可执行的。与其说是保证，不如说是一种承诺。还有一个经常坏的，很容易坏的。 

foobar& fbNonConst = const_cast<foobar&>(fb1);
于 2009-04-15T13:30:08.427 回答
30

这些 const 意味着如果“with const”方法更改内部数据，编译器将出错。

class A
{
public:
    A():member_()
    {
    }

    int hashGetter() const
    {
        state_ = 1;
        return member_;
    }
    int goodGetter() const
    {
        return member_;
    }
    int getter() const
    {
        //member_ = 2; // error
        return member_;
    }
    int badGetter()
    {
        return member_;
    }
private:
    mutable int state_;
    int member_;
};

考试

int main()
{
    const A a1;
    a1.badGetter(); // doesn't work
    a1.goodGetter(); // works
    a1.hashGetter(); // works

    A a2;
    a2.badGetter(); // works
    a2.goodGetter(); // works
    a2.hashGetter(); // works
}

阅读本文了解更多信息

于 2009-04-15T13:30:06.210 回答
13

布莱尔的回答是正确的。

但是请注意，有一个mutable限定符可以添加到类的数据成员中。任何如此标记的成员都const可以在不违反const合同的情况下修改方法。

如果您希望对象记住调用特定方法的次数，同时不影响该方法的“逻辑”常量，您可能想要使用它（例如）。

于 2009-04-15T13:37:14.743 回答
12

C++ Common Knowledge: Essential Intermediate Programming中Const成员函数的含义给出了清晰的解释：

类 X 的非 const 成员函数中 this 指针的类型是 X * const。也就是说，它是一个指向非常量 X 的常量指针（参见 Const Pointers 和 Pointers to Const [7, 21]）。因为 this 所指的对象不是 const，所以可以修改。类 X 的 const 成员函数中 this 的类型是 const X * const。也就是说，它是一个指向常量 X 的常量指针。因为 this 所指的对象是 const，所以它不能被修改。这就是 const 和非 const 成员函数之间的区别。

所以在你的代码中： 

class foobar
{
  public:
     operator int () const;
     const char* foo() const;
};

你可以这样想： 

class foobar
{
  public:
     operator int (const foobar * const this) const;
     const char* foo(const foobar * const this) const;
};
于 2017-03-14T05:48:18.753 回答
8

我想补充以下几点。

你也可以把 它变成一个const &和const &&

所以，

struct s{
    void val1() const {
     // *this is const here. Hence this function cannot modify any member of *this
    }
    void val2() const & {
    // *this is const& here
    }
    void val3() const && {
    // The object calling this function should be const rvalue only.
    }
    void val4() && {
    // The object calling this function should be rvalue reference only.
    }

};

int main(){
  s a;
  a.val1(); //okay
  a.val2(); //okay
  // a.val3() not okay, a is not rvalue will be okay if called like
  std::move(a).val3(); // okay, move makes it a rvalue
}

随意改进答案。我不是专家

于 2019-03-26T17:24:17.703 回答
7

当您const在方法签名中使用时（如您所说const char* foo() const;：），您是在告诉编译器指向的内存this不能被此方法更改（foo在此处）。

于 2015-05-30T05:54:27.253 回答
3

这里 const 意味着在该函数中任何变量的值都不能改变

class Test{
private:
    int a;
public:
    void test()const{
        a = 10;
    }
};

像这个例子一样，如果你试图在测试函数中改变一个变量的值，你会得到一个错误。

于 2020-12-20T17:07:06.130 回答
2

与函数声明一起使用的const关键字指定它是一个const 成员函数，并且不能更改对象的数据成员。

于 2019-08-18T09:05:23.657 回答
2

https://isocpp.org/wiki/faq/const-correctness#const-member-fns

什么是“const成员函数”？

检查（而不是变异）其对象的成员函数。

const成员函数由成员const函数的参数列表后面的后缀表示。带有const后缀的成员函数称为“const 成员函数”或“检查器”。没有const后缀的成员函数称为“非常量成员函数”或“mutators”。</p> 

class Fred {
public:
  void inspect() const;   // This member promises NOT to change *this
  void mutate();          // This member function might change *this
};
void userCode(Fred& changeable, const Fred& unchangeable)
{
  changeable.inspect();   // Okay: doesn't change a changeable object
  changeable.mutate();    // Okay: changes a changeable object
  unchangeable.inspect(); // Okay: doesn't change an unchangeable object
  unchangeable.mutate();  // ERROR: attempt to change unchangeable object
}

调用尝试unchangeable.mutate()是在编译时捕获的错误。没有运行时空间或速度损失const，并且您不需要编写测试用例来在运行时检查它。

const成员函数的结尾inspect()应该用来表示该方法不会改变对象的抽象（客户端可见）状态。这与说该方法不会更改对象结构的“原始位”略有不同。C++ 编译器不允许采用“按位”解释，除非它们能够解决通常无法解决的别名问题（即，可能存在可能修改对象状态的非常量别名）。这个别名问题的另一个（重要）见解：用指向常量的指针指向一个对象并不能保证该对象不会改变；它只是保证对象不会通过那个指针改变。

于 2020-03-20T19:44:17.213 回答
0

在const对象中只能const调用方法。这种方法的所有领域都被视为const领域。最后一期有奇怪的效果：

  • 指针变为 const 指针int* const，这与指向 const 的指针不同const int*。因此，您可以更改指针指向的对象，但不能使指针指向另一个对象。
  • 引用应该成为一个常量引用，但它始终是一个常量引用：你不能将它重新初始化到另一个对象。但是您可以再次更改引用所指的对象。
于 2021-12-14T15:14:18.153 回答