Thread: Friend functions

In my header file I'm declaring some members in this way:

Code:

private:
    int tempLength;
public:
    friend String operator+(const String &, const String &);

Then in the .cpp file I access them this way:

Code:

String operator+(const String &tempStringOne, const String &tempStringTwo){
    tempLength = ....
}

I'm getting an error everytime I try and access tempLength. The compiler says it is undeclared. I thought making the function a friend it would have access to the private data members? Or am I not understanding it?

should be

Code:

String operator+(const String &tempStringOne, const String &tempStringTwo){
    tempStringOne.tempLength = ....
}

because this operator is not a member of String.
Kurt

In my book it says "By making a function a friend to a class, you allow the function the same access privileges that a member function of the class has."

Then it says to declare it the way I did in the header and then in the .cpp to exclude the String:: and the friend keyword. So even though it's not a member of String it still has the same access privileges of a member. But it's not letting me access them.

to access the member tempLength of a String you have to have an object of type String.
Kurt

Originally Posted by laserlight

What have you tried, given ZuK's advice?

Well the thing is I have to keep it as a friend function. I can't use the String:: at the beginning of it because then it won't let me take two arguments because it automatically takes the "this" object and I need to take in the two arguments. So I'm not really sure what to do. I know it's not a member function because I declared it a friend function. So his hint didn't help me much. I'm thinking the friend function can't access the private data members but my book says it can but it doesn't specifically show code that does it.

Originally Posted by ZuK

to access the member tempLength of a String you have to have an object of type String.
Kurt

Shoot. Well I'll show you the rest of that code.

Code:

String operator+(const String &tempStringOne, const String &tempStringTwo){
       
       
       length = tempStringOne.length + tempStringTwo.length;
       buf = new char[tempLength];
       strcat(buf, tempStringOne.buf);
       strcat(buf, tempStringTwo.buf);
       
       String tempString(buf);
       delete [] buf;
       
       return tempString;
       
       }

So I kinda got what you were saying. I used "length" right two out of three times. So I would have to say "int length" and "char * buf" here instead of what I have. That kind of sucks. I think I'll just make the new object at the beginning instead of at the end and then update it's variables.
Thanks for the help.

>> I can't use the String:: at the beginning of it because then it won't let me take two arguments because it automatically takes the "this" object and I need to take in the two arguments.

ZuK didn't advise you to use String::. His sample code tells you exactly what you need to do to access a length variable of an object. But you are already doing that correctly, you just didn't declare the temporary length variable you are using to store the sum. It is just a variable by itself, not a member of String. You need to declare it as an int.

I understand that now. That's why I posted all of my code because when I just posted an example I didn't connect it to how I was using it. I was already accessing the length in the object by String.length. I didn't want to have to go through an object to just use length though. That's where the confusion came in for me.

Originally Posted by laserlight

You could do that, but an alternative is to implement an member function operator+=, then implement a free function operator+ in terms of it. An untested example:

Code:

String& String::operator+=(const String& rhs) {
    int templength = length + rhs.length;
    char* tempbuf = new char[templength + 1]; // Account for null terminator.
    tempbuf[0] = '\0';
    strncat(tempbuf, buf, length);
    strncat(tempbuf, rhs.buf, rhs.length);
    delete[] buf;
    length = templength;
    buf = tempbuf;
    return *this;
}

Now you can just write:

Code:

String operator+(const String& lhs, const String& rhs) {
    return String(lhs) += rhs;
}

Note that operator+ no longer needs to be a friend function.

Wow I already have a overloaded += operator that looks almost identical to that. Wierd. Just out of curiosity what would be more efficient: having the + operator access the += operator or have the + operator just have all the code itself?