oop — позволить одному классу выполнить работу или разделить один класс на несколько подклассов в C ++?

Question

oop — позволить одному классу выполнить работу или разделить один класс на несколько подклассов в C ++?

У меня есть вопрос, связанный с тем, как определить один класс или спроектировать несколько классов, а затем позволить им завершить работу. Моя задача:

1) идентифицировать некоторые объекты на изображении;
2) проанализировать особенности каждого объекта;
3) исходя из особенностей объекта выберите те, которые удовлетворяют некоторым
критерии.

Я могу определить один класс для работы, например, в C ++:

class JobExecutive
{
public:
void DoTheJob
{
IdentifyObjects();
AnalyzeObjects();
FindObjects();
}
};

Или я могу определить три класса:

class ObjectIndentifier()
{
pulbic:
std::vector<MyObject> objList;
void identifyObjects();
}

class ObjectFeatureAnalyzer()
{
public:
std::vector<MyFeatures> featureList;
std::vector<int> objSelect;
void analysizeObjects( std::vector<MyObject> &objList);
}
class ObjectFinder()
{
public:
std::vector<MyCoordinate> coordinatesAOI;
void findObject(std::vector<int> &objSelect,std::vector<MyObject>  &objList);
}

Эти три класса могут быть включены для выполнения этой работы:

ObjectIndentifier identifier;
identifier.identifyObjects();
ObjectFeatureAnalyzer analyzer;
analyzer.analysizeObjects(identifier.objList);
ObjectFinder finder;
finder.findObject(identifier.objSelect, identifier.objList);

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

1

c++design-patterns oop

Решение

Другие решения

Других решений пока нет …

Источник

Accepted Answer

В C ++ и любом языке OO хорошим правилом разработки является так называемое Принцип единой ответственности.

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

Рассмотрим простую реализацию компилятора:

class tokenizer
{
std::vector<tokens> tokenize( const std::string& code );
}:

class parser
{
backend_bytecode parse( const std::vector<token>& tokens );
};

class optimizer
{
backend_bytecode optimize( const backend_bytecode& bytecode );
};

class binary_generator
{
executable generate( const backend_bytecode& bytecode );
};

class compiler
{
tokenizer tokenizer;
parser    parser;
optimizer optimizer;
binary_generator generator;

executable compile( const std::string& code );
};

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

1