C++:如何组合多个概念？

这个标题似乎受到了很多批评。但是，我发现很难找到这个概念。在C++领域，它也是相对较新的地方，那里的学校仍在教授C++11。
避免XY问题的动机和环境
现在，我正在使用concepts来测试嵌入式设备项目，这是逆向工程(和学习)过程的一部分。设备库和设备API的问题在于，有各种各样的编程禁忌是从文字设备(或设备产品线)的能力中提炼出来的:

硬编码设置

扩展

宏

设备功能的特定捆绑包或子集

，它利用宏和帮助程序类来构建结构(structs building structs)

没有简化的假设:用于跨平台和设备测试的大量错误处理包

等。

代码结束了-无论开发人员多么努力，我都知道不可能有更好的结果-变得非常冗长和复杂。换句话说，它在功能上很简单，但是很难理解。
通常，我可能会形成structs来包装捆绑包并隐藏硬编码的内容，但是现在我正在使用concepts，因为它们使我能够构造自己的接口(interface) namespace ，该 namespace 可以由我(一个独立的开发人员)更有效地进行更改或更新。知识。我对设备的了解越少，使用它就越好。
通过概念，我还可以保护编写的代码(取决于我的概念化内容)不受设备制造商和api提供程序的更改传播。

在利用这些概念时，我正在尽早选择关于代码结构的选择。
为了做出决定，我需要知道concepts是否有可能被原子地编写，然后组成conceptual structures。例如:

// real code

// Concepts

template < typename ContextInfo>
concept ExtensibleDeviceContext = requires(ContextInfo & contextInfo, const char * name,
                                           bool optional, void * devFeatures)
{
    { contextInfo.addDeviceExtension(name, optional, devFeatures)};
};

template< typename ContextInfo>
concept ExtensibleInstanceContext = requires(ContextInfo & contextInfo, const char * name,
                                             bool optional)
{
  { contextInfo.addInstanceLayer(name, optional) };
  { contextInfo.addInstanceExtension(name, optional) };
};

// Some dummy functions

template<ExtensibleDeviceContext Cx>
void foo(Cx &context, const char *name, bool optional, void *devFeatures)
{
   context.addDeviceExtension(name, optional, devFeatures, version);
   context.addDeviceExtension(FOO_MACRO_1);
}

template<ExtensibleInstanceContext Cx>
void bar(Cx &context, const char *name, bool optional)
{
   context.addInstanceLayer(name, optional);
   context.addInstanceExtension(BAR_MACRO);
}

实际上，我想做的是在模板上下文“<...>”内将这些概念组合成一堆概念:

// psuedo-code: what I am trying to achieve

template<typename PortInfo: {ExtensibleInstanceContext, ExtensibleDeviceContext}>
void foobar(
      PortInfo port,
      const char *portName,
      bool optional,
      const char *devName,
      bool devOptional,
      void *devFeatures
    )
{
   foo(port, devName, devOptional, devFeatures);
   bar(port, portName, optional);
};

这种concept组合可能吗？如果是这样，是否可以在上面概述的模板语法中进行？如果没有，是否应该采用某种“更好”或“预期”的方法来代替呢？

最佳答案

您可以使用foobar子句约束requires，或命名所需概念的结合。

template<typename PortInfo>
requires ExtensibleInstanceContext<PortInfo> && ExtensibleDeviceContext<PortInfo>
void foobar(
      PortInfo port,
      const char *portName,
      bool optional,
      const char *devName,
      bool devOptional,
      void *devFeatures
    )
{
   foo(port, devName, devOptional, devFeatures);
   bar(port, portName, optional);
};

或者

template <typename ContextInfo>
concept ExtensibleDeviceInstanceContext = ExtensibleInstanceContext<ContextInfo> && ExtensibleDeviceContext<ContextInfo>;

template <ExtensibleDeviceInstanceContext PortInfo>
void foobar(
      PortInfo port,
      const char *portName,
      bool optional,
      const char *devName,
      bool devOptional,
      void *devFeatures
    )
{
   foo(port, devName, devOptional, devFeatures);
   bar(port, portName, optional);
};

您可以使用&&，||和!及其通常的 bool 含义来组合概念。