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

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

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

#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()

Answer 2

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

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

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

Using a templated function parameter type name to call a function

c++

templates

sfinae

c++14