C++模板基础（九）

完美转发与 lambda 表达式模板

void f(int& input)
{std::cout << "void f(int& input)\t" << input << '\n';
}void f(int&& input)
{std::cout << "void f(int&& input)\t" << input << '\n';
}int main(int argc, char *argv[])
{QCoreApplication a(argc, argv);int x = 3;f(x); //int&f(5); //int&&return a.exec();
}

void f(int& input)
{std::cout << "void f(int& input)\t" << input << "\n\n";
}void f(int&& input)
{std::cout << "void f(int&& input)\t" << input << "\n\n";
}template<typename T>
void fun(T input)
//void fun(T& input) //无法将int x = 3;从int转换为int&
//void fun(T&& input) //&&是万能引用，右值引用的变量是左值。输出同void fun(T input)
{std::cout << "template<typename T> void fun(T input)\n";f(input);
}int main(int argc, char *argv[])
{QCoreApplication a(argc, argv);int x = 3;fun(x); //int&fun(5); //参数是int&&类型，但是调用了void f(int& input)return a.exec();
}

● (C++11) 完美转发： std::forward 函数
– 通常与万能引用结合使用
– 同时处理传入参数是左值或右值的情形

#include<utility>void f(int& input)
{std::cout << "void f(int& input)\t" << input << "\n\n";
}void f(int&& input)
{std::cout << "void f(int&& input)\t" << input << "\n\n";
}template<typename T>
void fun(T&& input)
{std::cout << "template<typename T> void fun(T input)\n";f(std::forward<T>(input)); //完美转发
}
int main(int argc, char *argv[])
{QCoreApplication a(argc, argv);int x = 3;fun(x); //int&,调用void f(int& input)fun(5); //int&&,调用void f(int&& input)return a.exec();
}

void f(int& input)
{std::cout << "void f(int& input)\t" << input << "\n\n";
}void f(int&& input)
{std::cout << "void f(int&& input)\t" << input << "\n\n";
}template<typename T>
void fun(T input)
{std::cout << "template<typename T> void fun(T input)\n";f(std::forward<T>(input)); //完美转发不能处理的情形
}
int main(int argc, char *argv[])
{QCoreApplication a(argc, argv);int x = 3;fun(x); //int&,调用void f(int&& input)fun(5); //int&&,调用void f(int&& input)return a.exec();
}

void f(int& input)
{std::cout << "void f(int& input)\t" << input << "\n\n";
}void f(int&& input)
{std::cout << "void f(int&& input)\t" << input << "\n\n";
}template<typename... T>
void fun(T... inputs)
{std::cout << "template<typename... T> void fun(T... inputs)\n";f(std::forward<T>(inputs)...); //包展开技术
}
int main(int argc, char *argv[])
{QCoreApplication a(argc, argv);int x = 3;fun(x); //int&,调用void f(int&& input)fun(5); //int&&,调用void f(int&& input)return a.exec();
}

void f(int& input)
{std::cout << "void f(int& input)\t" << input << "\n\n";
}void f(int&& input)
{std::cout << "void f(int&& input)\t" << input << "\n\n";
}template<typename... T>
void fun(T&&... inputs) //万能引用参数包
{std::cout << "template<typename... T> void fun(T... inputs)\n";f(std::forward<T>(inputs)...); //包展开技术
}
int main(int argc, char *argv[])
{QCoreApplication a(argc, argv);int x = 3;fun(x); //int&,调用void f(int& input)fun(5); //int&&,调用void f(int&& input)return a.exec();
}

● (C++20) lambda表达式模板

消除歧义与变量模板

struct Str
{const static int internal = 3;
};int p = 5;template<typename T>
void fun()
{//internal是T中的一个具体数据，乘以变量pstd::cout << T::internal*p << '\n';
}int main(int argc, char *argv[])
{QCoreApplication a(argc, argv);fun<Str>();return a.exec();
}

● 使用 typename 与 template 消除歧义
– 使用 typename 表示一个依赖名称是类型而非静态数据成员

struct Str
{using internal = int;
};template<typename T>
void fun()
{//internal是T中的一个数据类型，p是该类型的一个指针int x = 5;typename T::internal* p = &x; //加上typename表示internal是T中的一个数据类型，消除了歧义Str::internal* ptr = &x; //加上限定名Str消除歧义std::cout << p << '\n' << ptr << '\n';
}
int main(int argc, char *argv[])
{QCoreApplication a(argc, argv);fun<Str>();return a.exec();
}

– 使用 template 表示一个依赖名称是模板
– template 与成员函数模板调用

struct Str
{template<typename T>static void internal(){std::cout << "Str::template<typename T> static void internal()\n";}
};template<typename T>
void fun()
{//T::internal<int>(); //编译器可能认为<是小于运算符。Warning: Use 'template' keyword to treat 'internal' as a dependent template nameT::template internal<int>(); //OK，使用了template消除了歧义
}
int main(int argc, char *argv[])
{QCoreApplication a(argc, argv);fun<Str>();return a.exec();
}

struct Str
{template<typename T>void internal() //非static函数{std::cout << "Str::template<typename T> static void internal()\n";}
};template<typename T>
void fun()
{T obj;//obj.internal<int>(); //编译器可能认为<是小于运算符。Warning: Use 'template' keyword to treat 'internal' as a dependent template nameobj.template internal<int>();  //OK，使用了template消除了歧义
}
int main(int argc, char *argv[])
{QCoreApplication a(argc, argv);fun<Str>(); //输出同上return a.exec();
}

● (C++14) 变量模板
– template T pi = (T)3.1415926;

template<typename T>
T pi = (T)3.141592653;int main(int argc, char *argv[])
{QCoreApplication a(argc, argv);std::cout << pi<double> << '\n';std::cout << pi<float> << '\n';std::cout << pi<int> << '\n';return a.exec();
}

template<typename T, unsigned v>
unsigned MySize = (sizeof(T) == v);int main(int argc, char *argv[])
{QCoreApplication a(argc, argv);std::cout << MySize<float, 4> << '\n';std::cout << MySize<int, 2> << '\n';return a.exec();
}

– 其它形式的变量模板
std::is_same

参考
深蓝学院：C++基础与深度解析
cppreference