在C++中通过模板参数传递类构造函数

Question

我知道函数可以通过template参数，我可以像这样传递类构造函数。

更新： 的全部原因，我想这样做，是我可以在存储库并没有任何代码我想的alloc类改变选择的构造函数（在这种情况下class A）

class A 
{ 
public: 
    A(){n=0;} 
    explicit A(int i){n=i;} 

private: 
    int n; 
}; 

class MemoryPool 
{ 
public: 
    void* normalMalloc(size_t size); 
    template<class T,class Constructor> 
    T* classMalloc(); 
}; 

template<class T,class Constructor> 
T* MemoryPool::classMalloc() 
{ 
    T* p = (T*)normalMalloc(sizeof(T)); 
    new (p) Constructor; // choose constructor 
    return p; 
} 

MemoryPool pool; 
pool.classMalloc<A,A()>(); //get default class 
pool.classMalloc<A,A(1)>(); 

Answer 1

你无法绕过的构造函数，但是你可以通过工厂周边函子：

class A 
{ 
    int n; 

    A(int i) : n(i) {}; 

public: 

    static A* makeA(int i) 
    { 
     return new A(i); 
    } 
}; 

template<typename T, typename Factory> 
T* new_func(Factory factory) 
{ 
    return factory(); 
} 

#include <functional> 

int main() 
{ 
    new_func<A>(std::bind(&A::makeA, 0)); 
    new_func<A>(std::bind(&A::makeA, 1)); 
} 

Answer 2

你整个的假设是错误的。你不需要这个功能。

template<class T> 
T* new_func() 
{ 
    return new T; 
} 

new之后的东西是一个类型，而不是构造函数的引用。

Answer 3

这样更好，我觉得

template<class T, int n> 
struct Factory 
{ 
    static T* new_func() 
    { 
    return new T(n); 
    } 
}; 

template<class T> 
struct Factory<T,0> 
{ 
    static T* new_func() 
    { 
    return new T; 
    } 
}; 

T* t = Factory<T>::new_func(); //call default constructor 
T* t2 = Factory<T,2>::new_func(); //call constructor T(2)