am anfang lesen sich klassen ja wunderbar.
man macht eine public klasse, füllt sie mit werten und greift dann später darauf zu.

doch, warum soll man nun seine klasse privat machen? laut meinen sehr schlauen buch wegen "sicherheit". in ordnung.

nun geht es mit den klassen munter weiter: in die klasse wird in diesem schlauen buch nun immer eine funktion gesetzt (eine selbstdefinierte), um auf die privat - bereiche der klasse zugreifen zu können.

ab hier setzt es bei mir aus - kann mir jemand erklären, wie funtionen sinnvoll darauf zugreifen sollen und wie sie das tun?

*dankend*
tuxinator

doch, warum soll man nun seine klasse privat machen? laut meinen sehr schlauen buch wegen "sicherheit". in ordnung.

Nunja, Sicherheit ist vielleicht nicht der wirklich relevante Ausdruck dafür -> Datenkapselung.

Ein einfaches Beispiel:

class point {

    private:

        int x;
        int y;

    public:

        // Standard c-tor:
        point( );

        // Standard d-tor:
        ~point( );

        void set_x( int x_to_set );
        void set_y( int y_to_set );
        void set_xy( int x_to_set, int y_to_set );

        int get_x( );
        int get_y( );
};

point::point( ) : x( 0 ), y( 0 )
{
}

point::point( int x_to_set, int y_to_set ) : x( x_to_set ), y( y_to_set )
{
}

point::~point( )
{
}

void point::set_x( int x_to_set )
{
    x = x_to_set;
}

void point::set_y( int y_to_set )
{
    y = y_to_set;
}

void point::set_xy( int x_to_set, int y_to_set )
{
    set_x( x_to_set );
    set_y( y_to_set );
}

int point::get_x( )
{
    return x;
}

int point::get_y( )
{
    return y;
}

...aber sollte das nicht in deinem Buch stehen?

Greetz, Swordfish

eigentlich macht man nicht (jedenfalls nicht hauptsächlich) Klassen public oder private, sondern die Mitglieder der Klassen, das wiederum können Methoden, Variablen oder weitere Klassen sein.

Also gut, warum macht man Variablen private und schreibt Zugriffsmethoden? Hm, das nennt sich Datenkapselung. Wozu? Der Benutzer sieht nur die Schnittstelle (also die Methoden). Was innen drin vorgeht, geht ihn nix an. Die Innereien können dann auch ausgetauscht werden, ohne dass die Schnittstelle geändert werden muss.

Zusätzlich bieten Zugriffsmethoden natürlich eine gewisse Sicherheit, denn man kann Abfragen einbauen, ob der neue Wert für Variable x wirklich gut ist, oder ob der Benutzer gerade Mist eingegeben hat. Außerdem erhöht es die Übersichtlichkeit, da der Benutzer der Klasse nur die öffentliche Schnittstelle kennen und benutzen muss.

All das ermöglicht Datenkapselung.

MfG

GPC

class String
{
 private:
  char* str;
 public:
  String( const char* str_ )
  {
     unsigned len = strlen( str_ );
     str = new char[ len + 1 ];
     strcpy( str, str_ );
  }

  unsigned length() const //liefert die Länge des Strings zurück
  {
     return strlen( str );
  }  
};

Das ganze ist so jetzt nicht optimal, deshalb beschließen wir (die Autoren der Klasse) die Länge intern zu speichern, wodurch length die Länge nicht mehr berechnen muss

class String
{
 private:
  char* str;
  unsigned len;
 public:
  String( const char* str_ )
  {
     len = strlen( str_ );
     str = new char[ len + 1 ];
     strcpy( str, str_ );
  }

  ~String()
  {
     delete[] str;
  }

  unsigned length() const //liefert die Länge des Strings zurück
  {
     return len;
  }  
};

Das ist jetzt nur nen Minimalbeispiel aber die Kapselung ist alles worum es sich in der Objektorientierten Programmierung dreht.