Is this a legal way to implement impure virtual functions?

Question

By an "impure virtual function", I mean pure virtual functions that also have implementations (as described at http://www.gotw.ca/gotw/031.htm) for diagnostic purposes.

The kosher way to implement them is to do:

class Foo
{
public:
    ...
    virtual void Bar() = 0;
};

void Foo::Bar() { assert(false); }

But this is kind of tedious, especially for a class has a number of pure virtual methods. Also, it's hard to ensure that someone doesn't accidentally add a new pure virtual function without also adding a corresponding implementation.

Ideally what I'd like to do is:

class Foo
{
public:
    ...
    virtual void Bar() = 0
    {
        assert(false);
    }
};

but the C++ standard explicitly disallows this (section 10.4/2 in the ISO C++ 2003 standard).

As an alternative, I've thought of the following hack. In the Foo.h header:

#ifndef ABSTRACT_METHOD
#define ABSTRACT_METHOD = 0
#endif

class Foo
{
public:
    ...
    virtual void Bar() ABSTRACT_METHOD;
};

and then in the corresponding Foo.cpp source file:

#define ABSTRACT_METHOD { assert(false); }

#include "Foo.h"

...

so that it gets a single compiled implementation.

Would doing so be legal?

Answer 1

No, it's not legal. The one definition rule says that a class can have multiple definitions in a program (from different translation units), but those definitions must all consist of identical sequences of tokens (3.2/5). ABSTRACT_METHOD is a preprocessing token (prior to macro replacement), but that's not good enough.

So your .cpp file can't validly be used in the same program as another .cpp that includes the header.

Answer 2

I can't answer whether it's valid or not. But if the user of your class declares a derived class in the source file, the compiler won't enforce that Bar() must be implemented in that derived class (because it won't see the = 0). I would imagine that this alone would be a reason not to do it like this.