Vererbung Naming Conventions

KN4CK3R

Hallo,

ich habe im Moment ein paar "Probleme" mich für eine Naming Convention bei "Gruppenvererbungen" zu entscheiden.

Stand bisher:

/
class Module;
class Player;
class PlayerIterator;

/ABC/
class ABCModule : Module;
class ABCPlayer : Player;
class ABCPlayerIterator : PlayerIterator;

/XYZ/
class XYZModule : Module;
class XYZPlayer : Player;
class XYZPlayerIterator : PlayerIterator;

Mich stört daran, dass die vererbten Namen recht lang werden können und dass es irgendwie doppelt gemoppelt ist, dass ich in einer ABC Klasse ständig die Namen der anderen ABC Klassen schreiben muss, obwohl an der Stelle klar ist, dass es sich nur um Klassen von ABC handelt.

Überlegung:

/
namespace Base
{
	class Module;
	class Player;
	class PlayerIterator;
}

/ABC/
namespace ABC
{
	class Module : Base::Module;
	class Player : Base::Player;
	class PlayerIterator : Base::PlayerIterator;
}

/XYZ/
namespace XYZ
{
	class Module : Base::Module;
	class Player : Base::Player;
	class PlayerIterator : Base::PlayerIterator;
}

Die Namespaces finde ich von der Überlegung her sehr sauber, aber im Code gibt es dafür dann Probleme, da man nie wirklich schnell sieht in welcher Datei man eigentlich gerade ist. Auch müsste man die Dateien, die die Klassen beeinhalten umbenennen, da es sonst zu Kollisionen beim Linken kommt, da die *.obj Namen identisch sind.

Kennt ihr eine Lösung, wie man am besten mit sowas umgeht?

Deine Namen sollen die fachliche Eigenheit einer Klasse widerspiegeln, nicht deren technischen Bezug, also z.B.

class Fahrzeug;
class PKW : public Fahrzeug;

alles andere fuehrt zu einer (Ab)Art Ungarischer Notation fuer Klassen.

KN4CK3R

Das ist mir schon klar, aber was heißt das für meinen Fall? Die Klassen ohne Namen können als Interface angesehen werden.

KN4CK3R schrieb:

Das ist mir schon klar, aber was heißt das für meinen Fall? Die Klassen ohne Namen können als Interface angesehen werden.

Also haben die Interfaces keine Zusatzfunktionalität/-schnittstellen gegenüber ihrer Basisklasse!?

class XYZModule : public Module {};

Dann verzichte auf sie. Solche Klassen braucht keiner.

Falls doch haben sie ja Funktionalität und du kannst sie entsprechend benennen.

KN4CK3R

Die Unterklassen haben natürlich Funktionalitäten. Am ehesten lässt sich das ganze vielleicht mit sowas hier vergleichen:

/
class Substantiv;
class Verb;

/Deutsch/
class DeutschSubstantiv : class Substantiv;
class DeutschVerb : class Verb;

/Englisch/
class EnglischSubstantiv : class Substantiv;
class EnglischVerb : class Verb;

Deutsche und Englische Implementierungen würden dann dementsprechende Funktionen implementieren.

knivil

Und wo ist das Problem mit:

namespace basic {
class nomen ...

}

namespace deutsch {

class nomen : basic::nomen ...
}

namespace english {
class nomen : basic::nomen ....

}

KN4CK3R

Wie schon oben geschrieben, würden dann die Dateinamen nicht mehr zu den Klassennamen passen. Um ein wirkliches Problem geht es hier ja auch gar nicht, mehr nach der best practice Frage.

Marthog

Ich finde es albern, über mehrere Namespacegrenzen hinweg zu vererben und würde es eher so machen:

namespace nomen
{ 
    class basic;
    class englisch: basic;
    class deutsch : basic;  
}

Damit hat man die gleiche Funktionalität zusammen in einem Namespace.

KN4CK3R

Ich würde hier aber eher die Gruppenzugehörigkeit bei der Sprache sehen und nicht mehr der Art des Wortes oder nicht?

hustbaer

namer schrieb:

Deine Namen sollen die fachliche Eigenheit einer Klasse widerspiegeln, nicht deren technischen Bezug, also z.B.
class Fahrzeug;
class PKW : public Fahrzeug;
alles andere fuehrt zu einer (Ab)Art Ungarischer Notation fuer Klassen.

Wenn PKW ein Fachbegriff aus der Domäne ist, dann ist es OK.
Sonst würde ich PersonenKraftFahrzeug vorziehen.

Und ich weiss auch nicht was das mit Ungarischer Notation zu tun haben soll. Ist das selbe Prinzip wie im Deutschen Hauptwörer zusammengesetzt werden.
Ist ja kein Zufall dass PersonenKraft Fahrzeug funktioniert.

hustbaer

Marthog schrieb:

Ich finde es albern, über mehrere Namespacegrenzen hinweg zu vererben und würde es eher so machen:
namespace nomen
{ 
    class basic;
    class englisch: basic;
    class deutsch : basic;  
}
Damit hat man die gleiche Funktionalität zusammen in einem Namespace.

Du willst alle Iteratoren in einen Namespace packen, alle Container in einen anderen, alle Streams in den nächsten, alle Exceptions ...?

Also throw Exceptions::FooParser() statt throw Foo::ParserException() ?
Und Iterators::GuiElement it = ... statt Gui::ElementIterator it = ... ?

Das kann ja hoffentlich nur ein Scherz sein.