C ++ getter函数：const和非const

Question

I'm writing a program with a robot class in C++. The following code, when I try to access the getter crash with

==19724== Stack overflow in thread 1: can't grow stack to 0xffe801ff8
==19724== Warning: client switching stacks?  SP change: 0x15788828 --> 0xffeffe990
==19724==          to suppress, use: --max-stackframe=68342473064 or greater
unknown location(0): fatal error in "trying": memory access violation at address: 0xffe801ff8: no mapping at fault address

Here is the getter code :

#ifndef ROBOT_MAP
#define ROBOT_MAP

#include <iostream>
#include <stdio.h>
#include <cv.h>
#include <highgui.h>

class Robot{
protected : 

    int _y;
    int _x;
public : 

    Robot(int x, int y): _x(x), _y(y){};

    void setX(int x){_x = x;}
    void setY(int y){_y = y;}

    const int& getX() const {return _x;}
    int& getX(){return const_cast<int&>(static_cast <Robot &>(*this).getX());}
    const int& getY() const {return _y;}
    int& getY(){return const_cast<int&>(static_cast <Robot &>(*this).getY());}


};
#endif

I'm trying to implement the const and non const function correctly as I found it defined somewhere else on this site. The same kind of getter returning a std::vector works but as soon as try SomeRobot.getX() , it crashes.

I've been running it in valgrind and it didn't gave me much more information.

So what is wrong in the code that makes it crash ?

Answer 1

Here:

int& getX(){return const_cast<int&>(static_cast <Robot &>(*this).getX());}

Since *this is cast to Robot & (ie, not changed), the non-const version of getX() is called, making this function infinitely recursive. It goes on to die with a stack overflow.

Instead, write

//                                                     vvvvv-- here
int& getX(){return const_cast<int&>(static_cast <Robot const &>(*this).getX());}

to make getX() call getX() const . The same applies for getY() .

Obligatory note: Be very, very, very careful with const_cast . This is one of the few contexts where using it makes some sense ¹ and is not insanely dangerous. Although, I have to say that the function bodies of getX() and getY() are short enough that I'd have no qualms duplicating them.

¹ That is to say, would make some sense if the functions were more complicated.