Come viene chiamata questa struttura / modello simile a "interfaccia"? [chiuso]

Question

Come viene chiamata questa struttura / modello simile a "interfaccia"? [chiuso]

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

1

Supponiamo di avere una classe XmlDoc che contiene funzionalità di base per gestire una struttura dati XML e salvare / caricare dati da / verso un file. Ora abbiamo diverse sottoclassi, A , B e C . Tutti ereditano da XmlDoc e aggiungono metodi specifici dei componenti per l'impostazione e l'acquisizione di molti dati. Sono come "interfacce" ma aggiungono anche un'implementazione per le firme.

Infine, abbiamo una classe ABCDoc che unisce tutte le "interfacce" tramite ereditarietà multipla virtuale e aggiunge un po 'di materiale specifico di ABCDoc , come l'uso di XMLDoc -methods per impostare un tipo di documento appropriato. Potremmo anche avere una classe ADoc per il solo salvataggio dei dati di A .

Come si chiama questo modello? "Interfaccia" non è la parola giusta in quanto le interfacce di solito non contengono un'implementazione.

Punti bonus per le convenzioni del codice C ++.

interfaces c++ terminology

posta Sebastian Negraszus 15.11.2011 - 17:45

fonte

2 risposte

Leggi altre domande sui tag interfaces c++ terminology

Creazione di una libreria che richiede altre librerie (PHP) Qual è il modo migliore per inserire un intervallo di valori in una struttura dati

score 2 · Answer 1

Si chiama " Diamond Problem " oppure, se non è un problema per te, puoi eliminare il "Problema" " parte. Il problema è, come risolvete quale metodo ereditato viene chiamato dalla classe derivata? È possibile eseguire l'override delle chiamate di funzione, ma in questo modo si utilizza l'ereditarietà solo come interfaccia. Se lo fai, perché non creare classi astratte che non ereditano dalla classe "master", quindi componi le tue nuove classi usando l'ereditarietà multipla?

score 0 · Answer 2

Eredità multipla.

Forse quello che stai illuminando è il fatto che tutte le classi base per ABCDoc, sono anche sottoclassi della stessa classe base, e non gerarchie di classi diverse.

In realtà, penso che sia una combinazione di 2 tecniche, in primo luogo, estendendo una classe base per diversi casi:

.................................................................................................................
.................................................................................................................
....+-----------------------------------------+................+----------------------------------------------+..
....|                <<class>>                |....../|........|                   <<class>>                  |..
....|             GenericDocument             |...../.|...+----|                  TextDocument                |..
....+-----------------------------------------+----<..|---+....+----------------------------------------------+..
....| [+]  Load(...)         <<virtual>>      |.....\.|...|....| [+]  Load(...)                 <<override>>  |..
....| [+]  Save(...)         <<virtual>>      |......\|...|....| [+]  Save(...)                 <<override>>  |..
....| [+]  DoSomething(...)  <<non virtual>>  |...........|....| [+]  SpecificMethod_A(...)  <<non virtual>>  |..
....+-----------------------------------------+...........|....+----------------------------------------------+..
..........................................................|......................................................
..........................................................|....+----------------------------------------------+..
..........................................................|....|                  <<class>>                   |..
..........................................................|----|                BitmapDocument                |..
..........................................................|....+----------------------------------------------+..
..........................................................|....| [+]  Load(...)                 <<override>>  |..
..........................................................|....| [+]  Save(...)                 <<override>>  |..
..........................................................|....| [+]  SpecificMethod_B(...)  <<non virtual>>  |..
..........................................................|....+----------------------------------------------+..
..........................................................|......................................................
..........................................................|....+----------------------------------------------+..
..........................................................+----|                   <<class>>                  |..
...............................................................|                  XMLDocument                 |..
...............................................................+----------------------------------------------+..
...............................................................| [+]  Load(...)                 <<override>>  |..
...............................................................| [+]  Save(...)                 <<override>>  |..
...............................................................| [+]  SpecificMethod_C(...)  <<non virtual>>  |..
...............................................................+----------------------------------------------+..
.................................................................................................................
.................................................................................................................

