C++类模板的重载

C++类模板的重载

  • 0. 说在前面的话
  • 1. 验证
  • 2. 额外的几个验证
    • 2.1 其他的几种写法
  • 3. 与特化的区分
  • 4. 测试的整体代码

0. 说在前面的话

由于在看QT5.15.2中的connect方法中的typedef QtPrivate::FunctionPointer SignalType;使用以及,QtPrivate::FunctionPointer的声明。而产生的疑问,因此有了这篇内容。QtPrivate::FunctionPointer的声明如下:

// 第一个
template<typename Func> struct FunctionPointer { enum {ArgumentCount = -1, IsPointerToMemberFunction = false}; };
// 第二个
template<class Obj, typename Ret, typename... Args> struct FunctionPointer<Ret (Obj::*) (Args...)>
    {
        typedef Obj Object;
        typedef List<Args...>  Arguments;
        typedef Ret ReturnType;
        typedef Ret (Obj::*Function) (Args...);
        enum {ArgumentCount = sizeof...(Args), IsPointerToMemberFunction = true};
        template <typename SignalArgs, typename R>
        static void call(Function f, Obj *o, void **arg) {
            FunctorCall<typename Indexes<ArgumentCount>::Value, SignalArgs, R, Function>::call(f, o, arg);
        }
    };

QtPrivate::FunctionPointer 的声明总共有七个,这里不再一一粘贴,看到这里不知诸位会不会产生以下几个疑问:

  1. 第二个QtPrivate::FunctionPointer 后面尖括号中的内容是什么
  2. 第二个QtPrivate::FunctionPointer 与第一个有什么关系,我们都知道
  3. typedef QtPrivate::FunctionPointer SignalType;会最终匹配到那个类型

我这里使用的环境是VS2019编写的代码, C++ 14的编译标准

1. 验证

  1. 声明一个结构体模板,声明形式如下

    template <typename A> struct Test<A> {};
    

    这种写法会产生如下错误
    在这里插入图片描述
    从这个错误提示中我们可以得到信息如下:

    1. 主模板(那有主模板是不是就由次模板呢?这里的次模板是我自己定义的,因为在网上没有查找到相关资料,若有知道官方资料地址,请评论区留言感谢!!!)
    2. 模板参数列表(模板参数列表起到的具体作用是什么?)
  2. 主模板与次模板一起声明
    次模板声明的官方标准暂未找到~~~
    这里的声明仿照了QT的源码

    template<class Obj> struct FunctionPointer {};
    template<class Obj, typename Ret, typename... Args> struct FunctionPointer<Ret(Obj::*) (Args...)>
    {
        typedef Obj Object;
        enum { ArgumentCount = sizeof...(Args), IsPointerToMemberFunction = true };
        typedef List<Args...>  Arguments;
    };
    

    接下来看FunctionPointer的用已经VS的智能提示
    C++类模板的重载_第1张图片
    C++类模板的重载_第2张图片
    看到这个智能提示诸位是否觉得有点像重载的提示呢?(这也是为什么文章标题是类模板的重载)。
    看到第一个提示大家应该很熟悉,就是任意类型。
    那第二个是什么呢?整体看起来有么有感觉它很想函数指针类型呢? 没错它就是一个函数指针类型,但确实一个类的成员函数指针类型,而(Args...)则表示该函数的参数。
    用其声明一个变量如下:

    /*
    template struct FunctionPointer
    声明的变量与结构体模板声明中各个类型的对象关系:
    	1. Obj:会被推导为MyClass
    	2. Ret:会被推导为void
    	3. Args:则会被推导为0个类型
    
    这里回答 "模板参数列表起到的具体作用是什么?" 这个问题,模板参数列表起到作用是指定这个模板类型接受的参数类型
    */ 
    FunctionPointer<void(MyClass::*)()> fpTest;
    

到这里我想最初的那三个问题,小伙伴们应该已经知道答案了吧。问题如下:

  1. 第二个QtPrivate::FunctionPointer 后面尖括号中的内容是什么
  2. 第二个QtPrivate::FunctionPointer 与第一个有什么关系,我们都知道
  3. typedef QtPrivate::FunctionPointer SignalType;会最终匹配到那个类型

2. 额外的几个验证

根据typedef List Arguments;衍生的验证,List模板类型的声明如下:

template <typename...> struct List { int primary; };
template <typename Head, typename... Tail> struct List<Head, Tail...> { typedef Head Car; typedef List<Tail...> Cdr; int ts; };
  1. List的使用及智能提示
    C++类模板的重载_第3张图片
    C++类模板的重载_第4张图片
    在第二个的智能提示中多个,且前面是空的,这个会有什么影响呢?看下面List的使用:

    // 可以看到,由于设置了两个类型,会被匹配到List的次模板(重载模板)
    List<int, string> list1;
    list1.ts = 0;
    
    // 一个类型同样会被匹配到次模板
    List<int> list2;
    list2.ts = 0;
    
    // 不设置类型的时候,被匹配到了主模板
    List<> list3;
    list3.primary = 0;
    
    // 多于两个类型的同样会被匹配到次模板
    List<int, string,int> list4;
    list4.ts = 0;
    

    目前看下来智能提示中多个,且前面是空的,好像对传入类型什么的并没有影响,这个应该是个标记(个人猜测),这个,目前测试看仅在主模板中存在可变模板参数时才会有。

