Mi sono imbattuto in un'istanza specifica in cui sembra che modularità e semplicità siano in conflitto l'una con l'altra. Di solito non è così, quindi non ero sicuro di come risolverlo.
Supponiamo che mi piacerebbe creare un'interfaccia queue :
template<typename T>
class queue {
public:
virtual ~queue() {}
virtual void enqueue(const T& t) = 0;
virtual void enqueue(T&& t) = 0;
virtual T dequeue() = 0;
};
Mentre stavo realizzando un paio di implementazioni (alcune delle quali sono atomiche), ho notato che potevo davvero risparmiare tempo avendo una "classe astratta" che chiamava i metodi empty() o full() per aiutare a implementare le variabili di condizione. In questo modo qualsiasi implementazione di classe I sincronizzata potrebbe anche solo estendere quella "classe astratta". La classe astratta, a sua volta, ha implementato un'interfaccia estesa:
template<typename T>
class bounded_queue : public queue<T> {
public:
virtual ~bounded_queue() {}
virtual bool full() = 0;
virtual bool empty() = 0;
};
Ma non sarebbe più semplice se avessi spinto quei metodi in queue , forse restituendo false di default? La risposta a questa domanda non è immediatamente ovvia per me. Se lo è, considera l'altra estremità dello spettro .
Non sono nemmeno sicuro che il disegno sopra (nel link) funzioni come previsto! Come posso decidere qualcosa di semplice, ma modulare?