6

I'm about to create an exception class hierarchy which conceptually looks somewhat like this:

#include <iostream>
#include <stdexcept>

class ExceptionBase : public std::runtime_error {
public: 
    ExceptionBase( const char * msg ) : std::runtime_error(msg) {}
};

class OperationFailure : virtual public ExceptionBase {
public: 
    using ExceptionBase::ExceptionBase;
};

class FileDoesNotExistError : virtual public ExceptionBase {
public: 
    using ExceptionBase::ExceptionBase;
};

class OperationFailedBecauseFileDoesNotExistError
    : public OperationFailure, FileDoesNotExistError {
public: 
    using ExceptionBase::ExceptionBase; // does not compile
};

int main() {
    OperationFailedBecauseFileDoesNotExistError e("Hello world!\n");

    std::cout << e.what();
}

All constructors should look the same as the constructor of the ExceptionBase class. The derived exceptions only differ concerning their type, there's no added functionality otherwise. The last exception type mentioned in the above code should also have these constructors. Is this possible using the inheriting constructors feature of the C++11 standard? If that is not possible: what are alternatives?

(By the way: In the above code the classes OperationFailure and FileDoesNotExistError did not compile with gcc 4.8, but with clang 3.4. Apparently, gcc rejects inheriting constructors for virtual bases. It would be interesting to know who's right here. Both compilers rejected the class OperationFailedBecauseFileDoesNotExistError, because the inheriting constructor does not inherit from a direct base.)

Ralph Tandetzky
  • 22,780
  • 11
  • 73
  • 120
  • 3
    Diamond inheritance? Sweet. – littleadv Oct 16 '13 at 09:29
  • 1
    Fun begins in 3, 2, 1... – Adri C.S. Oct 16 '13 at 09:37
  • Maybe you need to use `using OperationFailure::OperationFailure`? But probably it wont work because of the double inheritance. – Albert Oct 16 '13 at 09:55
  • Even a recent g++4.9 doesn't compile `OperationFailure` when creating an object (with the parametrized ctor). When replacing the virtual inheritance with a non-virtual, it work. I suggest you file a bug report for gcc, as I cannot find anything in the Standard which prohibits this, and the latest proposal [N2540](http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2540.htm) explicitly allows it. – dyp Oct 16 '13 at 15:00
  • I will file a bug-report. – Ralph Tandetzky Oct 16 '13 at 16:37

2 Answers2

2

When the using-declaration is used to inherit constructors, it requires a direct base class [namespace.udecl]/3

If such a using-declaration names a constructor, the nested-name-specifier shall name a direct base class of the class being defined; otherwise it introduces the set of declarations found by member name lookup.

I.e. in your case, the using-declaration in OperationFailedBecauseFileDoesNotExistError doesn't inherit, but re-declares (as an alias), or unhides, the name of the ctor of ExceptionBase.

You'll have to write a non-inheriting ctor for OperationFailedBecauseFileDoesNotExistError.

By the way, this is fine for non-virtual base classes: The using-declaration for inheriting ctors is rewritten as:

//using ExceptionBase::ExceptionBase;

OperationFailure(char const * msg)
: ExceptionBase( static_cast<const char*&&>(msg) )
{}

As you may only initialize a direct base class (or virtual base class) in the mem-initializer-list, it makes sense for non-virtual base classes to restrict the using-declaration to inherit ctors only from direct base classes.

The authors of the inheriting ctors proposal have been aware that this breaks support for virtual base class ctors, see N2540:

Typically, inheriting constructor definitions for classes with virtual bases will be ill-formed, unless the virtual base supports default initialization, or the virtual base is a direct base, and named as the base forwarded-to. Likewise, all data members and other direct bases must support default initialization, or any attempt to use a inheriting constructor will be ill-formed. Note: ill-formed when used, not declared.

dyp
  • 38,334
  • 13
  • 112
  • 177
1

Inhering constructors is like introducing wrapper functions for all the constructors you have specified. In your case, you must call the specific constructors of both OperationFailure and FileDoesNotExistError but the introduced wrappers will only call either of them.

I just checked the latest C++11 draft (section 12.9) but it doesn't really explicitly cover your case.

Albert
  • 65,406
  • 61
  • 242
  • 386
  • The implicit declaration of default ctors is not inhibited by the *using-declaration*, therefore `OperationFailure` and `FileDoesNotExistError` still have default ctors. I'm not sure if they're well-formed however, as they don't initialize the virtual base class properly. – dyp Oct 16 '13 at 14:31
  • If this *using-declaration* in `OperationFailedBecauseFileDoesNotExistError` (let's call this class `O`) was legal, it would introduce a ctor equivalent to `O(char const* msg) : ExceptionBase( static_cast(msg) ) {}`. However, this ctor is ill-formed, as it calls the deleted default ctor of both direct base classes. The latter are ill-formed (deleted) as they don't initialize the virtual base class, see [class.ctor]/5. – dyp Oct 16 '13 at 14:45
  • (Also see [DR1567](http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1567)). – dyp Oct 16 '13 at 14:57