相关疑难解决方法(0)

#include <vector>

using namespace std;

template<typename T, typename = decltype(&T::size)>
void f1(T)
{}

template<typename T, typename = decltype(&T::size)>
void f2(T&)
{}

template<typename T, typename = decltype(&T::size)>
void f3(T&&)
{}

int main()
{
    vector<int> coll;

    f1(coll); // ok
    f2(coll); // ok
    f3(coll); // error : no matching function for call to 'f3'
}

main.cpp(21,6):注意:候选模板被忽略:替换失败[with T=> std::vector<int, std::allocator<int> > &]:类型' std::vector<int, std::allocator<int> > &'在' ::' 之前不能使用,因为它没有成员

void f3(T&&)

我的编译器是clang 4.0.

令我惊讶的是,f3(coll)失败了,f1(coll)而且f2(coll)都很好.

为什么转发引用在这种情况下不起作用？

我不明白为什么数组衰减到模板函数中的指针.

如果您查看以下代码:当参数被强制为参考(函数f1)时,它不会衰减.在另一个函数中,它衰减了.为什么函数f中的T类型不是const char(buff&)[3]而是const char*(如果我理解正确的话)？

#include <iostream>

template <class T>
void f(T buff) {
    std::cout << "f:buff size:" << sizeof(buff) << std::endl;       //prints 4
}

template <class T>
void f1(T& buff) {
    std::cout << "f:buff size:" << sizeof(buff) << std::endl;       //prints 3
}

int main(int argc, char *argv[]) {
    const char buff[3] = {0,0,0};
    std::cout << "buff size:" << sizeof(buff) << std::endl;         //prints 3
    f(buff);
    f1(buff);
    return 0;
}

假设我们有一些模板化的结构,有时它的模板应该是一个数组.如何在struct中初始化数组？

这个

template<typename T>
struct A {
    T x;
    A(T x) : x(x) {}
};


int a[6];
A<decltype(a)> b(a);

编译期间生成错误:

error: array initializer must be an initializer list
A(T x) : x(x) {}
         ^

UPD1.更完整的代码这个东西用于:

template<typename T>
struct A {
    T x;
    A(const T& x) : x(x) {}
    A(const T&& x) : x(std::move(x)) {}
};

template<typename T>
A<typename std::remove_reference<T>::type> make_A(T&& a) {
    return A<typename std::remove_reference<T>::type>(std::forward<T>(a));
}


auto a = make_A("abacaba");

在以下代码中，使用的好处是&&什么？该代码来自Specialize相同运算符的不同特征的答案

从这个问题，我得到一个&&参数意味着它是一个可以被函数修改的引用。

的decay_t可能阻止编译器解释为阵列的变量的引用，如在什么是标准::衰变和时，应使用什么？

std::forward是完美的描述转发在这里。为什么我们需要这种转发？

谢谢。

#include <iostream>
#include <type_traits>
#include<utility>

class A;

template <typename T>
struct is_A : std::false_type {};
template <> struct is_A<A> : std::true_type {};

template <typename T>
struct is_int : std::false_type {};
template <> struct is_int<int> : std::true_type {};
template <> struct is_int<long> : std::true_type {};

class A{
public:
    int val;

    void print(void){
        std::cout << val << std::endl;
    }

    template <typename T1>
    std::enable_if_t<is_int<std::decay_t<T1>>::value, …