#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>

void* threadFunction(void* arg) {
    // 线程的执行代码
    printf("Thread is running\n");
    return NULL;
}

int main() {
    pthread_t thread;
    pthread_attr_t attr;
    size_t stackSize = 2 * 1024 * 1024; // 设置栈大小为2 MiB

    // 初始化线程属性
    if (pthread_attr_init(&attr) != 0) {
        perror("pthread_attr_init");
        return EXIT_FAILURE;
    }

    // 设置线程栈大小
    if (pthread_attr_setstacksize(&attr, stackSize) != 0) {
        perror("pthread_attr_setstacksize");
        return EXIT_FAILURE;
    }

    // 创建线程
    if (pthread_create(&thread, &attr, threadFunction, NULL) != 0) {
        perror("pthread_create");
        return EXIT_FAILURE;
    }

    // 等待线程结束
    if (pthread_join(thread, NULL) != 0) {
        perror("pthread_join");
        return EXIT_FAILURE;
    }

    // 销毁线程属性
    if (pthread_attr_destroy(&attr) != 0) {
        perror("pthread_attr_destroy");
        return EXIT_FAILURE;
    }

    return EXIT_SUCCESS;
}

namespace TagDispatch {

template <typename T>
void fun(T&& params) {
    std::vector<std::string> temp;
    temp.emplace_back(std::forward<T>(params));
    std::cout << "called fun(T&& params)" << std::endl;
}

void fun(int a) {
    std::cout << "called fun(int a)" << std::endl;
}

template <typename T>
void fwd(T&& params) {
    fun(std::forward<T>(params));
}

void test()
{
    fwd("abc"); //suc
    int a = 0;
    fwd(a);     //suc
    
    short b = 10;
    //fwd(b);     //failed, 匹配到了通用引用函数
    
}

int main(int argc, const char * argv[]) {    
    TagDispatch::test();

    return 0;
}

}

namespace TagDispatch {

template <typename T>
void fun2(T&& params, std::false_type) {
    std::vector<std::string> temp;
    temp.emplace_back(std::forward<T>(params));
    std::cout << "called fun(T&& params)" << std::endl;
}

void fun2(int a, std::true_type) {
    std::cout << "called fun(int a)" << std::endl;
}

template <typename T>
void fwd(T&& params) {
    fun2(std::forward<T>(params), std::is_integral<typename std::remove_reference<T>::type>());
}

void test()
{
    fwd("abc"); //suc
    int a = 0;
    fwd(a);     //suc
    
    short b = 10;
    fwd(b);     //succeed, 匹配到了通用引用函数
}

}

class Person
{
public:
    template <
        typename T,
        typename = std::enable_if_t<
            !std::is_base_of<Person, std::decay_t<T>>::value    // 防止调用拷贝和移动构造函数，并且考虑了子类
            &&                                                  // decay,移除指针引用和cv修饰符
            !std::is_integral<std::remove_reference_t<T>>::value
        >
    >
    explicit Person(T&& params) {
        std::vector<std::string> temp;
        temp.emplace_back(std::forward<T>(params));
        std::cout << "Person(T&& params)" << std::endl;
    }
    
    explicit Person(int a) {
        std::cout << "Person(int a)" << std::endl;
    }
};

void testCtrOverload() {

    short b = 10;
    Person person(b);
    
}

}