Por que uma variável não constante não pode ser passada como um argumento de modelo?

Em C , os argumentos de modelo devem ser expressões constantes. Isso significa que seus valores devem ser conhecidos em tempo de compilação. O compilador não pode avaliar uma variável não constante neste contexto.

Considere o código:

template 
void modify(){}

Para passar uma variável não constante como argumento do modelo, podemos escrever:

for(int i = 0; i ();
}

No entanto, isso aciona um erro porque o compilador não pode determinar o valor de i em tempo de compilação. O corpo do loop pode ser executado várias vezes, alterando o valor de i.

Atingindo o objetivo sem modificar a API

Em vez de passar uma variável não constante diretamente, podemos usar a especialização de modelo para implementar uma chamada iterativa:

#include 

template
void modify() { std::cout " 
void modify() { std::cout " 
void modify() {
    std::cout " ();
}

int main() {
    modify();
}

Chamando Modify com um valor dinâmico

Para chamar Modify com um valor que não é conhecido em tempo de compilação, podemos usar uma técnica chamada metaprogramação de modelo. Aqui está um exemplo simplificado:

#include 

template <:tuple>>
struct TupleSize;

template 
struct TupleSize<:tuple>> {
    static const int value = sizeof...(Args);
};

template 
void callModify(int i) {
    if constexpr (i ();
        callModify(i 1);
    }
}

int main() {
    int n = 10;
    callModify::value>(0);
}

Neste exemplo, callModify usa um parâmetro N que é o tamanho de uma tupla que contém o intervalo de valores desejado para i. A função usa um metaprograma recursivo para gerar as chamadas para modificar até o tamanho especificado N.