Полиморфные ключи карты в C ++

Question

Я работаю над API компьютерного зрения, где у меня есть различные алгоритмы, которые все работают с данными изображения и пытаются классифицировать некоторые объекты.

Некоторые из простых алгоритмов говорят, что классифицируют объекты просто на основе их размера, т.е. алгоритм может возвращать количество всех объектов в зависимости от их размера, например: маленький, средний, большой, например

Некоторые другие алгоритмы более точно настроены и могут классифицировать объекты по их истинному типу, например, стол, стул, кровать.

Итак, у меня есть интерфейс для всех таких объектов подсчета, как:

class IFurnitureCounter
{
    virtual std::map<ObjectType, size_t> getCount(const Image &input) = 0;
};

Идея состоит в том, что каждый из этих алгоритмов будет реализовывать этот getCount() метод, чтобы вызывающий мог использовать их независимо.

Моя проблема в том, что ключ ObjectType превращается в мешанину. Итак, я могу определить это ObjectType как перечисление, например:

enum class ObjectType {SMALL, MEDIUM, BIG, TABLE, CHAIR, BED} 

Однако это плохо, так как каждый алгоритм теперь видит все типы, даже если конкретный алгоритм может работать только с их подмножеством. Мне было интересно, есть ли лучшая парадигма разработки для лучшего разделения этих типов между алгоритмами.

EDIT Одна вещь, о которой я подумал, - это иметь разные enum для разных алгоритмов и специализироваться на этом типе.

Итак, скажем, у нас есть что-то вроде:

enum class SizeEnum {SMALL, MEDIUM, BIG};
enum class ObjectTypeEnum {CHAIR, TABLE, BENCH}

Итак, мой интерфейс может выглядеть так:

template<typename EnumType>
class IFurnitureCounter
{
    virtual std::map<EnumType, size_t> getCount(const Image &input) = 0;
};

Теперь у меня может быть что-то вроде:

class MyAwesomeCounter: public IFurnitureCounter<ObjectTypeEnum>
{
   // My implementation here...
};

Хотелось бы что-нибудь подобное? Может быть, мой синтаксис не точен, но кто-то может сказать мне, если это разумный подход или нет?

Answer 1

Я не уверен, что это правильный подход, но я нашел подход, основанный на шаблонах, который, кажется, работает (по крайней мере, начиная с C ++ 11).

// Interface class
template<typename EnumType>
class IFurnitureCounter
{
public:
    virtual std::map<EnumType, size_t> getCount() = 0;
};

Теперь мы можем наследовать от базы как:

enum class ObjectTypeEnum {CHAIR, TABLE, BENCH};
class MyAwesomeCounter: public IFurnitureCounter<ObjectTypeEnum>
{
public:
    virtual std::map<ObjectTypeEnum, size_t> getCount()
    {
         ObjectTypeEnum ote = ObjectTypeEnum::CHAIR;
         std::map<ObjectTypeEnum, size_t> map;
         map[ote] = 5;
         return map;
    }
};

int main()
{
    MyAwesomeCounter mac = MyAwesomeCounter();
    auto r = mac.getCount();
    std::cout << r[ObjectTypeEnum::CHAIR] << std::endl;
}

Кажется, что делает работу. Я уверен, что у этого подхода есть недостатки, и я с нетерпением жду каких-либо комментариев.

Этот код можно запустить здесь: http://www.cpp.sh/8h5uy