Inheritance: Conflict resolution

[IWishIKnew]

So, say an object has onperator++

what if I want an object that inherits that operator to do somthing on top of what it already does.

example:

class A
{
public:
    //constructors.....

    A operator++(const int& i)
    {
        a++;
        return *this;
    }
    int a;
}

class B : public A
{
public:

    //constructors.....

    B operator++(const int& i)
    {
        /* What happens??  Is there a proper way to write code to avoid this?? */
        return *this;
    }

    int b;
}

The operator I am overloading is a bitshift operator for istream and ostream. It allows the user to save the object in a file nice and neat. I am writing a sub-class of this class that has a few additional functionalities on top of the class it inherits from. It will save data from the oject it inherits from, on top of additional data it uses.

[LB]

Don't make up examples that demonstrate an entirely different problem than the one you're having.

IWishIKnew wrote:

The operator I am overloading is a bitshift operator for istream and ostream. It allows the user to save the object in a file nice and neat. I am writing a sub-class of this class that has a few additional functionalities on top of the class it inherits from. It will save data from the oject it inherits from, on top of additional data it uses.

You need a virtual serialize member function which operator<< calls.

[IWishIKnew]

hmm?

Are there different circumstances for... these calls??

Also, I'm having trouble finding a clear reference for serialized virtual member function...

I found out that I could over-ride an inherited function by virtualizing it, but that requires I re-write that function (or call it, or make it static or somthing) every time I want to use that function, just with a few additional steps.

[LB]

struct Base
{
    virtual void Serialize(std::ostream &os) const
    {
        os << "Base";
    }
};

struct Derived : Base
{
    virtual void Serialize(std::ostream &os) const override
    {
        os << "Derived, ";
        Base::Serialize(os);
    }
};

//...

std::ostream &operator<<(std::ostream &os, Base const &b)
{
    b.Serialize(os);
    return os;
}

//...

int main()
{
    Base b;
    Derived d;
    Base &bd = d;
    std::cout << b << std::endl;
    std::cout << d << std::endl;
    std::cout << bd << std::endl;
}

http://ideone.com/2k09GY

[IWishIKnew]

It seems like the only difference between the two is that one calls an inherited function through it's scope, and that you're using functions instead of operators.

[LB]

No, operator<< with std::ostream as its left parameter and and instance of your class as its right parameter must be a global operator, so even if it is in class scope it must be a friend function - it cannot be inherited and does not belong to the class.

[IWishIKnew]

alrighty.