Assigning a float to a string reference works—why? [duplicate]

Question

On a recent project, I ran into an error where I accidentally assigned a float to a string reference (instead of converting the float to a string, then assigning it).

The code looked something like this (tested under both Xcode/Apple LLVM 7.1 and GCC 4.9.2):

#include <iostream>
using namespace std;

static void get_text(string &s) {
    s = 1.0f;  // Legal (not even a warning!)
}

// This version gives a compiler error (as I'd expect)
// static void get_text(string &s) {
//     string out = 1.0f;
//     s = out;
// }

int main() {
    string s;
    get_text(s);
    cout << s << endl; // Prints garbage
    return 0;
}

Printing the string obviously results in garbage, but I'm not clear why this didn't give so much as a warning. (My best guess is that the compiler did some sort of implicit reinterpret cast to go from float, to int, to a memory address...?)

Is there a warning I could enable (in Xcode, ideally) that would prevent this sort of thing in the future?

Answer 1

This is because of the member function:

string& operator=( char ch );

There is implicit conversion from floating point to integer types in C++ (char is an integer type).

Normally you can use -Wfloat-conversion in g++ to get a warning about this conversion, but I tried it and it didn't warn. (Maybe compiler bug?)

A simple way to modify the code to get errors for unexpected floating/integer conversions is:

s = { 1.0f };

Another option is to make the function have string as return type (generally speaking this design is preferred to having an "out" reference parameter anyway):

static string get_text() { return 1.0f; }

Unfortunately this is one of many minor pitfalls surrounding the use of std::string, which was "designed" when C++ was still very young and it was not apparent what undesirable long term consequences would arise.