C++ 函数头后面的“const”是什么意思？

有一个

a类

，它具有以下

运算符（）

实现：

void A::operator()(...parameters...) const 
{
    // operator body
}

---

这个

const

是什么意思？

方法使用

this

作为

const a*

，然后只能调用其他

const

方法

---

请参阅CPP常见问题解答的条目。

该方法使用

此

作为

常量a*

，然后只能调用其他

常量

方法

---

请参阅CPP常见问题解答的条目。

const关键字指定函数为“只读”函数，不修改调用它的对象。

const关键字指定函数为“只读”函数不修改它调用的对象。

这意味着调用运算符不会改变对象的状态。

这意味着调用运算符不会改变对象的状态。C++中的< /p> < p>方法可以被标记为<代码> const <代码>，如上面的例子中所示，函数不修改实例。为了实现这一点，方法中的

this

指针的类型为

const A*const

通常，方法中的

this

指针是

a*const

，表示我们无法更改

this

指向的内容。也就是说，我们不能做

this=newa（）

---

<>但是，当类型为“代码> const A*const < /C> >时，我们也不能改变任何属性。C++中的

< P>方法可以被标记为 const ，如上面的示例中所示，以指示该函数不修改实例。为了实现这一点，方法中的

this

指针的类型为

const A*const

通常，方法中的

this

指针是

a*const

，表示我们无法更改

this

指向的内容。也就是说，我们不能做

this=newa（）

---

但是当类型为

const A*const

时，我们也不能更改任何属性。

A

const

成员函数承诺不会更改对象的可观察状态

在引擎盖下，它可能仍会更改状态，例如

可变

成员的状态。但是，

mutable

成员不应在类接口之外的任何位置可见，也就是说，您不应试图欺骗客户机代码，因为客户机代码可能有效地期望

const

函数不会调整对象的外壳。将

mutable

视为一种优化工具（例如用于缓存和记忆）

---

可变性示例：

你有一个四叉树类。在引擎盖下，四叉树是惰性建立的，即按需建立；这种懒散对类的用户是隐藏的。现在，该四叉树上的查询方法应该是

const

，因为查询四叉树预计不会改变四叉树。如何在不违反C++规则的情况下实现常量正确性和懒散性？使用

mutable

。现在，您有了一个四叉树，对于用户来说，它看起来是常量，但您知道，在引擎盖下，仍然有很多变化：

class Quadtree {
public:
    Quadtree (int depth);
    Foo query (Bar which) const;

private:
    mutable Node node_;
};

---

const

成员函数承诺不会更改对象的可观察状态

在引擎盖下，它可能仍会更改状态，例如

可变

成员的状态。但是，

mutable

成员不应在类接口之外的任何位置可见，也就是说，您不应试图欺骗客户机代码，因为客户机代码可能有效地期望

const

函数不会调整对象的外壳。将

mutable

视为一种优化工具（例如用于缓存和记忆）

---

可变性示例：

你有一个四叉树类。在引擎盖下，四叉树是惰性建立的，即按需建立；这种懒散对类的用户是隐藏的。现在，该四叉树上的查询方法应该是

const

，因为查询四叉树预计不会改变四叉树。如何在不违反C++规则的情况下实现常量正确性和懒散性？使用

mutable

。现在，您有了一个四叉树，对于用户来说，它看起来是常量，但您知道，在引擎盖下，仍然有很多变化：

class Quadtree {
public:
    Quadtree (int depth);
    Foo query (Bar which) const;

private:
    mutable Node node_;
};

---

如前所述，这意味着该方法不会修改对象的可观察状态。但同样重要的是，它意味着可以对常量对象、指针或引用调用该方法-非常量方法不能。即：

class A
{
public:
    void Method1() const
    {
    }

    void Method2()
    {
    }
};

int main( int /*argc*/, char * /*argv*/ )
{

    const A a;
    a.Method1(); //ok.
    a.Method2(); //compiler error!

    return 0;
}

---

如前所述，这意味着该方法不会修改对象的可观察状态。但同样重要的是，它意味着可以对常量对象、指针或引用调用该方法-非常量方法不能。即：

class A
{
public:
    void Method1() const
    {
    }

    void Method2()
    {
    }
};

int main( int /*argc*/, char * /*argv*/ )
{

    const A a;
    a.Method1(); //ok.
    a.Method2(); //compiler error!

    return 0;
}

---

不一定，由于

const_cast

和

mutable

@dan04:Ok，所以它的意思是“不会改变对象的状态…除非有人作弊！”：P@dan04：通过

const_cast

改变常量值会产生未定义的行为。@piokuc:可能会将其细化为“可观察状态”。@piokuc:示例：您有一个四叉树类。在引擎盖下，四叉树是惰性建立的，即按需建立；这种懒散对类的用户是隐藏的。现在，该四叉树上的查询方法应该是

const

，因为查询四叉树预计不会改变四叉树。如何在不违反C++规则的情况下实现常量正确性和懒散性？使用

mutable

。现在你有了一个四叉树，对于用户来说它看起来是常量，但是你知道在引擎盖下，仍然有很多变化。这不一定，因为

const\u cast

和

mutable

@dan04:Ok，所以它的意思是“不会改变对象的状态……除非有人作弊！” :P@dan04：通过

const_cast

改变常量值会产生未定义的行为。@piokuc:可能会将其细化为“可观察状态”。@piokuc:示例：您有一个四叉树类。在引擎盖下，四叉树是懒洋洋地建立起来的，即在d上