使用模板化的函数参数类型名称来调用函数

Question

我使用的是一个C API，它为不同类型定义了一些函数。类似于：

// defined in a header:
extern "C" A* A_create();
extern "C" B* B_create();

是否可以从模板化的C++函数中调用这些函数，以便模板类型参数确定要调用的C函数？

类似于：

// Template specialization for when T_create() exists
template <typename T>
auto create() -> declval( T##_create() ) {
// This is not valid syntax, but I'd like to call A_create() if this
// template is instantiated with A, B_create() if this is
// instantiated with B, etc. If the function doesn't exist, I'd like
// the compiler to fall back to the generic implementation below.
return T##_create() 
}
// Template specialization for when T_create() doesn't exist
template <typename T>
T* create() { 
return new T; // generic version just calls new. 
}

只是想知道是否可以在不为来自C api的每种类型显式专门化create()函数的情况下做到这一点。

Answer 1

由于没有参数可供使用，我可能只使用一个具有专业化功能的函数：

// generic version just calls new. 
template<class T>
T* create() { return new T;}
template<>
A* create() {return A_create();}
template<>
B* create() {return B_create();}

那么使用应该是琐碎的：

A* ptr = create<A>();

---

你无法避免专业化，但你可以让它们变得简单。

#define make_lib_create(T) template<> 
T* create() {return T##_create();}
make_lib_create(A);
make_lib_create(B);

Answer 2

您可以创建一个接受可调用作为参数的模板。以下示例提供了如何实现create函数的两个示例。

#include <iostream>
#include <memory>
struct A
{
A() { std::cout << "A()n"; }
~A() { std::cout << "~A()n"; }
};
struct B
{
B() { std::cout << "B()n"; }
~B() { std::cout << "~B()n"; }
};
std::unique_ptr<A> create_A()
{
return std::make_unique<A>();
}
std::unique_ptr<B> create_B()
{
return std::make_unique<B>();
}
template<typename C>
auto create(C createFn)
{
return createFn();
}
template<typename T>
auto create2(T (*createFn)())
{
return createFn();
}
int main()
{
std::cout << "create()n";
{
auto a = create(&create_A);
auto b = create(&create_B);
}

std::cout << "create2()n";
{
auto a = create2(&create_A);
auto b = create2(&create_B);
}
return 0;
}

输出：

create()
A()
B()
~B()
~A()
create2()
A()
B()
~B()
~A()