C++ 在常量成员函数内调用的非常量成员函数 #包括 同学们好{ 公众： 无效测试（）{ std:：cout

在

Hi:：Testing

中，

Hi

对象“是常量”。这意味着指针

hello

不能在该方法中修改。（就好像

hello

在该方法期间被定义为

hello*const hello；

）

---

但这并不意味着

hello

被转换为指向const的指针（看起来像

hello-const*const-hello；

）。由

hello

指向的对象不是const，因此您可以无限制地调用其非const方法。

在

Hi:：Testing

中，

Hi

对象“是const”。这意味着无法在该方法内修改指针

hello

。（就好像

hello

在该方法期间被定义为

hello*const hello；

）

---

但这并不意味着

hello

被转换为指向const的指针（看起来像

hello const*const hello；

）。由

hello

指向的对象不是const，因此您可以无限制地调用其非const方法。

您可以将问题简化为以下情况：

#include <iostream>

class Hello {
public:
    void Test() {
        std::cout << "Testing" << std::endl;
    }
};

class Hi {
public:
    Hi()
    :hello(new Hello())
    {}

    ~Hi()
    {
        delete hello;
    }

    void Testing() const {
        hello->Test();
    }

private:
    Hello  * hello;
};

int main(int argc, char ** argv) {
    Hi hi; ;
    hi.Testing();
    return 0;
}

---

您的

Hi

-对象是否为常量仅影响此类比中的顶级

const

修饰符（即

Hi:：hello

是

hello*

还是

hello*const

），但是，第一个const修饰符是指针类型本身的一个组成部分（且不受对象常数的影响）。

您可以将问题简化为以下情况：

#include <iostream>

class Hello {
public:
    void Test() {
        std::cout << "Testing" << std::endl;
    }
};

class Hi {
public:
    Hi()
    :hello(new Hello())
    {}

    ~Hi()
    {
        delete hello;
    }

    void Testing() const {
        hello->Test();
    }

private:
    Hello  * hello;
};

int main(int argc, char ** argv) {
    Hi hi; ;
    hi.Testing();
    return 0;
}

---

您的

Hi

-对象是否为常量仅影响此类比中的顶级

const

修饰符（即

Hi:：hello

是

hello*

还是

hello*const

），但是，第一个const修饰符是指针类型本身的一个组成部分（不受对象的常量影响）。

如果有指向常量对象的指针，则会限制您在目标对象中调用常量成员函数

指向（普通）对象的常量指针只是意味着您不能修改指针本身。因为它仍然是指向普通对象的指针，所以您可以使用任何成员函数，而不仅仅是常量成员函数。如果目标对象具有该函数的常量和普通重载，则将选择普通重载

---

当您有一个指针作为常量对象的成员时，您将得到第二个指针，而不是第一个指针。

如果您有一个指向常量对象的指针，则将限制您在目标对象中调用常量成员函数

指向（普通）对象的常量指针只是意味着您不能修改指针本身。因为它仍然是指向普通对象的指针，所以您可以使用任何成员函数，而不仅仅是常量成员函数。如果目标对象具有该函数的常量和普通重载，则将选择普通重载

---

当你有一个指针作为常量对象的成员时，你得到的是第二个，而不是第一个。

这肯定不会编译。@Rapptz:：现在它编译成功了。这肯定不会编译。@Rapptz:：现在它编译成功了。但这并不意味着hello是一个常量对象。但我读到的内容好像我们不能调用非常量成员func在这种情况下，它违反了这个概念，对吗？不，它没有。

这个

“是常量”在该方法中，所有成员的行为都像添加了顶级常量一样。这意味着指针成员变成了常量指针。也就是说，在该方法中不能执行

hello=new hello；

。这就是const提供给您的所有内容。它不会使成员指针指向的所有对象都成为常量。所有成员的行为都像有顶级指针一样-添加了级别const。这意味着指针成员变成了const指针。你能再解释一下你说的这行吗？是的，const指针。不是指向const对象的指针（或指向const对象的const指针）。变成const的是指针，而不是指针指向的对象。（换句话说，

hello->foo（）

不会修改指针

hello

，它只读取指针，然后调用

hello

指向的对象上的方法。该对象没有“变为常量”。）您放入该函数签名中的

const

（

void Testing（）const

）是编译器使所有函数在代码中处理的过程，就像在代码<> Hi中添加了一个顶级的const。这就是C++标准所必须做的，对于const限定成员函数。但是这并不意味着hello是一个常量对象。但是我读过，就像我们不能调用一个非常量成员函数一样。ugh常量对象。那么在这种情况下，它违反了概念，对吗？不，它没有。

这是常量在该方法中，所有成员的行为都像添加了顶级常量一样。这意味着指针成员变成了常量指针。也就是说，在该方法中不能执行
hello=new hello；
。这就是const提供给您的所有内容。它不会使成员指针指向的所有对象都成为常量。所有成员的行为都像有顶级指针一样-添加了级别const。这意味着指针成员变成了const指针。你能再解释一下你说的这行吗？是的，const指针。不是指向const对象的指针（或指向const对象的const指针）。变成const的是指针，而不是指针指向的对象。（换句话说，
hello->foo（）
不会修改指针
hello
，它只读取指针，然后调用
hello
指向的对象上的方法。该对象没有“变为常量”。）您放入该函数签名中的
常量（
无效测试（）常量
）是编译器运行的原因