Herzlich Willkommen, lieber Gast!
  Sie befinden sich hier:

  Forum » C / C++ (ANSI-Standard) » Future of C++

Forum | Hilfe | Team | Links | Impressum | > Suche < | Mitglieder | Registrieren | Einloggen
  Quicklinks: MSDN-Online || STL || clib Reference Grundlagen || Literatur || E-Books || Zubehör || > F.A.Q. < || Downloads   

Autor Thread - Seiten: [ 1 ] > 2 < [ 3 ]
010
03.12.2002, 14:52 Uhr
Bruder Leif
dances with systems
(Operator)



Zitat:
void* postete
Und wo liegt dann der Vorteil von Interfaces?
Ich kann das so ja auch in C++ verwirklichen, oder?
Aber wozu die Sprache unnötig einschränken?



Tja, angeblich müssen die dummen Programmierer vor sich selbst geschützt werden... das ist IMO das Hauptargument für interfaces. Vielleicht hab ich mich aber auch nur zu wenig damit beschäftigt?
--
Mit 40 Fieber sitzt man nicht mehr vor dem PC.
Man liegt im Bett.
Mit dem Notebook.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
011
03.12.2002, 14:55 Uhr
void*
Generic Pointer
(Operator)


Wenn das das Argument ist...Interfaces nein, danke. Aber vielleicht erzählt uns virtual noch mehr?!
--
Gruß
void*
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
012
03.12.2002, 15:06 Uhr
virtual
Sexiest Bit alive
(Operator)


Final Classes bedeutet, dass du nicht mehr von ihnen ableiten darfst. Auch wenn es eh schlechter Stil ist, verbietet Dir C++ nicht, von einem STL Container abzuleiten:

C++:
// Achtung: Böser code:
class Filepath: public std::string
{
};


Schlechter Stil ist es aus gründen des Designs. Falscher Code ist es, weil std::string keinen virtuellen Destructor hat und damit bei der Destruction einen Filepath der Speicher des Strings nicht freigeben kann. Das Problem: C++ meckert das noch nicht mal als Fehler an, höchstens als Warnung, wenn du einen guten Compiler hast.

Anonyme Klassen sind Klassen, die man bei der Instanziierung ableiten kann, in C++ gibt es das nicht, aber eine entsprechende Syntax könnte so aussehen:

C++:
//  Normale Klasse
class X
{
     ...
     virtual void method() { std::cout << "X::method()" << std::endl; };
};

void f()
{
   X* = new X(...) {
       // Überschreibe on-the-fly
       void method() { std::cout << "anonym::method()" << std::endl; };
   };
}


Man bracht also nicht immer gleich das ganze geraffel mit Klassendeklaration und definition, sondern kann - bei einfachen Ableitungen - mal eben schnell was ableiten.

Interfaces:
Es gibt Analogien zwischen Interfaces und Mehrfachvererbung. Allerdings würde ich aus Desgnsicht sagen, daß es unterschiede zwischen Klassen und Interfaces gibt. Eine Klasse ist etwas, was man Instanziieren kann (es sei denn es ist abstrakt). Ein Interface ist eine Schnittstellenvereinbarung. Ich finde, daß Interfaces eine bessere Granularität als Klassen haben: eine Klasse hat naturgemäß verschiedene Interfaces. Ein String hat zB Funktionsgruppen zur Abfrage des Stringinhalte, zur Serialisierung, zur Manipulation des Inhalts usw. Bei gut gewählten, hinreichend abstrakt formulierten Interfaces würde ich annehmen, daß man mit Interfaces klarer designen kann als mit Klassen.
Java kommt übrigens komplett ohne merhfachvererbung aus, benutzt stattdessen sehr intensiv das Interface Feature. Und da muß ich sagen, daß sich insbesondere bei komplexeren Anwendungen ein klareres, leichter verständliches Design entwickeln läßt. Ist aber natürlich nur meine persönliche Ansicht.
--
Gruß, virtual
Quote of the Month
Ich eß' nur was ein Gesicht hat (Creme 21)
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
013
03.12.2002, 15:11 Uhr
virtual
Sexiest Bit alive
(Operator)


Ach, noch ein kleiner Nachtrag:
ich fände ein Protection level nach der devise "readonly" ganz okay:

C++:
class X
{
readonly:
     int y; // Darf ausserhalb von X gelesen, aber nicht geschrieben werden
};


OO Puristen werden natürlich sagen: da muß man halt einen Getter für schreiben, weil man ja die Details der implementierung verbergen möchte, aber bei einigen Klassen fände ich das schon okay.
--
Gruß, virtual
Quote of the Month
Ich eß' nur was ein Gesicht hat (Creme 21)
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
014
03.12.2002, 15:18 Uhr
void*
Generic Pointer
(Operator)


1. Das mit den Final Classes hört sich gut an. Kann wie z.B. const, logische bzw. Design-Fehler verhindern. Wäre wohl auch einfach in die Sprache zu intergrieren.

2. Kannst Du mal ein sinnvolles Anwendungsbsp. für anonyme Klassen geben? Ist für mich nicht ganz offensichtlich.

3. Kann ich nicht einfach abstrakte Klassen als Interfaces betrachten?

