Question

I’m teaching myself C++, and in the process I’m writing simple little programs to learn basic ideas. With respect to “pass-by-reference”, I’m confused why the following piece of code works (some of the code is just there to practice overloading constructors):

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

class Dude
{
public:
  string x;
  Dude();                    // Constructor 1
  Dude(const string &a);     // Constructor 2
};

Dude::Dude() : x("hi") {}
Dude::Dude(const string &a) : x(a) {}

int main()
{
  Dude d1;
  Dude d2 = Dude("bye");

  cout << d1.x << endl;
  cout << d2.x << endl;

  return 0;
}

In “main()”, I create an object “d2” of type “Dude”, and use Constructor 2 to set “x” to be the string “bye”.

But in Constructor 2’s declaration, I told it to accept an address of a string, not a string itself. So why can I pass it “bye” (which is a string). Why don’t I have to create a variable string, and then pass the address of that string to Constructor 2 of Dude?

Answer 1

This actually illustrates one of the coolest and most useful features of C++: Temporary variables. Since you specified that the string reference is const, the compiler allows you to pass a reference to a temporary value to that function. So, here’s what’s happening behind the scenes with Dude d2 = Dude("bye");:

• The compiler determines that the best constructor to use is Dude::Dude(const string &). How this choice is made is a whole different topic.
• However, in order to use that constructor you need a string value. Now, "bye" is a const char[4], but the compiler can trivially convert that to a const char *, and that can be turned into a string. So, an anonymous temporary variable (call it temp1) is created.
• string::string(const char *) is invoked with "bye", and the result is stored in temp1
• Dude::Dude(const string&) is invoked with a reference to temp1. The result is assigned to d2 (actually, it is assigned to another temporary variable and the copy constructor for Dude is invoked with a const reference to it and that is assigned to d2. But in this case the result is the same.)
• temp1 is discarded. This is where the string destructor string::~string() is run on temp1
• Control passes to the next statement