namespace, class und struct benutzen oder alles class?

Peanut

Ich erwische mich leider dabei einfach pauschal alles in Klassen zu packen.
Ein struct wird so einfach zu einer
class xxx{ public: ...}
und wenn ich sehe das ich einige Objekte nur anlege um eine Methode darin aufzurufen, könnte ich prinzipiell auch einen Namespace verwenden.

Meine Frage ist nun eher estehtischer Natur: Ist dieser Klassen-Fetisch nun streng verwerflich oder fällt es in die "nicht so schlimm" Kategorie? Sollte ich meine Klassen also überdenken und ggf. "umbennenen" oder kann ich das guten Gewissens so lassen und gelobe für die Zukunft besserung?

Besten Dank!
Peanut

Shade Of Mine

Ein Klasse solltest du nur dann machen, wenn du eine Klasse brauchst.

Notfalls kannst du dir ja mit UML helfen - denn modelling ist in der Objekt Orientierten Programmierung sehr wichtig.

HumeSikkins

Hallo,
class und struct nicht zu unterscheiden, scheint mir nur ein geschmackliches Problem zu sein. Es gibt ja schließlich keinen wirklichen Unterschied in der Sprache.

Namensräume und Klassen sind aber sowohl aus Sicht der Sprache, als auch konzeptionell zwei völlig verschiedene Dinge. Wenn man die sorglos durcheinanderwirft hilft kein lapidares "ich gelobe Besserung" sondern die Lektüre eines *guten* C++ Buches.

Peanut

Original erstellt von HumeSikkins:
class und struct nicht zu unterscheiden, scheint mir nur ein geschmackliches Problem zu sein. Es gibt ja schließlich keinen wirklichen Unterschied in der Sprache.

OK.

Original erstellt von HumeSikkins:
**
Namensräume und Klassen sind aber sowohl aus Sicht der Sprache, als auch konzeptionell zwei völlig verschiedene Dinge. Wenn man die sorglos durcheinanderwirft hilft kein lapidares "ich gelobe Besserung" sondern die Lektüre eines *guten* C++ Buches.**

Folgendes Beispiel, Namespace oder Klasse?

typedef std::vector< std::vector< std::string > > table;

class UserDB{
  private:
    /// connection pool object to get databaseconnection.
    static DB* db;
    /// load session date from database
    void loadSession(UserDBEntry& user);
  public:
    /// restore User by User-ID and Password.
    User* restore( std::stringi& _uid, std::string& _pass);
    /// restore User by session-ID.
    User* restore( std::string& _sid );
    /// insert or update User.
    bool store( UserDBEntry& user );
    /// get table of Clients.
    table UserDB::getClientFor( UserDBEntry& user );
    /// default constructor, get Database if not already there.
    UserDB(){
      if ( db==NULL ){
        Config conf("auth");
        db = new DB (conf["db"]);
      }  
    };
    /// default destructor ( empty ).
    virtual ~UserDB();
    /// Exceptionclass for UserDB-class.
    class Error : public std::exception{
      /// reason for this exception.
      std::string reason;
      public:
        /// constructor with or without reason.
        Error( std::string _reason="" ) : reason(_reason) {};
        /// destructor ( empty )
        ~Error() throw() {};
        /// overloaded method from std::exception to give reason.
        virtual const char* what () const throw() { return reason.c_str (); }
    };
};

Ich würde sagen:
-Nur Methoden und statische Elemente-> Namespace
-Constructor wird benutzt -> Klasse
-Anwendung: UserDB db; db.store(this); ~db -> Namespace

aber der Zugriff auf die Datenbank der hier durch

static DB* db;

erreicht wird war ursprünglich durch eine Erbschaft von DB realisiert und das geht nur mit Klassen.

Bin ich ganz auf dem Holzweg???

Edit: Quoting korrigiert.

[ Dieser Beitrag wurde am 24.06.2003 um 11:32 Uhr von Peanut editiert. ]