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

如何解决使用模板化函数参数类型名称调用函数

我使用的 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() 函数进行显式特化的情况下做到这一点。

解决方法

由于没有可使用的参数，我可能只使用具有特化功能的函数：

// 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();}

Then usage should be trivial：

A* ptr = create<A>();

---

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

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

,

您可以创建一个接受可调用对象作为参数的模板。以下示例提供了 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()