template<std::same_as<int>...T>
int sum(T...args){
    auto s = (args+...+0);
    return s;
}

template<typename... Ts>
auto make_tuple(Ts ...args)   -> decltype(std::tuple<Ts...> t(args...)) //c11 写法
auto make_tuple(Ts ...args)  //c14 自动推导
{
    std::tuple<Ts...> t(args...);
    return t;
}

template<std::convertible_to<double>... Ts> //可转成double
void f(Ts ...args){
    std::vector<double>t{1.0+(args)*{args}...};
    for(auto v:t){
        cout<<v<<endl;
    }
    cout<<"sizeof...(args)"<<endl;
}
int main(){
    f(1,2.0f,3,4,1);
    return 0;
}


template<typename ...Base>
class Myclass:public Base...{
    public:
        Myclass():Base()...{}
};
int main(){
    Myclass<BaseClass1,BaseClass2>mc;
}

template<typename ...Ts>
void print_fold(Ts...args){
    ((cout<<args<<endl), ...);
}

void print_recursion(const auto &first, const auto & ...rest){
    cout<<first<<endl;
    if constexpr(sizeof...(rest)>0) {
        print_recursion(rest...);
    }
    
}

//使用常量n进行索引
auto f(auto ...args){
    const int n=sizeof...(args);
    cout<<args...[n]<<endl;
}


template<std::size_t I,typename...Args>
auto element_at(const Args &...args){
    static_assert(I<sizeof...(args),"Index out of bounds");
    return std::get<I>(std::forward_as_tuple(args...));
}

//递归方式获取。
template<std::size_t I,typename T, typename...Args>
auto element_at(T arg0, const Args&... args){
    static_assert(I<1+sizeof...(args),"Index out of bounds");
    if constexpr (I==0)
        return arg0;
    else
        return element_at<I-1>(args...);
}
//c++26
template<std::size_t I, typename ... Args>
auto element_at_1(const Args&...args){
    return args...[I];
}


int main(){
    cout<<element_at<3>(1,2.0,'c',"string")<<endl;
    return 0;
}