Question

Consider the following code where I am returning double& and a string&. It works fine in the case of a double but not in the case of a string. Why does the behavior differ?

In both cases the compiler does not even throw the Warning: returning address of local variable or temporary as I am returning a reference.

#include <iostream>
#include <string>
using namespace std;


double &getDouble(){
    double h = 46.5;
    double &refD = h;
    return refD;
}

string &getString(){
    string str = "Devil Jin";
    string &refStr = str;
    return refStr;
}

int main(){
    double d = getDouble();
    cout << "Double = " << d << endl;

    string str = getString();
    cout << "String = " << str.c_str() << endl;

    return 0;
}

Output:

$ ./a.exe
Double = 46.5
String =

Answer 1

You should never return a reference to a local variable no matter what the compiler does or does not do. The compiler may be fooled easily. you should not base the correctness of your code on some warning which may not have fired.

The reason it didn’t fire here is probably that you’re not literally returning a reference to a local variable, you are returning a variable that is a reference to a local variable. The compiler probably doesn’t detect this somewhat more complex situation. It only detects things like:

string &getString(){
    string str = "Devil Jin";
    return str;
}

The case of the double is simpler because it doesn’t involve constructing and destructing a complex object so in this situation the flow control analysis of the compiler probably did a better job at detecting the mistake.