C ++ 11 prohíbe el uso de un determinado método de plantilla, combinado con std :: enable_if para lograr

escenas a utilizar:

Hay varios constructores y, al mismo tiempo, se implementa un constructor de parámetro variable con una plantilla. Ahora quiero llamar a diferentes constructores por separado, pero si el constructor de parámetro variable no es condicional, todas las inicializaciones llamarán a este constructor de parámetro variable. es causado por el principio de coincidencia automática de plantillas. Por lo tanto, en algunos casos, quiero prohibir este constructor de parámetros de variable. ¿Cómo implementarlo con otros constructores? Ahora, la plantilla combinada con std :: enable_if puede cumplir este requisito.

La función de std :: enable_if se puede encontrar en Internet. El siguiente es un método para que c ++ 11 prohíba el uso de una determinada plantilla. Este ejemplo se puede implementar principalmente para plantillas de parámetros variables.

Código:

#include <type_traits>
#include <iostream>
#include <memory>

class B {
public:
    B() { //没有参数的构造函数
        std::cout << "B init 0 param" << std::endl;
    }

    B(std::string ptr) { //1个参数的构造函数
        std::cout << "B init 1 param" << std::endl;
    };

    B(std::string sharedPtr, std::string sharedPtr1) { //2个参数的构造函数
        std::cout << "B init 2 param" << std::endl;
    }

    //3个参数的构造函数
    B(std::string sharedPtr, std::string sharedPtr1, std::string sharedPtr2) {
        std::cout << "B init 3 param string " << std::endl;
    }

    //可变参数的构造函数，只有参数大于3个才用此构造函数，假如不用std::enable_if加条件，则所有初始化都会调用此构造函数，模板匹配原则
    template<class... Args, typename std::enable_if<(sizeof...(Args) > 3)>::type...>
    B(Args&&... args) {
        fun1(std::forward<Args>(args)...);
        std::cout << "B init n parm" << std::endl;
    }

    ~B() {
        std::cout << "~B" << std::endl;
    };

    template<class U, class T>
    void fun1(U a, U b, U c, T d) {
        std::cout << "----fun1 template a:" << a << ",d:" << d << std::endl;
        funceb<T>(d);
    }
    
    template <typename F>
    typename std::enable_if<(sizeof(F) > 4)>::type funceb(F a)
    {
        std::cout << "----2222 funceb template a:" << a << std::endl;
    }
 

public:
    std::string a;
};

class D;
class C {
public:
    C(){
        std::cout << "0 C init" << std::endl;
    };

    //可变参数的类型都不一样的实现方式
    template<class... Args>
    void func(Args&&... args) {
        d_ptr = std::make_shared<D>(std::forward<Args>(args)...);
    }

    ~C() {};

private:
    std::shared_ptr<D> d_ptr;
};

class D {
public:
    D(){
        std::cout << "0 D init" << std::endl;
    };

    D(int a, std::string s, float f) {
        std::cout << "1 D init s:" << s << std::endl;
    };
    ~D() {};
};

int main()
{
    B b0;//用没有参数的构造函数
    B b("a1" ,"a2");//用只有两个参数的构造函数
    B b1(100 , 200 , 200, "hello"); //用可变参数的构造函数

    C c;
    c.func(1, "aaaaddddd", 2.0);//可变参数的多种数据类型的方式
}