Konvt's questions

Em C++, eu marco uma função como noexceptnos seguintes casos:

A função em si não gera exceções, mas seus parâmetros de tipo de valor podem gerar exceções durante a construção.

O código a seguir demonstra essa situação:

struct A {
    A(bool will_throw) {
        std::cerr << "Ctor of A\n";
        if (will_throw) throw std::runtime_error("An exception from A");
    }
    A(A&& lhs) noexcept {
        std::cerr << "Move ctor of A\n";
    }
    ~A() noexcept = default;
};

struct B {
    A mem_;

    // Exceptions are thrown during parameter passing, not inside the function
    // Thus it isn't an UB I think.
    B(A value = A(true)) noexcept : mem_{std::move(value)} {/* do nothing */}
    ~B() noexcept = default;
};

Neste código, o construtor de Bé marcado como noexcept, e o A(true)construtor padrão pode lançar uma exceção, mas acredito que isso não leva a um comportamento indefinido, pois a exceção ocorre durante a passagem de parâmetros e não dentro do corpo da função.

O programa de teste está aqui .

Minha pergunta é:

Em casos semelhantes, é seguro marcar o construtor e outras funções com noexcept? Essa prática pode ser aplicada amplamente, especialmente em casos em que a função em si não lança nenhuma exceção?

Na biblioteca padrão, o tipo de parâmetro do construtor da classe de exceção, como std::runtime_error, segue este padrão:

runtime_error( const std::string& what_arg ); // (1)
runtime_error( const char* what_arg );        // (2)
runtime_error( const runtime_error& other );  // (3)

O que me confundiu é que (1) foi usado const std::string&em vez de std::string, o que obviamente resulta em uma operação de cópia adicional dentro do construtor.

Se o tipo de parâmetro fosse std::string, não apenas evitaria uma operação de cópia extra, mas também seria noexcept; o que é uma conclusão que percebi recentemente:

Se uma função marcada como noexcepttiver um parâmetro de um tipo que pode gerar uma exceção durante sua construção, mesmo que seja garantido que a exceção será gerada, ela não fará com que o programa seja encerrado devido a uma exceção.

Isto é confirmado pelo programa de teste .

Então, por que a lista de parâmetros do construtor de exceção da biblioteca padrão não usa std::string? Ou meu entendimento e conclusão, assim como o programa de teste, estão incorretos, mesmo que seja um comportamento indefinido?

Escrevi o seguinte código para usar string em tempo de compilação:

template<char... Chars>
struct CnstString {
    template<char... Aped>
    using push_back = CnstString<Chars..., Aped...>;
    constexpr static char value[] = {Chars...};
};

Tudo bem quando eu uso assim:

#include <iostream>
using str = CnstString<'H', 'e', 'l', 'l', 'o', '\0'>;
int main()
{
    std::cout << str << std::endl;
    return 0; // it will output "Hello"
}

O que eu quero fazer é usar uma estrutura de modelo recursiva, unir uma string fornecida pelo código acima em tempo de compilação e anexar a à '\0'matriz no ponto final recursivo.

A razão pela qual escrevi este código é porque quero concatenar a mesma string várias vezes. Obviamente não posso concatenar a mesma string como "Hello""Hello".

A estrutura do modelo recursivo é mostrada abaixo:

template<int N, typename Str>
struct RepeatStr {
    using ret = RepeatStr<N-1, Str>; // this is an error, I don't know how to pass parameters
};
template<typename Str>
struct RepeatStr<-1, Str> {
    using ret = Str:: template push_back<'\0'>;
};

No entanto, descobri que não sabia como acrescentar caracteres a si mesmo usando seus caracteres em Str.

Há algo de errado? Ou é simplesmente impossível fazer em tempo de compilação?