Printable View
I have yet to use overloaded functions or constructors in any of my applications. That includes 2D games and the like. A lot of people say it's the best thing ever, but I don't see what could possibly be done with this. I've been doing C++ for over a year, and haven't used this even once, even though I understand the concept. Can someone show me an example of how this could be used effectively and not just for preference reasons? Thanks!
>I've been doing C++ for over a year, and haven't used this even once
Then you haven't needed it yet. There's nothing wrong with that at all. :)
>Can someone show me an example of how this could be used effectively and
>not just for preference reasons?
An excellent example of overloading would be the << and >> operators that you probably use heavily with iostreams.
Well, that would be operator overloading correct? I was specifying an example to be based on function overloading or even constructor overloading. Yes, I have used those operators alot! :D
>I was specifying an example to be based on function overloading
An overloaded operator is a function as well.
>or even constructor overloading
Constructors are even easier. Take a look at the string class. For member function overloading, take another look at the string class. :)
If you've ever had a constructor that takes an argument, then you probably could have overloaded it. More often than not, my classes will have a default constructor because the argument it takes is optional when it's instantiated.
As for overloading operators... they're really just a convenience thing. You could take any overloaded operator and simply make a function that does the same thing, but there are lots of times where specific operators simply seem like a logical replacement for a function.
I might also dare to say that templating could be considered overloading since that's essentially what the compiler does when you compile the code.
If you are working with CString you can't use << >> unless you overload them:
Code:// Operator << for input of the object
ostream& operator<<(ostream& os, const CString& str)
{
os << (const char*) str;
return os;
}
// Operator >> for output of the object
istream& operator>>(istream& is, CString& str)
{
char s[80];
is >> s;
str = s;
return is;
}
>If you are working with CString you can't use << >> unless you overload them
That's a shame. Good thing std::string is vastly superior. :) By the way, your overloaded operator>> is exceptionally poor. First, you impose a hidden size limitation by using an array. Second, you don't enforce that limitation when reading into the array. The former is poor programming practice and the latter is potential undefined behavior.
I know operator overloading but I rarely use it. As for function overloading, it can be useful when you want to use two functions that have the same name
Code:ijnt func ( int x, int y )
{
// code
}
// overloaded function
float func ( float x, float y )
{
}
Well, good examples of function overloading occur on the standard library. Take a look at the std::string.find() for instance, http://www.cppreference.com/cppstring/find.html, or the STL containers for constructor overloading examples like the std::map object for instance, http://www.cppreference.com/cppmap/m...structors.htmlQuote:
Originally Posted by Sentral
You mean you haven't ever concatenated two std::strings with + ? I have a hard time believing that.Quote:
Originally Posted by Sentral
If you haven't overloaded any operators yourself, that's fine (although it suggests you're not using the full power of the STL), but pretty much everyone uses operators that are overloaded by some library. (Not using them probably means that you're not using a proper string class, no smart pointers, no index access operator for accessing your smart array, ... in other words, you're missing out on a lot of good programming practice.)
Overloading operators is something you typically do in general-purpose libraries, not in applications.
>> If you are working with CString you can't use << >> unless you overload them
operator << should definitely work, since CString has an implicit conversion to const char*. Although I would imagine that its not common to use fstreams and the MFC string class in the same place.
I didn't realize that it would be considered overloading!:o Maybe I have used it!Quote:
You mean you haven't ever concatenated two std::strings with + ? I have a hard time believing that.
you probably used it in your first ever C++ program..Quote:
Originally Posted by Sentral
Although at the time, its unlikely you were told that << is an overloaded bitwise-left-shift operator :)Code:#include <iostream>
using namespace std;
int main()
{
cout << "Hello, World!";
}