Массив концептуальных указателей

Я пытаюсь выяснить, могу ли я использовать концепции как своего рода интерфейс для классов, не требуя дополнительной нагрузки на виртуальную таблицу. Я собрал пример, который вроде работает, но я должен хранить экземпляры моего класса в массиве, определяемом их общим наследованием, а не их общей концепцией. Я не вижу ничего обсуждаемого в постах о массивах понятий, но 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* массив (как в строке с комментариями ниже той, которая вызвала первую ошибку), программа компилируется и запускается, как и ожидалось.

Почему массив указателей концептов не разрешен? Будет ли это возможно в будущей версии с ++?

(Мой пример включает в себя виртуальные функции и наследование, хотя моя цель состояла в том, чтобы устранить их. Я включил их только для удобства, чтобы получить 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 для включения apply (), как определено стандартом C ++ 17, но он был доступен в std :: экспериментальный. (Я думаю, что это может быть добавлено в более поздней версии 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;
};