0

First of all thank you very much for your clues.

I'm having a particular problem while trying to finish an assignment. I'm pretty sure is something wrong with namespaces, includes, header files and all this stuff, but don't really know what's going wrong.

The point is this: I need two different classes (let's say Car and CarShop), which each of them has to overload the operator +.

  • Car -> Car &operator+(const Car &c) (should "add" two cars)
  • CarShop -> CarShop &operator+(const Car &c) (should "add" a car to an existing CarShop)

In file CarShop.h, I need to #include "car.h", since it works a lot with different "car" objects. Moreover, in my main test class, let's say main.cpp, I also need to #include "car.h" and #include "carshop.h".

Here I get the error message. Visual Studio (we're working with it as our IDE) gives me "LNK1169 & LNK2005" errors, explaining that "one or more symbols are simultaneally defined".

Anyone could help me please? What should I do in order to avoid this conflict between the two overloaded operators?

PS. Both of them (the 2 overloaded operators) are declared as friend functions for their respective classes (in the .h files), and implemented in their respective .cpp file.

Improve this question
3
  • 4
    (1) Please post your code; without seeing the code that causes the errors, the errors are difficult to diagnose. (2) What does it mean "to add two cars"? (3) Your operator+ should return by value, not by reference, if it follows the behavior of the built-in +: it should not mutate either of its operands and should return a new object. If you want to mutate one of the operands, you should consider using operator+=. Commented Jan 30, 2011 at 17:04
  • 1
    do your .h files have #define guards? Commented Jan 30, 2011 at 17:05
  • 1
    There is an inconsistency in your question: the function declarations you show are for member function operator overloads, but then you say that the overloads "are declared as friend functions." Which is it? Commented Jan 30, 2011 at 17:47

3 Answers 3

Reset to default
2

As others have pointed out, you can't just declare these as friends:

Car &operator+(const Car &c);
CarShop &operator+(const Car &c);

Even if you could compile and link it, it just wouldn't work. And you can't link because they have the same signatures (the return type isn't included in the signature). You have two choices: either have non-member friends or have member functions (no friend declaration is necessary). If you want non-member friends, you should have declared them like this, specifying both operands:

Car operator+(const Car &c1, const Car &c2);
CarShop operator+(const CarShop &cs, const Car &c);

Note that, as James pointed out, these operators shouldn't return references. They return new instances by definition.

However, friend operators are only necessary when the first parameter has type different from any class that is under your control. For example, it would be necessary to declare a friend operator if the first parameter had type std::string or int. However, since these are your classes, you should better declare the operators as members:

Car operator+(const Car &c2); // this is declared inside the Car class
CarShop operator+(const Car &c); // this is declared inside the CarShop class

No need for friends here as they are members. Well, strictly speaking, you may wish to declare CarShop::operator+(const Car&) as a friend in the Car class, if you want to access the Car's private members. But for Car::operator+(const Car&) it is absolutely unnecessary.

Improve this answer
Sign up to request clarification or add additional context in comments.

Comments

1

You are multiply declaring a Car type. In your main.cpp you include car.h and carshop.h while carshop.h already includes car.h. Without inclusion guards this leads to linker errors.

You have two possibilities:

  • remove #include "Car.h" from your main.cpp
  • use include guards like this:

anyfile.h:

#pragma once

/* ... the rest of your code ... */

In the off-chance your compiler doesn't support #pragma once directive you can always use the standard, though a little cumbersome, macro guards in your headers:

myheader.h:

#ifndef MYHEADER_H
#define MYHEADER_H

/* ... your code here ... */

#endif
Improve this answer

1 Comment

The error message seems to indicate a link error, so he probably is already doing this.
1

Short answer: Don't declare those operators as friend.

Long answer: When a function is declared as friend, it means that it does not belong to the class where it is "declared" (in fact, you are not declaring the function there), you are just saying that the function (note that it will be a C function, not a member function) is friend to that class and can access private data.

You are probably using friend becouse you saw code using that for the operator<< (with std::ostream), but that cannot be a member becouse you would need to be a member function of std::ostream. Removing the friend, you will make "this" the first operator.

Improve this answer

Comments

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.