C++ 这会导致无限循环吗？

对于定义函数的第二个

const

版本，是否保证这样做是安全的？它看起来会有无限递归，因为我想返回

const

，但我想调用的另一个函数是non-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;
}

#包括
使用名称空间std；
课堂测试{
公众：
int*剂量测定法（int a）{
int*someInt=新的int（a）；
返回someInt；
}
常数int*doSomething（INTA）常数{
返回剂量测定法（a）；
}
};
int main（）{
试验a；
cout在这种情况下，编译器总是选择函数的not const版本，甚至不调用const版本。
否则编译器将无法编译，您正在阻止常量。
例如，我快速修改了代码：

#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;
}

#包括
使用名称空间std；
课堂测试{
公众：
int*剂量测定法（int a）{
int*someInt=newint；
*someInt=a；
返回someInt；
}
int ax=10；
无效的某些内容（int i）
{
ax=i；
}
常数int*doSomething（INTA）常数{
某物（a）；
返回0；
}
};
int main（）{
试验a；
cout不完全正确：正如@Pete Becker在评论中指出的那样，如果您调用了
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
版本以特定方式调用它

斯科特·迈尔斯：

当
const
和non-
const
成员函数具有基本相同的实现时，可以通过让non-
const
版本调用
const
版本来避免代码重复

Scott Myers继续提供了一种安全的方法：

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());
}

此代码调用非常量版本的
doSomething
。尝试调用常量版本并观察其爆炸。为什么不在分配时初始化
someInt
：
int*someInt=new int（a）我认为C++不允许只在返回类型上不同的函数重载……ANEDAR：过载不仅在返回类型上不同。它也有不同的CV资格。@ ANNEAR，但它不是。但是这里不是这样的；这两个函数在它们的<代码> const < /Calp>限定符中不同，它决定了哪一个可以。在常量对象上调用，而在非常量对象上调用。我知道它正在泄漏内存。这只是一个示例。出于对您的编码风格的好奇，
somethingElse（）的右括号是
缩进8个空格是有原因的，还是这是一个错误？你可以直接返回int本身，即使是为了测试也不明白为什么你需要一个泄漏的指针。无论如何不是重点。关于括号，是的，是错误，我很快编码了它，一定是在复制粘贴过程中弄糟了。M.G++对我大喊大叫说
警告：类型限定符在函数返回类型上被忽略，所以我将其切换为指针。它可以是常量，但结果是本机类型，并且总是按值传递；因此
常量
没有意义。您可以传递指针和对本机类型的引用。但通常，除非有充分的理由，否则您应该尝试避免它，因为您正在使用更多的memory那么你应该，在64位机器上，指向int的指针或指针是64位的，而int本身很可能是32位的。但是如果你有多个参数用来返回值，那么你可以使用指向本机类型的ref或指针。Scott Myers的解决方案非常完美。我在想是否有办法调用non-
const
在某种程度上，版本来自于
const
版本，我认为您不能。感谢您清楚地解释这一点。部分问题是我对const方法的工作原理的误解：对于让
const
版本调用非
const
版本有任何警告吗？似乎工作正常。是的：
const
成员函数pr不允许永远更改对象的状态，但本质上是调用一个非
const
函数，该函数可以更改对象的状态。让非
const
版本调用
const
版本更安全，因为非
const
函数可以对对象执行任何操作。你是对的，但从从简单删除重复代码的角度来看，它应该不会有什么不同。我做了如下操作：
u8char\u t*codepoint=&\u base[0]当从const方法调用时，它会抛出一个错误，除非我使用静态强制转换删除const。我觉得如果我这样做，那么我可能只需要从
const
中调用非
const
版本，并放弃强制转换。为了澄清，我使用
codepoint
用
c>迭代基本字符串odepoint+length
其中
length
是utf-8字符的宽度（以字节为单位）。
class TestAccess;
class Test
{
    TestAccess& t;
public:
    const TestAccess& getA() const { return t; }
    TestAcess& getA() { return t; }
};