Question

I’m trying to create some overloaded arithmetic operators which use inherited classes like this:

class Block {
    public:
        Block() {}
        virtual double Value() {};
};

class Constant : public Block {
    public:     
        Constant(double v) { value = v; }
        virtual double Value() { return value; }
    private:
        double value;       
};

class Add : public Block {
    public:
        Add(Block &a, Block &b) { value1 = &a; value2 = &b; }
        virtual double Value() { return value1->Value() + value2->Value(); }
    private:
        Block *value1;
        Block *value2;          
};

Block operator + (Block &a, Block &b) {
    return new Add(a, b);
}

int main() {
    Constant a(5.0);
    Constant b(6.0);
    printf("%.3f", (a+b).Value());
}

But I get following: error: conversion from 'Add*' to non-scalar type 'Block' requested

This is my first experience with OOP in C++ so is my idea even possible?

Answer 1

As a general rule, operator overloading and inheritance don’t
work well together, since in C++, operators generally have value
semantics. There is one major exception, however, and if all of
the instances of your Add class are in fact the return value
of your operator+ (temporaries), then you’ve effectively
implemented compile time expression evaluation—a very
important optimization technique. (In modern C++, this is
usually done using templates, rather than inheritance, but the
principle is the same.)

Because operators have value semantics, they should return
values, not pointers. This means no new. Another reason not
to use new is that anything that is newed must be explicitly
deleted, and in most cases, there’s no way to explicitly delete
a pointer returned as part of an expression. And such a pointer
must be dereferenced as well.

EDIT:

I seem to have forgotten an important point: the declared return value of the operator must be the actual type you are returning, since your return expression will be copied into this type. Thus:

Add
operator+( Block const& lhs, Block const& rhs )
{
    return Add( lhs, rhs );
}

Note too the const. Without it, you cannot use the operator
on temporaries; e.g. a + b + c would be illegal (supposing
a, b and c are of type Block, or of some type derived
from it).