Secondo, avere una singola classe che incapsula tutti gli scenari esistenti.

..........................................................
..........................................................
....+----------------------------------------------+......
....|                   <<class>>                  +---+..
....|                  TextDocument                |...|..
....+----------------------------------------------+...|..
....| [+]  Load(...)                 <<override>>  |...|..
....| [+]  Save(...)                 <<override>>  |...|..
....| [+]  SpecificMethod_A(...)  <<non virtual>>  |...|..
....+----------------------------------------------+...|..
.......................................................|...................................................................
....+----------------------------------------------+...|.../|.....+-----------------------------------------------------+..
....|                  <<class>>                   |...|../.|.....|                       <<class>>                     |..
....|                BitmapDocument                |---+-<..|-----|                 MultipleFormatDocument              |..
....+----------------------------------------------+...|..\.|.....+-----------------------------------------------------+..
....| [+]  Load(...)                 <<override>>  |...|...\|.....| [+]  Load(...)                        <<override>>  |..
....| [+]  Save(...)                 <<override>>  |...|..........| [+]  Save(...)                        <<override>>  |..
....| [+]  SpecificMethod_B(...)  <<non virtual>>  |...|..........| [+]  SelectDefaultFileFormat(...)  <<non virtual>>  |..
....+----------------------------------------------+...|..........+-----------------------------------------------------+..
.......................................................|...................................................................
....+----------------------------------------------+...|..
....|                  <<class>>                   +---+..
....|                 XMLDocument                  |..
....+----------------------------------------------+..
....| [+]  Load(...)                 <<override>>  |..
....| [+]  Save(...)                 <<override>>  |..
....| [+]  SpecificMethod_C(...)  <<non virtual>>  |..
....+----------------------------------------------+..
......................................................

Ho un caso simile. Una classe è composta da diverse classi base, che deve discendere dalla stessa classe, anche.

Penso che ci siano 2 situazioni di questi. Se le classi di base intermedie, possono essere considerate per aggiungere più classi ("più formati di file"), forse la classe finale dovrebbe essere cambiata in questo modo:

........................................................................................................................
....+-----------------------------------------+......./|......+-----------------------------------------------------+...
....|                <<class>>                |....../.|......|                       <<class>>                     |...
....|             GenericDocument             |-----<..|------|                 MultipleFormatDocument              |...
....+-----------------------------------------+......\.|......+-----------------------------------------------------+...
....| [+]  Load(...)         <<virtual>>      |.......\|......| [+]  Load(...)                        <<override>>  |...
....| [+]  Save(...)         <<virtual>>      |...............| [+]  Save(...)                        <<override>>  |...
....| [+]  DoSomething(...)  <<non virtual>>  |...............| [+]  SelectDefaultFileFormat(...)  <<non virtual>>  |...
....+------------------+----------------------+...............+-----------------------------------------------------+...
.......................|.................................................................^..............................
.......................|................................................................/.\.............................
.......................^.............................................................../...\............................
....................../.\..............................................................\.../............................
...................../...\..............................................................\./.............................
..................../-----\..............................................................V..............................
.......................+.................................................................|..............................
.......................|.................................................................|..............................
.......................|.......................................+-------------------------+---------------------------+..
.......................+---------------------------------------|                       <<class>>                     |..
...............................................................|                   <<Many classes>>                  |..
...............................................................+-----------------------------------------------------+..
...............................................................| [+]  Load(...)                        <<override>>  |..
...............................................................| [+]  Save(...)                        <<override>>  |..
...............................................................+-----------------------------------------------------+..
........................................................................................................................

Dove può supportare diverse classi di formati di file come "add-on".

C'è una seconda situazione.

Nella mia app. la classe finale discende da 4 classi specifiche, Dovevo avere accesso ai metodi specifici di quelle classi intermedie, e per aggiungere più classi non si applicava. E le 4 classi intermedie, doveva essere discendente della stessa base o della stessa classe root.

Se era un'altra lingua, quello supportava più interfacce di ereditarietà, forse tutte queste soluzioni potrebbero essere più semplici.

Ma, per il secondo caso, "odoro", un Design Pattern senza nome.