API更改上的函数参数的常量正确性

Question

Suppose I am using a library which implements the function foo , and my code could look something like this:

void foo(const int &) { }

int main() {
    int x = 1;
    foo(x);
    std::cout << (1/x) << std::endl;
}

Everything works fine. But now suppose at one point either foo gets modified or overloaded for some reason. Now what we get could be something like this:

void foo(int & x) {
    x--;
}
void foo(const int &) {}

int main() {
    int x = 1;
    foo(x);
    std::cout << (1/x) << std::endl;
}

BAM. Suddenly the program breaks. This is because what we actually wanted to pass in that snippet was a constant reference, but with the API change suddenly the compiler selects the version we don't want and the program breaks unexpectedly.

What we wanted was actually this:

int main() {
    int x = 1;
    foo(static_cast<const int &>(x));
    std::cout << (1/x) << std::endl;
}

With this fix, the program starts working again. However, I must say I've not seen many of these casts around in code, as everybody seems to simply trust this type of errors not to happen. In addition, this seems needlessly verbose, and if there's more than one parameter and names start to become longer, function calls get really messy.

Is this a reasonable concern and how should I go about it?

Answer 1

If you change a function that takes a const reference so that it no longer is a const, you are likely to break things. This means you have to inspect EVERY place where that function is called, and ensure that it is safe. Further having two functions with the same name, one with const and one without const in this sort of scenario is definitely a bad plan.

The correct thing to do is to create a new function, which does the x-- variant, with a different name from the existing one.

Any API supplier that does something like this should be severely and physically punished, possibly with slightly less violence involved if there is a BIG notice in the documentation saying "We have changed function foo , it now decrements x unless the parameter is cast to const". It's one of the worst possible binary breaks one can imagine (in terms of "it'll be terribly hard to find out what went wrong").