4. Dann bin ich wohl ein OO Purist!?
--
Gruß
void*
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
015
03.12.2002, 15:57 Uhr
virtual
Sexiest Bit alive
(Operator)


ad 2:
Stell Dir nicht zuviel darunter vor, es verkürzt die Sache einfach nur: eine Anonyme Klasse in Java ist stets auch als normale Klasse denkbar. Das wohl typische Anwendungsbeispiel in Java sind Event Listener; sowas gibt es nicht in C++ (jedenfalls nicht in Standard). Ein Listener kann man zB an eine Listbox oder jede beliebige GUI omponente dran hängen und damit der GUI Componente sagen: Bitte rufe eine bestimmte Methode dieses Listener auf, wenn eine Aktion passiert. zB würdest Du bei einem Button dich dafür interessieren, ob grade der Button gedrückt wird. Für diesen Zweck gibt es einen bestimmten Listener, einen ActionListener, der dafür geschaffen ist.
Nun wird man naturgemäß in seiner Anwendung viele Buttons haben und jeder soll was anderes tun, also muß auch die Methode, die aufgerufen wird, irgendwie spezialisert werden. Wenn ich einen solchen Listener in C++ hätte (so designen kann man das auch hier), müsste ich also recht viel schreiben, nur um eine einzige Methode zu überschreiben. Mit dem Konzept der Anoynmen Klasse kann ich mir da so einiges an (langweiliger) Tipparbeit einfach sparen und direkt die Methode überschreiben, ohne die Klasse explizit abzuleiten. Ein angenehmer Nebeneffekt ist, daß solche Listener Objekt auch nicht mehr im Klassen Header auftauchen, der dadurch deutlich schlanker würde.

ad3:
Ich finde Nein. UML Unterscheidet auch zwischen Interface und Klasse, COM ebenfalls. Es sind Apfel und Birne. (Sowohl COM alsauch UML verwenden das Interface/Klassen Begriffspaar wie in Java auch).

ad4:
Kann ich letztlich nicht beurteilen. Mein Bauchgefühl sagt mir: nein, denn sonst dürftest Du nicht in C++ programmieren, was einfach nur zu sehr an C hängt, um Puristentauglich zu sein.
--
Gruß, virtual
Quote of the Month
Ich eß' nur was ein Gesicht hat (Creme 21)
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
016
03.12.2002, 16:24 Uhr
void*
Generic Pointer
(Operator)


3. Warum nicht
interface == abstrakte Klasse
Klasse == Klasse
???
Das Sprachmittel in C++ ist bloss flexibler, 2 Namen für das gleiche Dinge, oder?

4. Ok, dann bin ich kein OO Purist... ...aber dann spar Dir Dein überflüssiges Sprachmittel und schreib dir eine Get-Methode!
--
Gruß
void*
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
017
03.12.2002, 17:05 Uhr
virtual
Sexiest Bit alive
(Operator)


ad 3:
Guck Dir doch einfach mal in der MSDN an, was die Jungs bei COM unter Interface verstehen und was sie für eine Klasse halten. Kommt wie gesagt dem recht nahe, was in Java abgeht. Eine Klasse ist die Summe 1..N Interfaces.

ad4:
Wird gemacht, Chef
--
Gruß, virtual
Quote of the Month
Ich eß' nur was ein Gesicht hat (Creme 21)
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
018
03.12.2002, 17:29 Uhr
Bruder Leif
dances with systems
(Operator)


@get-Methode: Da wäre mir das Property-Konzept wieder lieber ;-) Zum Beispiel so:


C++:
public int Width  // Nach außen sichtbar wie eine public-int-Variable
   {
      get  // Mini-Methode, wird beim auslesen aufgerufen
      {
         return m_iWidth;
      }
      set  // Entsprechend fürs beschreiben
      {
         if(value < 0 || value > 999)
            throw "Ungültige Breite";
         m_iWidth = value;
      }
   }



So sieht das z.B. in C# aus. Width wird angesprochen wie eine public-Variable, nur daß beim beschreiben der neue Wert überprüft wird. Und wenn die set-Methode weggelassen wird, ist das Teil automatisch ReadOnly.
--
Mit 40 Fieber sitzt man nicht mehr vor dem PC.
Man liegt im Bett.
Mit dem Notebook.

Dieser Post wurde am 03.12.2002 um 17:29 Uhr von Bruder Leif editiert.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
019
03.12.2002, 18:24 Uhr
virtual
Sexiest Bit alive
(Operator)


Gott sei mit Dir, Bruder Leif; denn dies dünkt mir ein wahrhaft gutes Konzept zu sein, bei welchem auch OO Puristen sich auf dem rechten Pfad der Tugend wähnen werden!
--
Gruß, virtual
Quote of the Month
Ich eß' nur was ein Gesicht hat (Creme 21)
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
Seiten: [ 1 ] > 2 < [ 3 ]     [ C / C++ (ANSI-Standard) ]  


ThWBoard 2.73 FloSoft-Edition
© by Paul Baecher & Felix Gonschorek (www.thwboard.de)

Anpassungen des Forums
© by Flo-Soft (www.flo-soft.de)

Sie sind Besucher: