标签: function-templates

我听说C++类成员函数模板不能是虚拟的.这是真的？

如果它们可以是虚拟的,那么一个人可以使用这样一个函数的场景的例子是什么？

我知道语言规范禁止功能模板的部分特化.

我想知道为什么禁止它的理由？它们没用吗？

template<typename T, typename U> void f() {}   //allowed!
template<> void f<int, char>()            {}   //allowed!
template<typename T> void f<char, T>()    {}   //not allowed!
template<typename T> void f<T, int>()     {}   //not allowed!

template<typename T>
void f(T a, const T& b)
{
    ++a; // ok
    ++b; // also ok!
}

template<typename T>
void g(T n)
{
    f<T>(n, n);
}

int main()
{
    int n{};
    g<int&>(n);
}

请注意:b是的const T&,++b没关系!

为什么const T&不确定是const？

考虑

#include <iostream>
#include <type_traits>

template <class T, class ARG_T = T&>
T foo(ARG_T v){
    return std::is_reference<decltype(v)>::value;
}

int main() {
    int a = 1;
    std::cout << foo<int>(a) << '\n';
    std::cout << foo<int, int&>(a) << '\n';
}

我希望两种情况下的输出均为1。但在第一种情况下为0：与默认值class ARG_T = T而不是一致class ARG_T = T&。

我想念什么？

#include <iostream>

struct uct
{
    uct() { std::cerr << "default" << std::endl; }

    uct(const uct &) { std::cerr << "copy" << std::endl; }
    uct(      uct&&) { std::cerr << "move" << std::endl; }

    uct(const int  &) { std::cerr << "int" << std::endl; }
    uct(      int &&) { std::cerr << "int" << std::endl; }

    template <typename T>
    uct(T &&) { std::cerr << "template" << std::endl; }
};

int main()
{
    uct u1    ; // default
    uct u2( 5); // int
    uct u3(u1); …

在下面的示例中，0它以一种特殊的方式运行：它选择与示例函数调用所期望的不同的重载。我想知道为什么。我的理解也如下。

#include <iostream>

template<typename T>
void f(T a) {
    std::cout << "first" << std::endl;
}

template<typename T>
void f(T* a) {
    std::cout << "second" << std::endl;
}

int main()
{
    f(0);
    f<size_t>(0);
    f<size_t>(0UL);
    
    f(1);
    f<size_t>(1);
}

输出：

first
second
first
first
first

我的理解：

f(0)- 模板参数推导，整数文字0是int类型，因此f选择第一个T=int

f<size_t>(0)-带有整数提升的显式模板实例化，选择的类型是T=size_t，选择第一个函数并从到提升0（我在这里错了）intsize_t