2.1 其他的几种写法

  1. 主模板包含可变参数类型
    // 主模板包含可变参数类型时,次模板才可以调整模板参数类型的个数,但次模板不可与主模板参数类型一致
    
    template <typename A, typename...> struct List2 { int primary; };
    template <typename A, typename B,typename... Tail> struct List2<A, B,Tail...> { int abtail; };
    template <typename A> struct List2<A> { int A; };
    template <typename A, typename B> struct List2<A,B> { int AB; };
    template <typename A, typename B, typename C> struct List2<A,B,C> { int ABC; };
    // 次模板与主模板参数类型一致 error
    // template  struct List2 { int abtail; };
    
  2. 主模板不包含可变参数类型
    // 主模板不包含可变参数类型时,次模板可以包含可变参数类型
    template <typename A> struct Test { int primary; };
    template <class A, typename... B> struct Test<A(*) (B...)> { int testAmultiB; };
    /*
    * 将可变模板参数改掉后
    *   1. 若 template  struct Test { int testAmultiB; }; 存在则匹配此模板
    *   2. 若其不存在则匹配到主模板
    */ 
    //template  struct Test { int testAB; };
    /*
    * 以下两种写法都会被认为类模板参数太多,第一种是可能是因为主模板不包含可变参数,若次模板包含可变参数时
    * 可变参数需要放到可以被解释的参数中,如函数的形参
    * 
    * 第二种暂不清楚
    */
    //template  struct Test { int testAmultiB; };
    //template  struct Test { int testAB; };
    

3. 与特化的区分

特化写法如下:

template <typename A, typename B> struct templateSpecialization {};
template <typename A> struct templateSpecialization<A, int> {};
template <> struct templateSpecialization<char, int> {};

4. 测试的整体代码

// templateStruct.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
//

#include 
using namespace std;
class MyClass
{
public:
    MyClass() = default;
    ~MyClass() = default;
    void test(int,int) { return; }
};


template <typename A, typename B> struct templateSpecialization {};
template <typename A> struct templateSpecialization<A, int> {};
template <> struct templateSpecialization<char, int> {};


template <typename...> struct List { int primary; };
template <typename Head, typename... Tail> struct List<Head, Tail...> { typedef Head Car; typedef List<Tail...> Cdr; int ts; };


// 主模板包含可变参数类型时,次模板才可以调整模板参数类型的个数,但次模板不可与主模板参数类型一致

template <typename A, typename...> struct List2 { int primary; };
template <typename A, typename B,typename... Tail> struct List2<A, B,Tail...> { int abtail; };
template <typename A> struct List2<A> { int A; };
template <typename A, typename B> struct List2<A,B> { int AB; };
template <typename A, typename B, typename C> struct List2<A,B,C> { int ABC; };
// 次模板与主模板参数类型一致 error
// template  struct List2 { int abtail; };


// 主模板不包含可变参数类型时,次模板可以包含可变参数类型
template <typename A> struct Test { int primary; };
template <class A, typename... B> struct Test<A(*) (B...)> { int testAmultiB; };
/*
* 将可变模板参数改掉后
*   1. 若 template  struct Test { int testAmultiB; }; 存在则匹配此模板
*   2. 若其不存在则匹配到主模板
*/ 
//template  struct Test { int testAB; };
/*
* 以下两种写法都会被认为类模板参数太多,第一种是可能是因为主模板不包含可变参数,若次模板包含可变参数时
* 可变参数需要放到可以被解释的参数中,如函数的形参
* 
* 第二种暂不清楚
*/
//template  struct Test { int testAmultiB; };
//template  struct Test { int testAB; };







template<class Obj> struct FunctionPointer {};
template<class Obj, typename Ret, typename... Args> struct FunctionPointer<Ret(Obj::*) (Args...)>
{
    typedef Obj Object;
    enum { ArgumentCount = sizeof...(Args), IsPointerToMemberFunction = true };
    typedef List<Args...>  Arguments;
};

template <typename Func1, typename Func2>
static inline void connect(const typename FunctionPointer<Func1>::Object* sender, Func1 signal,
    const typename FunctionPointer<Func2>::Object* receiver, Func2 slot)
{
    const type_info& nInfo = typeid(Func1);
    cout << nInfo.name() << " | " << nInfo.raw_name() << " | " << nInfo.hash_code() << endl;
    const type_info& inInfo = typeid(FunctionPointer<Func1>::Arguments::Car);
    cout << inInfo.name() << " | " << inInfo.raw_name() << " | " << inInfo.hash_code() << endl;

    cout << FunctionPointer<Func1>::ArgumentCount << endl;

}

int main()
{
    typedef void (*ptr)();
    Test<ptr> test1;
    test1.testAmultiB;
    
    FunctionPointer<void(MyClass::*)()> fpTest;

    List<int,string> list1;
    list1.ts = 0;

    List<int> list2;
    list2.ts = 0;

    List<> list3;
    list3.primary = 0;

    List<int, string,int> list4;
    list4.ts = 0;


    List2<int> list21;
    list21.A = 0;
    
    List2<int,int> list22;
    list22.AB = 0;

    List2<int,int,int> list23;
    list23.ABC;


    MyClass a;
    connect(&a, &MyClass::test, &a, &MyClass::test);

}




你可能感兴趣的:(C++,c++)