c++ - 正确声明模板参数 - 显式特化函数定义时的参数

Question

我有一个看起来像这样的类:Foo 是我的类； FooBar 是库中的一堆不同类型的类，每个类都有独立的名称。

Foo.h

class Foo {
public:
    Foo() = default;

    // There many types, and many of these types have multiple constructors
    // All of the appropriate overloads are available here.
    template<class Type>
    FooBar<Type>& getFooBarByFullName( ... ) {
       // construct & return FooBar<Type>(...);
    }      

    // Then I have a hand full of overloaded function template declarations 
    // with a generic name to call the appropriate functions from above.
    // Each FooBar has different parameters, and FooBar is a class template.
    template<class Type, template<typename> class FooBar>
    FooBar<Type>&  getFooBar(...);
};

// Outside of any class I have a generic function template
template<class Other, class Type, template<typename> class FooBar, class... FP>
Type doSomething( some param A, some param B, some param C, FP... params ) {
    // Code here to work with Other using A, B & C

    FooBar<Type> fooBar = getFooBar<Type, FooBar>( params... );
    // do something to fooBar

    return value generated from fooBar;
}

Foo.cpp

#include **Foo.h**

template<class Type, template<typename> class FooBar>
FooBar<Type>&  getFooBar(...) {
    return {};
}

template<>
FooBar<int>& Foo::getFooBar( ... ) {
    return getFooBarByFullName( ... );
}

template<>
FooBar<short>& Foo::getFooBar( ... ) {
    return getFooBarByFullName( ... );
}

// etc...

---

我正在处理的其中一个模板参数的实现是 class unary_op .

我不想定义任何这样的类。我需要能够将函数对象、函数指针、lambda 或 std::function 作为 unary_op 传递给这些函数类。

我遇到的问题是我的标题中的声明是否如下所示:

template<class IntType = int, class UnaryOp>
FooBar<IntType>& getFooBarByFullName( std::size_t count, double xmin, double xmax, UnaryOp fw ) {
    // Constructors last parameter is defined as a class UnaryOp; 
    // but can be any of a function object, function pointer, lambda, std::function<...> etc.
    FooBar<IntType> fooBar( count, xmin, xmax, fw ); 
}

// Then I can declare the appropriate generic declaration overload here
template<class Type, template<typename> class FooBar, class FuncOp>
FooBar<Type>& getFooBar( std::size_t count, double xmin, double xmax, FuncOp fw ); // Declaration only

但是，当我转到 cpp 文件以使用提供的适当重载声明编写定义显式特化，同时试图避免歧义时，我遇到了麻烦。

template<>
FooBar<int>& Foo::getFooBar( std::size_t count, double xmin, double xmax, ? ) {
    return getFooBarByFullName<int>( count, xmin, xmax, ? );
}

template<>
FooBar<short>& Foo:getFooBar( std::size_t count, double xmin, double xmax, ? ) {
    return getFooBarByFullName<short>( count, xmin, xmax, ? );
}

如您所见，我不知道如何定义 class UnaryOp 类型的最后一个参数.我还希望能够支持调用者可以传递我上面提到的任何类型:function object , function pointer , lambda , std::function<>作为 UnaryOp 的最后一个参数.我不知道从这里去哪里......

编辑 - 我忘了在我的实际代码中提到这一点；上面两个类删除了默认构造函数；并且所有类方法都是静态的。

Answer 1

目前还不清楚您实际在问什么，但您的问题似乎是在 .cpp 文件中创建一个可实例化但通用的函数。我认为有两种选择可以解决这个问题:

1. 放弃你的计划:让这些方法模板只存在于 .hpp 文件中并占用 UnaryOp作为(可推导的)模板参数。

   .hpp:
   template<typename Type, typename UnaryOp>
   Type Qoo(Type const&x, UnaryOp&&func)
   {
      // some simple/short code calling func()
   }
   

2. 为 UnaryOp 实现函数重载= std::function在你的 .cpp 文件中实现通用 UnaryOp (lambda、仿函数、函数指针等)作为 .hpp 文件中的模板，使用 std::function 调用前者从任何 UnaryOp 创建的对象是。

   .hpp:
   template<typename Type>
   Type Qoo(Type const&, std::function<Type(Type)>&&);
   
   template<typename Type, typename UnaryOp>
   Type Qoo(Type const&x, UnaryOp&&func)
   {
      return Qoo(x, std::function<Type(Type)>{func});
   }
   
   .cpp
   template<typename Type>
   Type Qoo(Type const&t, std::function<Type(Type)>&&func);
   {
      // some lengthy code calling func()
   }
   // explicit instantiations
   template int Qoo(int const&, std::function<int(int)>&&);
   template short Qoo(short const&, std::function<short(short)>&&);
   ...
   

第二个版本允许预编译，但在 UnaryOp 情况下会产生开销≠ std::function<> .第一个解决方案避免了此类开销，但将完整的实现公开给 .hpp 文件并且不提供预编译的好处。

在类似的情况下，如果实现的代码很多，我倾向于使用第二个版本，这样 std::function 的开销对象可以容忍，第一个版本只针对小代码，一般应该是inline无论如何。

最后，请注意，在 .cpp 文件中，您无需定义所有特化，只需提供模板并指定显式实例即可。