初学C++模板编程：如何显式指定函数模板的第二个参数类型？

Great question! When working with function templates, C++ matches explicit template arguments in the exact order they’re declared—so by default, you can’t skip the first parameter to explicitly set the second. But there are two straightforward solutions to get the behavior you want:

1. Reorder the Template Parameters #

The simplest fix is to swap the order of your template parameters, putting the one you want to explicitly specify first. Then you can provide that explicit type, and let the compiler deduce the second (now first in the template list) from the function arguments.

Here’s how that looks with your code:

#include <iostream>
using namespace std;

// Swap U and T in the template parameter list
template<typename U, typename T> 
void add(T x, U y) { 
    cout << x + y << endl; 
}

int main() {
    // Explicitly specify U=double, compiler deduces T=int from the first argument
    add<double>(1, 2.0); 
    return 0;
}

This works because the first explicit template argument (double) maps to U, and the compiler automatically deduces T as int from the value 1.

2. Use a Class Template Wrapper (C++17+) #

If you don’t want to reorder the template parameters, you can wrap the function logic in a class template where the parameter you want to specify is a class-level template parameter, and the deduced parameter is a function-level template parameter. This leverages C++17’s class template deduction for clean calls.

Example implementation:

#include <iostream>
using namespace std;

template<typename U>
struct Add {
    // T is deduced from the first function argument
    template<typename T>
    void operator()(T x, U y) {
        cout << x + y << endl;
    }
};

int main() {
    // Explicitly specify U=double, T is deduced as int
    Add<double>{}(1, 2.0);
    return 0;
}

Here, we explicitly set the class template parameter U to double, then the operator() deduces T from the first argument 1.

Why the Original Approach Can’t Skip Parameters #

Just to clarify: C++ doesn’t allow "skipping" leading template parameters when providing explicit arguments (e.g., add<, double>(1, 2.0) is invalid syntax). The compiler expects explicit arguments to fill in template parameters from left to right, unless a parameter has a default value—but default values don’t help here since we need T to be deduced from the function argument.

内容的提问来源于stack exchange，提问作者tesla1060