Is this method evaluating a null string?

Question

I'm new to c++, so please bear with me if this is a silly question.

The method below seems to create a string named reversePhrase but with no initial value and then use it phrase.evalPalindrome(reversePhrase):

void testForPalindrome(string origPhrase)
{
   string reversePhrase;
   bool isPalindrome;
   Palindrome phrase(origPhrase);


   if (phrase.evalPalindrome(reversePhrase))
   {
      cout << "This phrase IS a palindrome!" << endl; 
   }
   else
   {
      cout << "This phrase is NOT a palindrome." << endl; 
   }
   cout << "Original phrase: " << origPhrase << endl;
   cout << "Reverse phrase: " << reversePhrase << endl << endl;
}

In java this would create a null pointer exception. But I analyzed the method that is being called and it looks like it is accepts the address of a string.

bool Palindrome::evalPalindrome (string& reversePhrase)
{
   // code
}

But I don't understand how this is working. Does the initial string reversePhrase; simply assign memory to reversePhrase? If yes, how is the calling function able to then print out reversePhrase that is modified from another function (code is not shown, but it is modified from the other function).

It just seems like writing code this way is hard to read.

Answer 1

In java this would create a null pointer exception.

That's because Java is a different language with different object-creation syntax.

In C++, as soon as you wrote string reversePhrase, that object was fully-formed and ready to go.

---

But I analyzed the method that is being called and it looks like it is accepts the address of a string.

No, it accepts a reference to a string! And that's why the calling scope can later see the modified string!

Answer 2

string& reversePhrase doesn't declare evalPalindrome to take the address of a string. It declares the function to take a reference to a string. (Declaring it with string* would mean the address of a string, aka a pointer to a string.)

In C++, when you initialize a string with no arguments:

string reversePhrase;

it creates an empty string, so reversePhrase is equal to "". Thus it's not a null string, just an empty one, which you can safely pass by reference to the evalPalindrome function, which will then be able to modify the original string object passed to it.

Answer 3

You are not creating a pointer but a object of type string. It is never assigned so it should just be a blank string "". Getting the address to it will work fine as it is a valid object.

I am not sure how that function would be a working one though.

Answer 4

What is happening here is what is called pass by reference. Normally, when you pass a variable in C++, a copy of it is made. Which is why when you run the below, you will get "A", "B", "A".

int main(){
    string s = "A";
    cout << s << endl;
    cngLetter(s);
    cout << s << endl;
}

void cngLetter(string s){
    s = "B";
    cout << s << endl;
}

If you pass by reference, then it will update it on the main thread. The following will print "A", "B", "B"

int main(){
    string s = "A";
    cout << s << endl;
    cngLetter(s);
    cout << s << endl;
}

void cngLetter(string& s){
    s = "B";
    cout << s << endl;
}

Note that only one character was added to that, the & which causes a pass by reference, i.e. not a copy, but instead the memory address. No need for me to type up a lot in this post, as you can read up on it here

Now strings aren't unmanaged memory, so if you don't assign it at first, then you will instead get "", "B", "B"

int main(){
    string s;
    cout << s << endl;
    cngLetter(s);
    cout << s << endl;
}

void cngLetter(string s){
    s = "B";
    cout << s << endl;
}

Basically, a string that is not given an inital value is just an empty string.

Answer 5

The '&' operator in this context is syntactical candy for '*'. Within the evalPalindrome method, while reversePhrase is passed in as a pointer, it is ALWAYS dereferenced. This makes the common error of not dereferencing a pointer impossible. You're right that it can make for confusing code, as the passed-in value can be modified similar to if it had been passed in as a pointer, except that the calling function has no indication that it is being passed in as a pointer unless you specifically look at the method signature.