我想弄清楚我是否可以使用概念作为类的一种接口(interface)而不需要虚拟表的开销。我整理了一个可以工作的示例，但我必须将我的类实例存储在一个数组中，该数组由它们的共同继承而不是它们的共同概念定义。我没有在帖子中看到任何关于概念数组的讨论，但 g++ 6.3.0 似乎不允许这样做。错误是:

$ g++ -fconcepts -std=c++1z custom_concept.cpp 
custom_concept.cpp: In function ‘int main()’:
custom_concept.cpp:37:20: error: ‘shapes’ declared as array of ‘IShape*’
    IShape* shapes[2] = {&square, &rect};  // doesn't work 
                    ^
custom_concept.cpp:39:25: error: ‘shapes’ was not declared in this scope
    for (IShape* shape : shapes ) 
                         ^~~~~~

如果我将 IShape* 数组更改为 Rectangle* 数组(如导致第一个错误的注释行下方的行)，程序将编译并按预期运行。

为什么不允许概念指针数组？这可能会在未来的 c++ 版本中被允许吗？

(我的示例包括虚函数和继承，尽管我的目标是消除它们。我包括它们只是为了方便 Rectangle* 版本工作。如果我能得到 IShape* 版本可以工作，我计划删除虚函数和继承。)

代码如下:

#include <iostream>

template <typename T>
concept bool IShape = requires (T x, T z, int y)
{
    { T() } ;
    { T(x) }  ;
    { x = z } -> T& ;
    { x.countSides() } -> int ;
    { x.sideLength(y) } -> int ;
};

struct Rectangle
{
    Rectangle() {};
    Rectangle(const Rectangle& other) {};
    Rectangle& operator=(Rectangle& other) {return *this; };
    virtual std::string getName() { return "Rectangle"; }

    int countSides() {return 4;}
    virtual int sideLength(int side) { return (side % 2 == 0) ? 10 : 5; }
};

struct Square : public Rectangle
{
    Square() {};
    Square(const Square& other) {};
    Square& operator=(Square& other) {return *this; };
    std::string getName() override { return "Square"; }
    int sideLength(int side) override { return 10; }
};

int main()
{
    Square square;
    Rectangle rect;
    IShape* shapes[2] = {&square, &rect};  // doesn't work 
//  Rectangle* shapes[2] = {&square, &rect}; // works 
    for (IShape* shape : shapes )
    {
        for (int side = 0 ; side < shape->countSides() ; ++side )
        {
            std::cout << shape->getName() << " side=" << shape->sideLength(side) << "\n";
        }
    }

    return 0;
};

感谢@Yakk 关于使用元组的想法。 G++ 6.3.0 没有完全实现 #include 文件以包含 C++17 标准定义的 apply()，但它在 std::experimental 中可用。 (我认为它可能会添加到更高版本的 g++ 中。)这是我最终得到的:

#include <iostream>
#include <tuple>
#include <experimental/tuple>

template <typename T>
concept bool IShape = requires (T x, T z, int y)
{
   { T() } ;
   { x = z } -> T& ;
   { T(x) }  ;
   { x.countSides() } -> int ;
   { x.sideLength(y) } -> int ;
};

struct Rectangle
{
   Rectangle() {};
   Rectangle(const Rectangle& other) {};
   Rectangle& operator=(Rectangle& other) {return *this; };

   std::string getName() { return "Rectangle"; }
   int countSides() {return 4;}
   int sideLength(int side) { return (side % 2 == 0) ? 10 : 5; }
};

struct Square
{
   Square() {};
   Square(const Square& other) {};
   Square& operator=(Square& other) {return *this; };  

   std::string getName() { return "Square"; }
   int countSides() {return 4;}
   int sideLength(int side) { return 10; }
};

void print(IShape& shape)
{
   for (int side = 0 ; side < shape.countSides() ; ++side )
   {
      std::cout << shape.getName() << " side=" << shape.sideLength(side) << "\n";
   }
};

int main()
{
   Square square;
   Rectangle rect;
   auto shapes = std::make_tuple(square, rect);
   std::experimental::apply([](auto&... shape) { ((print(shape)), ...); }, shapes) ;

   return 0;
};

最佳答案

这是不可能的。

我的意思是您可以实现自己的类型删除来替换 virtusl 函数表。在您的特定情况下，它可能比 vtable 性能更高，因为您可以根据您的具体问题对其进行定制。

要从编译器获得帮助，这样您就不必编写样板/胶水代码，您需要反射和具体化支持以及辅助概念。

如果你这样做，它看起来像:

ShapePtr shapes[2] = {&square, &rect};

或

ShapeValue shapes[2] = {square, rect};

现在这不会做所有你希望性能明智的事情；类型删除仍然会跳过函数指针。并具有每个对象或 View 的存储开销。但是，您可以用更多的存储空间换取更少的间接访问。

这里的手动类型删除基本上是在 C 中实现一个对象模型，然后将其包装在 C++ 中看起来很漂亮。默认的 C++ 对象模型只是一种可能的方法，C 程序实现了许多替代方法。

您也可以退后一步，将数组替换为元组。元组可以存储非统一类型，并且通过大量工作您可以迭代它们:

auto shapes = make_IShapePtr_tuple(&square, &rect);

foreach_elem( shapes,[&](IShape* shape )
{
    for (int side = 0 ; side < shape->countSides() ; ++side )
    {
        std::cout << shape->getName() << " side=" << shape->sideLength(side) << "\n";
    }
});

lambda 获取非类型删除类型的地方。

这些都不需要概念:

auto shapes = std::make_tuple(&square, &rect);

foreach_elem( shapes,[&](auto* shape )
{
    for (int side = 0 ; side < shape->countSides() ; ++side )
    {
        std::cout << shape->getName() << " side=" << shape->sideLength(side) << "\n";
    }
});

以上可以写成c++14 .

A c++17 foreach_elem 看起来像:

template<class T, class F>
void foreach_elem( T&& t, F&& f ) {
  std::apply( [&](auto&&...args){
    ( (void)f(decltype(args)(args)), ... );
  }, std::forward<T>(t) );
}

在c++14 lambda 中的行改为:

    using discard=int[];
    (void)discard{ 0,((void)f(decltype(args)(args)),0)... };

这有点迟钝，需要 std::apply 的实现。

在c++11您必须在外部编写一个模仿 c++14 的结构 lambda 。

关于c++ - 概念指针数组，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/51996834/