Purpose of Operator Overloading

I was reading an article about this and I'm totally lost as to what the purpose of using operator overlaoding is. Could someone give me an explaination as to what it's main purpose is?

While I'm at it, I'm also confused on the purpose of copy constructors. I have an idea as to what they're used for so I'm gonna shoot and if it's wrong or anything, correct me because I'm sure I'm thinking the totally wrong thing.

I think a copy constructor would be more useful when you have a VERY VERY generic class that you want to create more specific classes out of but use the private members of the generic class in the more specific one.

Again, I'm probably thinking the totally wrong thing but I'm lost so any help would be appreciated. Thanks in advance.

Quote:

---

I was reading an article about this and I'm totally lost as to what the purpose of using operator overlaoding is. Could someone give me an explaination as to what it's main purpose is?

---

Take the string class for instance. They overloaded the + operator so that you could concatenate strings with it.

Quote:

---

Take the string class for instance. They overloaded the + operator so that you could concatenate strings with it.

---

So in other words, it's more or less a way to modify the behavior of an operator to better suit your needs?

Right. Another example is cout and cin. The << and >> operators are normally used for bitshifting, but they've been overloaded.

The purpose of overloading operators is to make code pretty.

C:
strcat(strcpy(string3, string1), string 2);

C++:
string3 = string1 + string2;

Ah I see. That clears that issue up. Thanks for the help.

As for the copy constructor, let's say you have a Widget:

Widget a(1, 2);

and you wanted to make b exactly like Widget a. You can use the copy constructor to make more Widgets out of other Widgets.

Widget b(a);

That's what the copy constructor does.

Quote:

---

As for the copy constructor, let's say you have a Widget:

Widget a(1, 2);

and you wanted to make b exactly like Widget a. You can use the copy constructor to make more Widgets out of other Widgets.

Widget b(a);

That's what the copy constructor does.

---

Okay so by using the copy constructor, it basically saves you from having to write code for classes that are identical?

Taking from your example, I'm guessing that widget b would have the same properties as widget a?

No, the purpose of writing a copy constructor is to take advanced action on copying that the version created by the compiler doesn't do automatically. citizen's post was misleading.

The typical example is a class that allocates memory inside and stores a pointer to it, then frees that memory in the destructor. (A string class would do that.) If the author doesn't write a copy constructor, the compiler will generate one that will just copy the pointer. Suddenly, both string objects (the old and the new one) point to the same memory, resulting in that memory being freed twice, which is an access violation. A custom copy constructor would allocate new memory for the copy and transfer the string contents over.

hmmm That was slightly confusing.

Okay lets say I have a class called enemy and it looks something like this:

Code:

---

class enemy{
private:
    int a, b;
public:
    enemy();
    enemy(int a, int b);
    //copy constructor
    enemy(enemy &newEnemy);
};

---

Now in my main function, I have the following statements:

Code:

---

enemy enemy1(5, 7);
//using the copy constructor
enemy enemy2(enemy1);

---

The first statement instanciates the enemy class in enemy1. The second statement instanciates the enemy class again in enemy2. Enemy1 and enemy 2 both have private members a and b. Now assuming you code the copy constructor to copy the values of private members a and b, if I were output the values of enemy1.a and enemy2.a, they would be the same right?

Yes, they would be the same. But in this case you wouldn't need a copy constructor. The compiler provides one for you. You could write enemy b(a) even if you didn't write the copy constructor.

You'll need it for more complicated classes. Classes that allocate memory dynamically (because two separate objects shouldn't use the same piece of free memory).
Or for classes that have static members. For example, if you used a static variable to keep track of how many objects exist (in constructor increment it, in destructor decrement). Now the compiler-generated copy constructor wouldn't know that it needs to increment the static counter, and this would mess up the counting.

Here's a tutorial: http://cplus.about.com/od/beginnerct.../aa072802a.htm

Overloaded operators don't always have to be a member of a class - if you wish to customise behaviour for operators involving classes which you have no control over, (such as standard library classes) then you can overload the operator outside the class, eg,

Code:

---

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

class MyDate
{
    int day, month, year;
public:
    MyDate(int d, int m, int y) : day(d), month(m), year(y) {}
    friend ostream& operator<<(ostream& os, MyDate md);
};

ostream& operator<<(ostream& os, MyDate md)
{
    os << md.day << '/' << md.month << '/' << md.year << '\n';
    return os;
}

int main()
{
    MyDate foo(15, 8, 1982);
    cout << foo;
}

---

This snippet outputs:

Code:

---

15/8/1982

---

I find this method extremely useful for manipulating text i/o