Parâmetros de modelo sem tipo

Eu entendo que o parâmetro de modelo sem tipo deve ser uma expressão integral constante. Alguém pode esclarecer o porquê disso?

template <std::string temp>
void foo()
{
     // ...
}

error C2993: 'std::string' : illegal type for non-type template parameter 'temp'.

Eu entendo o que é uma expressão integral constante. Quais são as razões para não permitir tipos não constantes std::stringcomo no trecho acima?

A razão pela qual você não pode fazer isso é porque expressões não constantes não podem ser analisadas e substituídas durante o tempo de compilação. Eles poderiam mudar durante o tempo de execução, o que exigiria a geração de um novo modelo durante o tempo de execução, o que não é possível porque os modelos são um conceito de tempo de compilação.

Aqui está o que o padrão permite para parâmetros de modelo sem tipo (14.1 [temp.param] p4):

Um parâmetro de modelo não-tipo deve ter um dos seguintes tipos (opcionalmente qualificado de cv):

• tipo integral ou enumeração,
• ponteiro para objeto ou ponteiro para função,
• referência de lvalue para objeto ou referência de lvalue para função,
• ponteiro para membro,
• std::nullptr_t.

Isso não é permitido.

No entanto, isso é permitido:

template <std::string * temp> //pointer to object
void f();

template <std::string & temp> //reference to object
void g();

Consulte §14.1 / 6,7,8 em C ++ Standard (2003).

Ilustração:

template <std::string * temp> //pointer to object
void f()
{
   cout << *temp << endl;
}

template <std::string & temp> //reference to object
void g()
{
     cout << temp << endl;
     temp += "...appended some string";
}

std::string s; //must not be local as it must have external linkage!

int main() {
        s = "can assign values locally";
        f<&s>();
        g<s>();
        cout << s << endl;
        return 0;
}

Resultado:

can assign values locally
can assign values locally
can assign values locally...appended some string

Você precisa ser capaz de destruir os argumentos do modelo

template <std::string temp>
void f() {
 // ...
}

f<"foo">();
f<"bar">(); // different function!?

Agora, um implante precisaria criar uma sequência única de caracteres para um std::string ou, nesse caso, qualquer outra classe arbitrária definida pelo usuário, armazenando um valor particular, cujo significado não é conhecido pela implementação. Além disso, o valor de objetos de classe arbitrários não pode ser calculado em tempo de compilação.

É planejado permitir tipos de classe literais como tipos de parâmetro de modelo para pós-C ++ 0x, que são inicializados por expressões constantes. Esses poderiam ser mutilados por ter os membros de dados mutilados recursivamente de acordo com seus valores (para classes básicas, por exemplo, podemos aplicar profundidade primeiro, passagem da esquerda para a direita). Mas definitivamente não vai funcionar para classes arbitrárias.

Um argumento de modelo sem tipo fornecido em uma lista de argumentos de modelo é uma expressão cujo valor pode ser determinado em tempo de compilação. Esses argumentos devem ser:

expressões constantes, endereços de funções ou objetos com ligação externa ou endereços de membros de classe estáticos.

Além disso, literais de string são objetos com ligação interna, portanto, você não pode usá-los como argumentos de modelo. Você também não pode usar um ponteiro global. Literais de ponto flutuante não são permitidos, dada a possibilidade óbvia de erros de arredondamento.