User-defined empty constructors in custom exception with multiple inheritance and abstract base class

Question

I designed several custom exceptions which all inherit from the same abstract base class custom::exception and from the corresponding standard exception thanks to multiple inheritance. Thus there is a specific hierarchy in my custom exceptions and I can catch them generically or specifically.

Now I switched on all warnings without any problem with GCC but clang complains about the virtual destructor :

#include <iostream>
#include <stdexcept>

namespace custom {
    struct exception;
    struct buffer_overflow;
    struct null_pointer;
    struct out_of_range;
    //...
}

struct custom::exception {
    virtual ~exception() noexcept {}
    virtual const char* what() const noexcept = 0;
};

struct custom::null_pointer : public custom::exception, public std::logic_error {
    null_pointer(const std::string &str): std::logic_error(str) {}
    const char* what() const noexcept override { return std::logic_error::what(); }
};

int main(){
    try{
        throw custom::null_pointer("[ERROR] NULL pointer exception !");
    }
    catch(const custom::exception &error){
        std::cout << error.what() << std::endl;
    }
}

Output with g++ (MinGW.org GCC-8.2.0-3) :

[ERROR] NULL pointer exception !

Output with clang++ version 6.0.0-1ubuntu2 :

test.cpp:13:13: warning: definition of implicit copy constructor for 'exception' is deprecated because it has a
      user-declared destructor [-Wdeprecated]
    virtual ~exception() noexcept {}
            ^
test.cpp:17:16: note: in implicit copy constructor for 'custom::exception' first required here
struct custom::null_pointer : public custom::exception, public std::logic_error {
               ^
test.cpp:24:15: note: in implicit move constructor for 'custom::null_pointer' first required here
        throw custom::null_pointer("[ERROR] NULL pointer exception !");
              ^
1 warning generated.
[ERROR] NULL pointer exception !

I do not really understand because custom::exception is abstract and does not contain any member variable so it does not need user-defined constructors. But if I define those, clang does not complain :

struct custom::exception {
    exception() noexcept {}
    exception(const exception&) noexcept {}
    virtual ~exception() noexcept {}
    virtual const char* what() const noexcept = 0;
};

My questions are :

Which compiler is correct ?
Why do I have to define empty default & copy constructors such as above ?

Thank you.

Related questions :

Why don't you let `custom::exception` derive from `std::exception`? — L. F., Oct 08 '19 at 10:59
@Superlokkus not a duplicate because this question concerns derived class not the base class. — Baptistou, Oct 08 '19 at 11:20
@L.F. ```custom::exception``` cannot derive from ```std::exception``` because of diamond inheritance problem. — Baptistou, Oct 08 '19 at 11:22
@Baptistou Not relevant, since the problems still is, that implicit defined constructors may be deprecated, even if no polymorphism was used after all. In your case, runtime polymorphism using virtual is just a different reason to user decalre the destructor. But ANY user declared destructor would cause the problem. — Superlokkus, Oct 08 '19 at 11:54

Superlokkus · Accepted Answer · 2019-10-08T11:51:25.037

You came across the same issue Warning: definition of implicit copy constructor is deprecated had encountered:

In the C++ standard D.2 Implicit declaration of copy functions [depr.impldec] the draft for C++17 N4659 states:

The implicit definition of a copy constructor as defaulted is deprecated if the class has a user-declared copy assignment operator or a user-declared destructor. The implicit definition of a copy assignment operator as defaulted is deprecated if the class has a user-declared copy constructor or a user-declared destructor (15.4, 15.8). In a future revision of this International Standard, these implicit definitions could become deleted (11.4).

This gives the answer to

1.: Both compilers are correct, clang actually warns you about the deprecation, gcc does not which is also okay.

This is ok because D(0) make a warning about it optional, also even the [[deprecated]] attribute, which also is not mandatory to issue a warning:

An implementation may declare library names and entities described in this section with the deprecated attribute

2. To force you to think about the so called Rule of Three: The rule of three states that since you need to define a constructor you probably you need a complex copy and or move constructor. By forcing you to explicit defining them, even with default, it acts as a insurance, the class author has thought about slicing and other problems. However since the implicit or defaulted copy constructor just copies your bases and elements, you should be fine.

You can default, which basically does the same as the implict defined things, but you want a virtual destructor, which is otherwise the same:

exception() noexcept = default;
exception(const exception&) noexcept = default;
virtual ~exception() noexcept = default;

I disagree with (2) because if I do a copy of ```custom::null_pointer``` it does not lose its diagnostic string. Moreover, declaring the destructor as defaulted still trigger the warning. — Baptistou, Oct 08 '19 at 11:42
Yeah I meanwhile read the standard in that regard, updated the answer — Superlokkus, Oct 08 '19 at 11:51

User-defined empty constructors in custom exception with multiple inheritance and abstract base class

1 Answers1