可能会导致无限循环？

Question

要定义第二个const版本的函数，是否可以安全地执行此操作？它看起来像会有无限递归，因为我想返回const，但我打算调用的另一个函数是非const。

它适用于g ++，但我担心这是不安全的。

#include <iostream> 

using namespace std; 

class test { 
public: 
    int* doSomething(int a) { 
     int* someInt = new int(a); 

     return someInt; 
    } 

    const int* doSomething(int a) const { 
     return doSomething(a); 
    } 
}; 

int main() { 
    test a; 

    cout << *a.doSomething(12345) << endl; 

    return 1; 
} 

Answer 1

不太：作为@Pete贝克尔在评论中指出的，如果你曾经被称为const版本将递归：

class test { 
public: 
    int* doSomething(int a) { 
     int* someInt = new int; 
     *someInt = a; 
     return someInt; 
    } 

    const int* doSomething(int a) const { 
     return doSomething(a); 
    } 
}; 

int main() { 
    const test a; 
    // You're not in for a good time: 
    a.doSomething(12345); 
    return 1; 
} 

在提供const和非const版本的函数是需要重复的代码，最好实施const版本，然后让非const版本以特定方式调用它。

从斯科特迈尔斯Effective C++ - Third Edition：

当const和非const成员函数具有基本上相同的实施方式中，代码重复可以通过使非const版本调用const版本

避免斯科特·迈尔斯继续提供一个安全的方法来做到这一点：

const int* doSomething(int a) const 
{ 
    int* someInt = new int; 
    *someInt = a; 
    return someInt; 
} 

int* doSomething(int a) 
{ 
    return const_cast<int*>(static_cast<const Test&>(*this).doSomething()); 
} 

在非const版本，有两种类型转换：在static_cast基本上变成this到const this，其中const_cast擅自抛弃的const -ness的回报。这是安全的，因为要拨打非const版本，您必须拥有非const this。

但是，如果你只是提供一个成员访问，它的简单和易于阅读，只是有以下几点：

class TestAccess; 
class Test 
{ 
    TestAccess& t; 
public: 
    const TestAccess& getA() const { return t; } 
    TestAcess& getA() { return t; } 
}; 

Answer 2

在这种情况下，编译器总是会选择函数的非const版本，甚至不会调用const函数。 否则编译器将不会编译，您正在制动constenss。 比如我修改迅速代码：

#include <iostream> 

using namespace std; 

class test { 
public: 
    int* doSomething(int a) { 
     int* someInt = new int; 

     *someInt = a; 
     return someInt; 
    } 
    int ax = 10; 
    void somethingElse(int i) 
    { 
     ax = i; 
    } 
    const int* doSomething(int a) const { 
     somethingElse(a); 
     return 0; 
    } 
}; 

int main() { 
    test a; 

    cout << *a.doSomething(12345) << endl; 

    return 1; 
} 

这个例子并不能编译，因为你调用一个const范围内const函数。编译器不会让你这样做。

现在，我知道是一个测试，但通过这种方式，你永远不会退出递归，它将永远循环，并且在每次调用时都会通过在堆上分配来泄漏内存，这两件事在一起可能会导致发生灾难。