1.可变参数和限制输入：
代码：不限制输入，返回+的总和
#include <iostream>
#include <filesystem>
#include <string>
#include <vector>
template<class Type>
concept AddAble = requires(Type T1, Type T2) {
{T1 + T2 }->std::convertible_to<Type>;
};
template< AddAble... Args>
void Add(Args... arge) {
using argeType = std::common_type_t<Args...>;
argeType number = (arge + ...);
std::cout << " number is >>>" << number;
}
int main() {
Add(123,788,888);
Add(std::string {"dsafdf"},std::string{"ddddd"});
return 0;
}
详解：
自动推断类型的方法：
在C++中，可以使用多种工具和特性来推断一个参数的类型。以下是一些常用的方法和工具：
auto 关键字: auto 关键字可以用于变量声明中，以自动推断类型。
auto x = 42; // 推断 x 的类型为 int
auto y = 3.14; // 推断 y 的类型为 double
auto z = x + y; // 推断 z 的类型为 double
decltype 关键字: decltype 可以用于获取表达式的类型，而不实际计算该表达式。
int x = 42;
decltype(x) y = 43; // y 的类型是 int
函数模板和模板参数推断: 在函数模板中，参数类型可以自动推断。
template<typename T>
void printType(T t) {
std::cout << "Type is: " << typeid(t).name() << std::endl;
}
int main() {
printType(42); // T 被推断为 int
printType(3.14); // T 被推断为 double
return 0;
}
std::common_type: 用于推断多个类型的公共类型。
std::common_type_t<int, double> result; // result 的类型是 double
std::invoke_result: 用于推断函数调用返回的类型。
int func(double);
using ResultType = std::invoke_result_t<decltype(func), double>; // ResultType 是 int
C++20 Concepts: 概念可以用于约束模板参数，并能更清晰地表达类型要求。
template<typename T>
concept Addable = requires(T a, T b) {
{ a + b } -> std::convertible_to<T>;
};
template<Addable T>
void add(T a, T b) {
std::cout << a + b << std::endl;
}
std::remove_reference 和 std::remove_cv: 用于在模板元编程中获取类型的基本形式。
template<typename T>
void func(T&& param) {
using Type = std::remove_reference_t<T>;
// Type 是去除了引用的类型
}
std::common_with 和std::convertible_to在限制模版中经常使用，我们看一下他们的区别：
std::common_with 和 std::convertible_to 是C++20中引入的概念，用于约束模板参数类型。尽管它们看似相似，但它们的用途和语义有所不同。
std::common_with
std::common_with 概念用于检查两个类型是否有一个公共类型，即可以相互转换为一个共同的类型。具体来说，std::common_with<T, U> 检查以下条件：
std::common_type_t<T, U>存在。std::common_type_t<U, T>存在。std::common_type_t<T, U>和std::common_type_t<U, T>是同一个类型。T和U都可以转换为std::common_type_t<T, U>。
简而言之，std::common_with 确保两个类型可以相互转换，并且这种转换是对称且一致的。
std::convertible_to
std::convertible_to 概念用于检查一个类型是否可以隐式转换为另一个类型。具体来说，std::convertible_to<T, U> 检查以下条件：
std::is_convertible_v<T, U>为true。static_cast<U>(std::declval<T>())是一个有效的表达式，并且其结果可以被转换为U。
简而言之，std::convertible_to 确保一个类型可以隐式转换为另一个类型。
代码示例：
class Base
{
public:
void Test() { };
};
class Son:public Base
{
public:
void printf() {
std::cout << " -------------------------------- ";
};
};
class TestClass
{
public:
void test() { }
};
template<class T1,class T2>
requires std::convertible_to<T1,T2>
void FuncConver(T1 arg1,T2 arg2) {
}
template <class T1,class T2>
requires std::common_with<T1,T2>
void FuncTest(T1 agr1,T2 agr2) {
agr2.printf();
}
int main() {
Base ba;
Son so;
TestClass test {};
FuncTest(ba,so);
FuncConver(1,3434);
// FuncConver(ba,so);
// Add(123,788,888);
// Add(std::string {"dsafdf"},std::string{"ddddd"});
return 0;
}
