Operator overloading in template in C?

Operator T() const {return a;} This is the typecast operator It'll implicitly convert the class instance to T In the example code you've posted this conversion is being performed at the line int n = a.

Operator T() const {return a;} This is the typecast operator. It'll implicitly convert the class instance to T. In the example code you've posted this conversion is being performed at the line int n = a.

Clear answer. Thanks Praetorian! – Bill Li Aug 23 at 16:04 1 @Bill Li - In C++11 you'll be able to use the explicit keyword with those just like you can with one argument constructors.

That way you can still get the conversion but it will never happen implicitly. – Omnifarious Aug 23 at 16:58.

It means if you want to convert an instance into a T you can use this operator, which here returns a copy of the private member. In your example code that is how you can assign a, which is of type A to an int directly. Try removing the operator T() and see how that fails to compile, with an error about assigining A to an int.

With the non explicit constructor (the opposite of marking a constructor explicit) there too it makes this type behave a lot like the template type itself in a number of circumstances. In effect you've wrapped a T inside another class that behaves like a T when it needs to. You could extend this to do other, more useful things like monitoring/logging/restricting the use of real instances by hiding them behind something which controlled them.

Also notice how you can change A a = A(5); to simply A a = 5; because of the implicit constructor.

Thanks for the reply. Is it trying to overload cast? The explicit syntax would be: int n = (int)a; I also agree with your point regarding explicit constructor.

– Bill Li Aug 23 at 15:57 the explicit I mentioned only applies to the constructor and has nothing to do with operator T(), which is what allows the assignment. Int n = (int)a; is just a cast, which happens to be a C-style cast too. (For C++ prefer static_cast and friends) – awoodland Aug 23 at 16:02.

It's basically making a functor - which is an object with function semantics. That means you can call the object just like a function as a replacement in places where you may have used a function - its a generic programming concept. It's beneficial because you can have multiple instances of that function-object (functor) and they can each maintain their own state, where as if you had a straight-up function then it could only maintain state via static variables, and it would thus not be re-entrant (you only ever get one instance of a static variable).

Functors are heavily used in STL algorithms as an extra optional parameter.

3 -1: the object does not overload operator(), so it is not a function object. – André Caron Aug 23 at 15:51 1 Nope, a functor would have the signature operator()( ) – Praetorian Aug 23 at 15:56.

Generally an operator of that form would be declared as: Distance operator+(int lhs, const Distance& rhs) { // Assuming the int value represents feet return Distance(rhs. Feet + lhs, rhs. Inches); } You'd probably also want to define the symmetric: Distance operator+(const Distance& lhs, int rhs) { // Assuming the int value represents feet return Distance(lhs.

Feet + rhs, lhs. Inches); } Also, I suggest you heed the advice of James McNellis--your job will be simplified if you just have one member representing lengths in a single unit.

– JBRWilkinson Sep 3 '10 at 7:46 class Distance { private: int feet,inches; Distance():feet(0),inches(0) {} Distance( int a,int be ):feet(a),inches(b) {} Distance operator+( int &lhs ,const Distance &rhs) { return (rhs. Feet+lhs,rhs. Inches) } }; int main() { Distance c7,c2(2,2); c7=3+c2; coutFeet– Salar Sep 3 '10 at 11:24 @Drew Hall :error C2511: 'Distance Distance::operator +(int,const Distance &)' it says overloaded member function not found in 'Distance' ........friend Distance operator+(int lhs, const Distance& rhs); which has been declared inside class Distance.

