Come confrontare oggetti con quantità di dati in espansione?

Question

Come confrontare oggetti con quantità di dati in espansione?

#1 da (4 voti)
#2 da (1 voti)
#3 da (0 voti)

4

Dato una classe come:

class State {
    bool IsLessThan(State);
    int data;
};

Il metodo State::IsLessThan(State) può semplicemente confrontare data in ogni classe secondo una logica. Tuttavia, supponiamo che i dati all'interno di State cambino durante lo sviluppo e mantengano diversi tipi predefiniti di gruppi di dati che il cliente decide di aggiungere allo stato. Un modo per implementare questo è:

class State {
    void Add(StateData);
    bool IsLessThan(State);
    Set<StateData> data;
};

Dove una classe derivata di StateData può essere considerata come struct con alcuni dati. Supponiamo che se State non contiene un tipo di StateData , ha un'istanza creata con valori predefiniti. Ogni volta che un nuovo tipo di StateData viene aggiunto al programma, la logica e quindi il codice in State::IsLessThan(State) dovranno essere modificati.

Supponiamo che la preoccupazione principale qui sia l'estensibilità dell'architettura. Questo può essere migliorato? Mi manca una soluzione migliore?

object-oriented c++ architecture

posta Ryan 19.11.2016 - 23:36

fonte

3 risposte

Leggi altre domande sui tag object-oriented c++ architecture

Concorrenza concomitante C ++ Uso delle classi nidificate per l'input e l'output per un metodo di calcolo

score 4 · Answer 1

Per parafrasare la tua domanda, hai una classe in cui le istanze devono essere in grado di confrontarsi con altre istanze della classe, ma dove i dati contenuti possono variare ed essere estesi in modi inizialmente imprevedibili. Sei preoccupato che i requisiti di comparazione siano difficili da risolvere in modo pulito a causa della variazione dei dati e speri di risolverli facendo in modo che la classe contenga una classe StateData estensibile.

Sfortunatamente, questo è solo spostando il problema da un posto all'altro. Certo, la classe StateData può incapsulare in modo pulito i dati variabili, ma poi devi capire come confrontare le diverse strutture di dati e stai ancora una volta osservando il problema originale.

A meno che non si possano creare regole generali per confrontare i vari dati, ci si troverà in un mondo di dolore una volta proliferate le strutture dei dati. Per me, questa è una strong indicazione del fatto che il tuo design è difettoso; o dovresti porre limiti chiari ai dati da contenere, oppure ripensare l'intera premessa e riorganizzare i dati in modo più pulito e regolare.

score 1 · Answer 2

Gli oggetti complessi vengono generalmente confrontati dai loro membri. Definisci un confronto "minore di" per Set e StateData e confronta gli oggetti contenenti che delega ai loro membri. Non tentare di implementare il confronto di oggetti con una struttura arbitraria, questo di solito causa un'interruzione di associatività.

I confronti degli insiemi sono di solito scarsamente definiti, vorrai essere severo al riguardo. Ad esempio, potresti dire che un Set è inferiore ad un altro Set se tutti i suoi membri sono inferiori a qualsiasi membro di un altro Set.

Per generalizzare, se qualcosa non ha una struttura ben definita, implementa l'operazione come parte della sua interfaccia stabile. Il codice cliente non dovrebbe assolutamente conoscere la sua struttura.

score 0 · Answer 3

How to compare objects with expanding amount of data?

Assicurati che vi sia un ordine chiaramente definito tra i vari tipi (e valori) di dati.

Assume that the main concern here is architecture extensibility.

Per risolvere il problema dell'implementazione di bool IsLessThan(State); , devi risolvere questi problemi separati:

come puoi sapere se un'istanza di StateData è inferiore a un'altra istanza di StateData, quando le istanze hanno tipi diversi
come puoi sapere se un'istanza di SetData è inferiore a un'altra quando poi hanno lo stesso tipo
che cosa significa per due istanze di stato confrontare meno di un anohter, in base al contenuto di un set.

Nessuno di questi ha risposte banali, poiché la risposta dipende dal dominio del problema. Mi sembra anche che tu stia cercando di risolvere il problema sbagliato (x-y) (che di solito significa che hai bisogno di più design / refactoring, o solo di fare un passo indietro e riesaminare quello che stai facendo.

Stai già parlando di comparare oggetti di tipi diversi (specializzazioni di StateData). Questo ha senso semantico per tutte le specializzazioni di StateData? (cioè, se uno dei tuoi StateData ha un'immagine all'interno e l'altro una data del calendario, puoi davvero dire che uno è "più grande" dell'altro?

Can this be improved? Am I missing a better solution?

Sei sicuro di aver risolto il problema corretto?