Template Argument Constant Evaluation

1. Why can't the compiler evaluate 'i' at compile time?

Compile-time evaluation requires that the value of 'i' be known before the program executes. However, in the provided code, 'i' is a loop variable that changes during program execution. The compiler cannot determine the value of 'i' at compile time because it is a dynamically assigned value.

2. Can I achieve the objective without modifying the API interface?

Yes, you can use template specialization to create a recursive function that iterates through the range of template arguments. For example, you could create a function:

template
void modify_recursive() {
    // Call modify with template argument 'i'
    modify();
    
    // Recursively call modify_recursive with the next template argument
    if (i ();
    }
}

Calling 'modify' with a Non-Constant Argument

To call 'modify' with a value that is not a compile-time constant, you can use a technique called template meta-programming. One approach is to create a template class that takes a function object as an argument and invokes it with the desired value:

template
struct InvokeWithParam {
    InvokeWithParam(F f, int param) : f(f), param(param) {}
    
    void operator()() { f(param); }
    
    F f;
    int param;
};

You can then pass an instance of InvokeWithParam as the template argument to modify:

int var = 5;
modify();

This will invoke the modify function with the value of var.