Может ли это вызвать бесконечный цикл?

Question

Для определения второй функции функции 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 в основном превращается в thisconst 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. В противном случае компилятор не будет компилироваться, вы торможение констант. Например, я быстро изменил код:

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

Этот пример не компилируется, потому что вы вызываете константную функцию внутри константной области. Компилятор не позволит вам это сделать.

Теперь, я знаю, это тест, но, делая это, вы никогда не выйдете из рекурсии, он будет зациклен навсегда, а также вы пропустите память при каждом вызове, выделив кучу, эти две вещи вместе могут привести к катастрофе.