Question

class A{
  public: 
    virtual char &operator[](int);
  protected:
    ..
};
class B:A{
  public:
    A* &operator[](int);
  protected:
}

Can I change the return type when I overload an overload of an operator?

thanks!

//EDIT
Okay, so now that we established that this wont work how can I build a work around?

Lets say I have classes A,B,C, and D.

class A{
  public: 
  private:
    char &operator[](int);
  protected:
    ..
};
class B:A{
  public: 
    virtual char &operator[](int);
};
class C: A{
  public:
  private:
    A::&operator[](int);
}
class D: A{
  public:
  private:
     A::&operator[](int);
}

Can I do something like this? If so is this the correct syntax?

Answer 1

The reason that a polymorphic function can’t return different types in different classes isn’t because someone on the C++ committee decided that it was “taboo”, but because any code that used that function’s return value couldn’t compile.

By creating an inheritance heirarchy, you’re able to access derived objects through a base pointer or reference:

class A
{
public:
    virtual char operator[](int);
};
class B : public A
{
public:
    virtual char operator[](int);
};

A *a;

std::cout << "Do you want to make an A or a B?";

char type;
std::cin >> type;

if (type == 'A')
    a = new A();
else
    a = new B();

char c = (*a)[0];

Note that on the last line, the compiler won’t know what type of object a is pointing to, since that’s determined at runtime. This is fine, because no matter what type of object a is pointing to, operator[] is still going to return a character. But what if that operator were allowed to return a different type in class B?

class Sequence
{
    ...
};

class A
{
public:
    virtual char operator[](int);
};
class B : public A
{
public:
    virtual Sequence operator[](int);
};

A *a = new B();
char c = (*a)[0];

Obviously, that last line makes no sense when a is an object of type B. In that case, you’re trying to assign a Sequence to a character. Likewise, Sequence c = (*a)[0]; wouldn’t make sense if a were an object of type A.