[c++] Operator overloading - call problem
 

I'm finishing up an assignment and I've hit a snag on calling an overloaded operator in a class.

Here's the generals,

-4 employee child classes created from a virtual "Employee Class"
-objects created dynamically and stored in a base pointer array
-each child class has an overloaded operator == in order to do a search by last name w/o using a get function.

The code for the overloaded operator looks like this:

-----------------------------------------------------

bool operator == (string lName)
{ bool result=false;
if (empLastName == lName)
result = true;
else
result=false;
return result;

}
-----------------------------------------------------

The compile error happens at the call:

-----------------------------------------------------

do
{
if (*employee[j] == findLastName)
{
found = true;
foundCount = j;
};
j++;
}while ((!found)&& j<empCount);

----------------------------------------------------

The error is funky:

error C2784: 'bool std::operator ==(const std::basic_string<_Elem,_Traits,_Alloc> &,const _Elem *)' : could not deduce template argument for 'const std::basic_string<_Elem,_Traits,_Ax> &' from 'Employee'

----------------------------------------------------

Anyway, any ideas would be greatly appreciated

Well, more code is necessary to tell for sure, particularly class and variable definitions, but I can give some suggestions. I am assuming here that your operator== is an inline-defined class member and employee is an array of Employee pointers.

First, the parameter(s) to an overloaded operator function like == that doesn't modify anything should be const references if they aren't basic types.

Second, the type that you get back from the expression *employee[j] is Employee. So operator== needs to be defined in the Employee class. If you have it defined in the subclasses and not the base class, not only is it a fundamental design problem because any operations that are the same in all subclasses should be in the base class, but also it simply won't work as the compiler spits out an ugly error. *edit*Actually I take back what I said before here if anyone read it. If you must have different implementations of operator== in each subclass, you can simply make it virtual. But it does still need to be defined in the base class and for such a simple operation you could probably just move the whole thing to the base class easily.

Also, this is just a stylistic issue, but you can simplify that implementation down to:
bool operator==(const string & lName)
{
return empLastName==lName;
}

Well, just to close out the post:

I got it working after making the operator into a friends funtion in the virtual parent class, Employee:

friend bool operator ==(Employee emp1, Employee emp2)

{
if (emp1.empNum == emp2.empNum)
return true;
else
return false;
}

In the main part of the program I create a temp object of derived class Engineer, set the empNumber and then do a simple comparison of the pointer array to the temp object:

case 6:
int tempNum;
bool found; int foundCount;
int j;

found=false;
system("cls");
cout << " Input the employee Number: ";
cin>>tempNum;
tmpEmpRec->setNum(tempNum);
j=0;
do
{
if(*tmpEmpRec == *(employee[j]))
{
found = true;
foundCount = j;
};
j++;
}while ((!found)&& j<empCount);

I would think making it a friend function would be unnecessary. Seems like a virtual member function might work. Alternatively, make an accessor function for the employee number (rather than accessing the variable directly). I would imagine:

class Employee
{
public:
virtual bool operator==(const Employee &rhs)
{
return rhs.empNum == empNum;
}
// everything else
};

I didn't try compiling/running this code, so it may have bugs (or be outright wrong)! But it seems like this would be the better way to do it. In general, using friend is rarely the right way to do things.