Eu tenho o problema de misturar exceções e herança múltipla. Basicamente eu tenho esse código:

#include <exception>
#include <stdexcept>
#include <iostream>

class A : public std::exception
{
public:
    virtual ~A() noexcept {};
};

class B : public A, public std::runtime_error
{
public:
    B() : A{}, std::runtime_error{""}
    {

    }
};

int main()
{
    try {
        throw B{};
    } catch (const std::exception& error) {
        // this catch doesn't work
        std::clog << "Caught!" << std::endl;
    }
}

O que eu preciso é modificá-lo para que a exceção da classe B possa ser capturada como std :: exception (por enquanto o manipulador terminate é chamado). Como posso conseguir esse comportamento? Eu acho que a herança virtual é necessária, mas não vejo nenhuma maneira de usá-lo neste caso.

ATUALIZAÇÃO: Eu preciso ser capaz de:
- pegar A como A (trivial),
- pegar A como std :: exception,
- pegar B como B (novamente, trivial),
- pegar B como std :: exception,
- pegar B como std :: runtime_error

Eu sei que isso é um monte de requisitos, e talvez não faça muito sentido, mas eu preciso disso e estou apenas curioso :)

UPDATE2: Eu acho que o problema é std :: runtime_error não estar virtualmente vindo de std :: exception (o que me permitiria resolver problema por herança virtual em A). Estou certo? Ainda assim, isso pode ser resolvido?

UPDATE3: Alan Stokes sugeriu uma solução nos comentários abaixo, o que parece funcionar para mim:

Você pode dividir A em duas classes - uma que implementa a funcionalidade B e uma que adiciona a herança de std :: exception? Então ambos A e B poderiam herdar (digamos) de A_base.

Obrigado por isso, ainda se alguém tiver outras boas soluções, por favor me avise.