// Option 1: intrusive concatenation
String operator + (const String & s1, const String s2)
{
 int len=s1.size()+s2.size();
 String result;
 result.buf=new char[len+1];
 strcpy(result.buf, s1.buf); 
 strcat(result.buf, s2.buf); // concatenate second string
 return result;
}

Although this implementation works fine, there is a less intrusive and more flexible solution based on the overloaded += operator.

Option 2: Using Operator +=
Instead of accessing private data members, allocating memory and using C functions, our implementation can use the overloaded += operator:

// Option 2: using operator +=
String operator + (const String & s1, const String s2)
{
 String result=s1;
 result+=s2;
 return result;
}

This implementation is easier to maintain and doesn't access nonpublic members of class String. In fact, we don't even need to declare it as a friend function. The implementation of operator += is left as an exercise for the reader.

Our discussion focused on a homemade String class because this is the most widely-used example of using the overloaded + operator. However, you can apply the guidelines and strategies that I have shown to any user-defined type. Overloading operator + correctly is based on these principles:

Danny Kalev is a system analyst and software engineer with 13 years of experience, specializing in C++ and object-oriented analysis and design. He is a member of the ANSI C++ standardization committee and the author of ANSI/ISO C++ Professional Programmer's Handbook (Que, 1999, ISBN: 0789720221). Check out the DevX review here. He can be reached at dannykk@inter.net.il.

Previous: Choosing Between a Member Function and a Non-Member Function

Introduction Choosing Between a Member Function and a Non-Member Function Implementation Return to Get Help with C/C++ Page Return to Main Get Help Page