O padrão de código a seguir é razoável ao usar traços no código de modelo em que ambas as implementações alternativas são sempre compiláveis?

Ler o código parece mais claro do que fazer outras travessuras para compilar condicionalmente (mas talvez eu não esteja familiarizado o suficiente com essas travessuras).

template<typename T>
class X
{
    void do_something() noexcept(std::is_nothrow_copy_constructible<T>::value)
    {
        if (std::is_nothrow_copy_constructible<T>::value)
        {
            // some short code that assumes T's copy constructor won't throw
        }
        else
        {
            // some longer code with try/catch blocks and more complexity
        }
    }

    // many other methods
};

(A complexidade adicionada é em parte para fornecer a forte garantia de exceção.)

Eu sei que esse código vaitrabalhos, mas é razoável esperar que o compilador elimine as ramificações constantes e falsas e faça inlining etc. para o caso noexcept (onde muito mais simples que o outro caso)? Espero algo que seja tão eficiente no caso de exceção, como escrever o método apenas com o primeiro bloco como corpo (e vice-versa, embora eu esteja menos preocupado com o caso complexo).

Se esse não é o caminho certo, alguém pode me esclarecer a sintaxe recomendada?