我想提供一个函数声明/定义，它根据输入参数返回正确的数据类型。这听起来就像函数模板的用途，但更具体地说，我希望函数接口(interface)看起来像:

template<class InT>
RetT getData(InT*);

在哪里，

• 要求 1:RetT 取决于输入类型 InT，不一定等于 InT。
• 要求 2:此外，我想为所有实际的 InT 类型强制执行一个通用接口(interface)，以确定什么是 RetT。换句话说，希望 InT 应该是一个基类。

稍微介绍一下后台应用程序。假设我有一个文本处理系统，我可以为其指定各种配置。一些配置可能是标志(即 bool 值)，如 performCompact、addSpacing 等。一些配置可能是标记(即字符串文字)，如 prefixToPath 、surfixToLastName 等。某些配置可能是自定义数据类型，例如 textColorMap、fontFamily 等。

我想提供一个通用函数来查询每个配置的数据，而不是每个配置一个函数。而且由于配置数据以不同的类型存储，我需要此函数根据用于查询的配置返回正确的数据类型。

选择这种设计的主要原因是为了节省维护工作。这个查询基础设施在它自己的组件中，不同的团队在他们自己的组件中处理不同的配置子集。我想尽量减少维护工作，以便在添加新配置时无需修改查询接口(interface)。

下面给出了一些示例代码。这满足了这两个要求，但是我仍然想知道是否有办法避免 Requirement2 的类模板。

#include <iostream>
using namespace std;

// In a *.hpp file in component A
template<class T>
auto getData(T* spec) {
    return spec->data();
}

template<class DataT>
class Configuration {
    public:
    virtual DataT data() = 0; 
};

// In some other components source files
class PerformCompact : Configuration<bool> {
    private:
    bool _data;
    public:
    PerformCompact(bool d):_data(d){}
    bool data() override {return _data;}

};

class PrefixToPath : Configuration<string>{
    private:
    string _data;
    public:
    PrefixToPath(string d):_data(d){}
    string data() override {return _data;}
};

// In one application source file
int main()
{
   PerformCompact performCompact(true);
   PrefixToPath prefixToPath("Some string");
   auto pd = getData(&performCompact);
   auto pstr = getData(&prefixToPath);
   cout << pd << endl;
   cout << pstr << endl;

   return 0;
}

最佳答案

可以将 SFINAE 与来自 <type_traits> 的新元函数一起使用检查函数返回行中类型的条件。如果某些函数模板的条件失败，而其他函数模板没有失败，SFINAE 确保编译器继续前进并选择最佳函数模板候选者。

如果可以在编译时检查您的类型的条件，这当然有效。这个小例子检查两种类型是否可以相互赋值，然后启用返回类型。如果类型不可分配(C 与 (A,B) 的组合)，则编译失败:

#include <type_traits>
#include <cassert>

class A; 
class B; 
class C; 

class A 
{
    public: 
        void operator=(B const& b) {}; 
};  

class B 
{
    public: 
        void operator=(A const& a) {}; 
}; 

class C {}; 

template<class RetT, class InT>
std::enable_if_t
<
    std::is_assignable<InT,RetT>::value, 
    RetT
>
getData(InT*)
{
    RetT result; 

    return result;
};

using namespace std; 

int main()
{
    A* Aptr = new A;
    B* Bptr = new B;
    C* Cptr = new C;

    getData<A>(Bptr); 
    getData<B>(Aptr); 


    // Assignments not there, so the compilation fails. 
    getData<B>(Cptr); 
    getData<C>(Bptr); 
    getData<A>(Cptr); 
    getData<C>(Aptr); 

    delete Aptr; 
    Aptr = nullptr;
    delete Bptr; 
    Bptr = nullptr; 
    delete Cptr; 
    Cptr = nullptr;

    return 0;
};

您还可以使用 if constexpr如果可以使用 C++17，则在函数体中:

template<class RetT, class InT>
RetT
getData(InT*)
{
    if constexpr (std::is_assignable<InT,RetT>::value)
    {
        RetT result; 

        return result;
    }
    else assert(false && "RetT and IntT not assignable.");
};

if constexpr在编译时评估，如果为真

   RetT result; 

   return result;

被编译，否则 assert 语句被编译。如果您尝试将函数与 C、(A,B) 组合使用，则会出现运行时错误:

 RetT getData(InT*) [with RetT = B; InT = C]: Assertion `false && "RetT and IntT not assignable."' failed.

如果你想在编译时激活断言，你可以使用static_assert .

关于c++ - C++中有没有一种设计模式可以方便地以统一的函数接口(interface)查询不同类型的数据？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/54082307/