C++ int2Type&type2Type

#include <iostream>


// 编译期就能确定函数调用，主要是编译器不会去编译一个未被用到的template函数
// 只会做语法检查，在template代码中大部分需要在编译器期间进行dispatch分发操作

/**
使用场景：
1.有必要根据某个编译器常数调用一个或数个不同的函数；
2.有必要在编译期间进行dispatch(分发)
*/


// 可以使用int2Type进行进行类型重载
template<int T> class Int2Type {
    enum {value = T};
};

class ST{};

template<typename T, bool isPolymophic>
class NiftyContainer{
public:
    void DoSomeThing(T* obj) {
        this->DoSomeThing(obj, Int2Type<isPolymophic>());
    }
private:
    // Int2Type<true/false>是不同类型，因此函数可以正常重载
    void DoSomeThing(T* obj, Int2Type<true>) {
        std::cout<<"polymophic"<<std::endl;
    }
    
    void DoSomeThing(T* obj, Int2Type<false>) {
        std::cout<<"no polymophic"<<std::endl;
    }
};

void Test(){
    ST st;
    NiftyContainer<ST, true> nt; // DoSomeThing(T* obj, Int2Type<false>)不会被编译,没有用到
    nt.DoSomeThing(&st);

}


/** 
模板函数不能偏特化，全特化没有问题(比如就一个模板参数)
但想实现模板函数偏特化特性，可以使用type2Type进行模板函数重载
*/

// template<typename T, typename Q>
// void Print(T* t, Q q) {
//     std::cout<<"template function 原型"<<std::endl;
// }
// template<typename T>
// void Print<T, int>(T* t, int i) {
//     std::cout<<"template function 偏特化"<<std::endl;
// }
// non-class, non-variable partial specialization 'Print<T, int>' is not allowed


// 这是模板函数重载
template<typename T, typename Q>
void Print(T* t, Q q) {
    std::cout<<"template function 重载1"<<std::endl;
}

template<typename T>
void Print(T* t, int i) {
    std::cout<<"template function 重载2"<<std::endl;
}

void Test1(){
    Print("hello", 2); // 重载2
    Print("hello", "world");// 重载1
}

// 使用type2Type映射效果更好
template<typename T> class Type2Type{ typedef T NewDefinedType;};

template<typename T, typename Q>
T* CreateObj(Q q, Type2Type<T>) {
    // 函数原型
    std::cout<<q<<std::endl;
    return new T(q);
}

template<typename Q>
int* CreateObj(Q q, Type2Type<int>) {
    std::cout<<q<<std::endl;
    return new int(q);
}

void Test2(){
   std::string* pstr = CreateObj<std::string, std::string>("hello", Type2Type<std::string>()); // hello
   int * i = CreateObj<int>(10, Type2Type<int>());  // 10
}
int main() {
    Test();
    
  return 0;
}