Only I have this error left nd I am sure that I defined function's body outside class. – Salar Sep 9 '10 at 3:18 @Salar: You've defined it outside the class, but it's still a member function of the class (that's what the Distance:: prefix means). You need to define it as a free function (non-member, thus no Distance:: prefix) outside of the class.

In fact, just copy and paste the code I gave above after your class definition (and remember to write "inline" in front of each function) and it should work. – Drew Hall Sep 9 '10 at 3:33 Yes it worked but I really did'nt get the logic behind it. Operator overloading function should be part of the class?

How would it come to know that it has to overload the operator... – Salar Sep 10 '10 at 19:16.

Several answers now suggest using a non-member operator+ overload to allow "addition" of Distance and int objects. This doesn't really make sense: what does it mean to add a Distance, which has a unit, to an int, which does not? However, it does make sense to add two Distance objects together.

If you have one distance of two feet and add another distance of three feet to it, you get a distance of five feet. This makes sense. You can accomplish this by overloading operator+ between two Distance objects (for simplicity, I've assumed that your Distance only has a single field containing inches.In a real-world application, you wouldn't want to have separate fields for inches and feet.

You'd probably want to use an SI unit, like meters, but that depends on the application and is entirely up to you): Distance operator+(const Distance& lhs, const Distance& rhs) { return Distance(lhs. Inches + rhs. Inches); } This doesn't help you, though, if you want to be able to do something along the lines of Distance d; d = d + 42; // assume 42 has the same units as a Distance object has In order to get this to make sense, you can use a converting constructor: struct Distance { Distance(int in = 0) : inches(in) { } private: int inches; }; The constructor here is a converting constructor because it is not explicit and can be called with a single argument.

It allows a single int (or a value that is implicitly convertible to an int) to be converted to a Distance object. This allows you to write Distance d; d = d + 42; Why is this different from using an operator+ overload that takes a Distance and an int argument? Simple: it forces the conversion from int to Distance to take place before the addition, so the actual addition doesn't have to care about its operands: it simply adds two distances together and lets the Distance constructors deal with any conversions that need to take place.

– Chubsdad Sep 3 '10 at 7:34 2 @chubsdad: Well, if the constructor is explicit then it is not a converting constructor (a converting constructor is, by definition, a constructor that is not explicit and that can be called with a single argument). If the constructor were explicit, it would not be considered as a user-defined conversion and you would not be able to perform d + 42. You would need to perform d + Distance(42).

There are scenarios under which converting constructors are useful, and this is potentially one of them. I don't think the presence of a converting constructor immediately indicates a design flaw. – James McNellis Sep 3 '10 at 7:37 1 Even if you rule out 3 + Distance(4), you still need similar overloading for 3 * Distance(4) – MSalters Sep 3 '10 at 7:41 @MSalters: If I understand your comment correctly, you are saying that my converting constructor suggestion falls apart if you need other operators (like operator*).

I completely agree (I'll try to revisit this answer in the morning to discuss that, unless someone beats me to it; I don't know what I'm doing answering questions at 3am anyway... ;-). – James McNellis Sep 3 '10 at 7:55 3 @James McNellis : Yup, operator*(Distance, Distance) will return an Area. Hence the need for an Distance operator*(int, Distance); an implict conversion int->Distance won't do.

– MSalters Sep 3 '10 at 8:22.

You need to write a free function (outside the class): Distance operator+(int lhs, const Distance& rhs) { return ...; } If ... needs to use private members of Distance then make it a friend in Distance. Class Distance { ... friend Distance operator+(int lhs, const Distance& rhs); }; Finally, if you want to be able to + with Distance on the left-hand side, just define another operator+ overload as above, but with Distance as the first argument. All this said, I would avoid doing what you appear to be doing.As a user of your Distance class, I don't know whether what you are doing would add 3 feet, 3 inches, or 3 meters.

If you aren't going to use SI units (meters) then you shouldn't allow addition with non-Distance values.

Beat me to it! :) – Drew Hall Sep 3 '10 at 6:57 3 Even if you are using SI units, you should usually disallow weakly-typed addition for consistency with multiplication. Distance(3) * Distance(4) and Distance(3) * 4 both make sense but have different meanings.

You can't afford to have an implicit conversion from int to Distance there. – MSalters Sep 3 '10 at 7:45 Hmm? If Distance is in meters then surely they both evaluate to Distance(12)?

– Peter Alexander Sep 3 '10 at 8:32 @ Peter Alexander:Thanks – Salar Sep 3 '10 at 10:27 error C2511: 'Distance Distance::operator +(int,const Distance &)' it says overloaded member function not found in 'Distance' ........friend Distance operator+(int lhs, const Distance& rhs); which has been declared inside class Distance. Only I have this error left. – Salar Sep 3 '10 at 6:09.

Apart from overloading the + operator taking two Distance objects you should avoid overloading operator+(const Distance &, int) as pointed out in other answers. It's better to define some constants like: const Distance feet(1,0); const Distance inch(0,1); and also overload the operator*(int, const Distance &) so that you then can write: Distance dist = 3 * feet + 5 * inch; Distance dist2 = dist + 2 * feet; which is more readable.

While not exactly an answer I'd like to point out that Boost::Units probably solves the OPs original problem throughoutly. Still it's useful to understand the mechanisms involved.

Yes, it is necessary, if you want all of them to work the way you want them to work C++ does not force any specific semantics on most of the overloadable operators. The only thing that is fixed is the general syntax for the operator (including being unary or binary and things like precedence and associativity). This immediately means that the actual functionality that you implement in your overload can be absolutely arbitrary.In general case there might not be any meaningful connection between what operator does and what operator!

Does. Operator might write data to a file, while operator! Might sort an array While overloading operators in such an arbitrary fashion is certainly not a good programming practice, the C++ language cannot assume anything.

So, no, it cannot and will not automatically use! Combination in place of! Or!

Combination in place of.

Yes, it is necessary, if you want all of them to work the way you want them to work. C++ does not force any specific semantics on most of the overloadable operators. The only thing that is fixed is the general syntax for the operator (including being unary or binary and things like precedence and associativity).

This immediately means that the actual functionality that you implement in your overload can be absolutely arbitrary. In general case there might not be any meaningful connection between what operator == does and what operator! = does.

Operator == might write data to a file, while operator! = might sort an array. While overloading operators in such an arbitrary fashion is certainly not a good programming practice, the C++ language cannot assume anything.So, no, it cannot and will not automatically use!

== combination in place of! =, or! > combination in place of.

Your example for == and! = is rather contrived. A more realistic one would be a class representing a SQL object, where you have to deal with the special semantics of NULL.

– dan04 Jul 2 '10 at 1:37.

Boost operators might be what you are looking for. These will derive most of your operators based on a few fundamental ones. That C++ does not provide this automatically makes sense, as one could give totally different meanings to , for example (although it would often be a bad idea).

1 C++ does provide this as std::rel_ops, but it's hard to use correctly and possibly shorter to just type them out yourself instead (avoiding the confusion). – Roger Pate Feb 6 '10 at 23:06.

No, you only need to overload operator == and operator.

Don't think this is so... If it was true why would this page give example of defining! = in terms of ==? Cs.caltech.Edu/courses/cs11/material/cpp/donnie/cpp-ops.

Html – Harley Green Feb 6 '10 at 23:01 Thanks for the clarification. – Harley Green Feb 6 '10 at 23:03 1 No it won't, you have to explicitly define each operator. – Igor Zevaka Feb 6 '10 at 23:05 2 @Autopulated: That one using directive is not enough, you need individual using declarations for each operator to introduce the names into the namespace so that they can be found through ADL.

– Roger Pate Feb 6 '10 at 23:27.

I am going to take a minority viewpoint here. If you already use boost then using boost operators is not that big of a deal. It may be the correct and tested way to do things but adding boost dependency just for the operators is an overkill.It is possible to write complex C++ programs without boost (which I personally find aesthetically unpleasant) and so to Keep It Simple (Stupid), to answer OP's question, if you overload operator ==, you should also overload operator!

=. Same is true for , ++ etc.

2 If you don't like boost, for whatever reason, that doesn't mean you can't use the same technique. My answer contains a link to a single, self-contained header I wrote as an example of how to do exactly that in this case. – Roger Pate Feb 6 '10 at 23:30 I am just answering the question - C++ does not automatically call operator == and invert the result when!

= is not defined. Not disputing that there is an automagic way to do that. – Igor Zevaka Feb 7 '10 at 3:49.

Yes it is necessary to overload whichever operators you want to be used as you define them - C++ will not make the decision you describe above; however, keep in mind that if the reason you are overloading is to sort your class, than you only need to override the operators used by the sort routine. In the case of the RTL sort algorithm you only need to override.

Yes! They are each technically different operators. C++ compilers are not inherently inference engines, they are parsers/compilers.

They will only do as much as you say to do. parashift.com/c++-faq-lite/operator-over..., en.wikipedia.org/wiki/Operators_in_C_and....

Except they are inference engines! Look at ADL and figure out the function overload resolution rules for a good long headache. – Roger Pate Feb 6 '10 at 23:02 I suspect there would be a lot of AI researchers who would disagree with you on the technical definition of an inference engine in computer science.

But yes, what modern compilers can "figure out" is impressive. – Harley Green Feb 6 '10 at 23:09 The definition I'm using: "An inference engine is a form of finite state machine consisting of three actions: matching, selecting, and executing rules. " The rules are simply a combination of function overload resolution and the declarations of functions and types in the program.No argument that it's primitive, of course.

– Roger Pate Feb 6 '10 at 23:24.

There are a few shortcuts you can use, such as CRTP to get them automatically injected (see the various Compare classes) into your class.

2 I wonder why this and stakx's now-deleted answer were down-voted. – GMan Feb 6 '10 at 22:59 Beats me, I gave up worrying about rep long ago, but I still see people playing games trying to influence answers. – Roger Pate Feb 6 '10 at 23:00 2 Please explain reasons when you downvote.

– Nicolás Feb 6 '10 at 23:30.

You can use overloading to use user defined names also . Operator overloading means using same operator to do perform operation on different items which are not in that category. And function overloading means using same name of function but different arguments,so as to overcome the overheads when same function is called during looping.

*strong text.

C++ does not, as a language, define any operator in terms of any other overloaded operator. Just because you have operator+, doesn't mean you get operator+= for free (unlike Ruby and Scala). Just because you have operator for free.

Std::relops (if imported correctly) and provide default definitions, and Boost provides some mix-ins that define all of the comparison operators in terms of.

Look at the operator precedence chart This will tell you the direction the operator associates (binds). Note that some operators have multiple forms with different meanings, such as binary and unary In such cases, you may have multiple overloads, e.g. : T operator-() and: T operator-(const T &o) The compiler chooses the right one based on the syntactical interpretation of the operator See also this useful set of guidelines.

Look at the operator precedence chart. This will tell you the direction the operator associates (binds). Note that some operators have multiple forms with different meanings, such as binary and unary -.

In such cases, you may have multiple overloads, e.g. : T operator-() and: T operator-(const T &o) The compiler chooses the right one based on the syntactical interpretation of the operator. See also this useful set of guidelines.

– Jonathan Leffler Mar 21 '10 at 5:15 Thanks for catching that, Jonathan. Fixed now. – Matthew Flaschen Mar 21 '10 at 5:27.

Most unary operators can only be placed at a specified side of their operand. For the two special cases, ++ and --, see this FAQ.

I cant really gove you an answer,but what I can give you is a way to a solution, that is you have to find the anglde that you relate to or peaks your interest. A good paper is one that people get drawn into because it reaches them ln some way.As for me WW11 to me, I think of the holocaust and the effect it had on the survivors, their families and those who stood by and did nothing until it was too late.