Question

pointer()的这些定义是否相等？

class Example
{
public:
    AnotherClass* const pointer() const;
    AnotherClass* pointer() const;


private:
    AnotherClass* m_pointer;
}

它能保证我有什么不能改变指向m_pointer的内存吗？

Answer 1

您需要第一种方法的返回类型为以下方法之一：

    AnotherClass const * pointer() const;

或

    const AnotherClass* pointer() const;

您所做的是将常量指针返回到非常量对象。

你想要的是 const对象的非常量指针。

另外，为了遵循典型的做法，你的第二种方法不应该是常量。

    AnotherClass* pointer();

Answer 2

pointer的两个重载仅在返回类型上有所不同。你的C ++编译器不会接受，这是一个错误。

假设指针（）只返回m_pointer：

声明AnotherClass* pointer() const;将公开m_pointer的值。该类的用户将无法更改m_pointer，但他们可以更改m_pointer指向的对象。

声明AnotherClass* const pointer() const;与AnotherClass* pointer() const;非常相似，但返回的值（临时指针）是const。这个声明实际上没有意义，因为你已经无法在第一个声明中更改返回值。在任何一种情况下都不能写example.pointer() = nullptr。当你将返回值赋给像p = example.pointer()这样的变量时，如果指针（）的返回值是常量，则没有区别。

声明const AnotherClass* pointer() const;和AnotherClass const * pointer() const;将公开m_pointer的值。该类的用户将无法更改m_pointer，并且他们将无法更改m_pointer指向的对象。

Answer 3

这里有几点需要考虑：

什么是const：指针或指针？

让我们看看这些不同声明之间的差异。

int x, y;

int       *       p = &x; // 0
const int *       p = &x; // 1
int const *       p = &x; // 2
int       * const p = &x; // 3
const int * const p = &x; // 4
int const * const p = &x; // 5

（0）表示p可以更改（p = &y;可以），它指向的内容（x）可以通过p进行更改（{{1}好的）。

（1）和（2）是等价的，意味着*p = y;可以更改（p没问题），它指向的内容（p = &y;）不能通过{{1}更改（x是一个错误）。

（3）表示p无法更改（*p = y;是错误），它指向的内容（p）可以通过p = &y;更改{{1}好的）

（4）和（5）是等价的，意味着x无法更改（p是一个错误），它指向的内容（*p = y;）无法通过{{更改1}}（p是一个错误）。

一种简单的记忆方法是查看p = &y;并认为它将对象 constness 分开，即

（a）x之前的p（例如*p = y;或*）表示指向的对象（类型const）是{{1} };和

（b）*之后const int * [...]（例如int const * [...]）表示指针为int且无法更改。

如果函数返回const对象会怎样？

考虑：

const

然后，（假设*有一个可访问的赋值运算符），我们有：

[...] * const p [...];

很自然地相信const和const的行为相同，但不的情况如下：

class some_class;

const some_class a(); // equivalent to 'some_class const a();'
      someclass  b();

const int        c(); // equivalent to 'int const c();'
      int        d();

原因是如果函数返回基本类型（例如some_class，some_class x; a() = x; // illegal : the returned object is const b() = x; // OK : the returned object is not const，c()，任何指针类型，...）则无法将返回的对象分配给。因此， 返回基本类型的d()对象与返回非常量对象的行为相同。

如何在返回类型上重载？

考虑

c() = 0; // illegal
d() = 0; // also illegal!!!

这是非法的。我们不能仅在返回类型上重载。一个原因是我们总是可以忽略函数返回的对象。例如，如果允许在返回类型上重载，那么下面将调用int的哪个重载？

bool

回答问题......

考虑第一个声明

char

从我们所看到的，这意味着const返回类型为int f(); // first overload. double f(); // second overload.的{{1}}对象（指针类型）。由于指针类型是基本类型，因此上面的函数f的行为与声明为

的行为相同

int main() {
    f(); // which f?
    return 0;
}

这是第二次重载。这是让这两个重载没有意义的第一个原因。但与后面的相比，这只是一个微弱的原因。

当我说“表现相同”时，我并不是指“等同”。两个重载的返回类型是不同的。正如我们所看到的，我们不能仅仅在返回类型上重载。这是非法的，代码无法编译。

它能保证我有什么不能改变指向m_pointer的内存吗？

不，再次，两个重载都表现相同，并返回指向可通过此指针更改的对象的指针。你想要的是这个：

AnotherClass* const pointer() const;

请注意pointer()左侧的const。

从const成员函数返回类成员的指针

3 个答案: