Was ist der Unterschied zwischen der Definition eines Klassentypmitglieds als öffentlich und privat?

Quelle: https://www.tutorialspoint.com/cplusplus/cpp_class_access_modifiers.htm

Die öffentlichen Mitglieder

Ein öffentliches Mitglied ist von überall außerhalb der Klasse, aber innerhalb eines Programms zugänglich. Sie können den Wert öffentlicher Variablen ohne Elementfunktion festlegen und abrufen, wie im folgenden Beispiel gezeigt:

Code:

#include <iostream>

using namespace std;

class Line {
   public:
      double length;
      void setLength( double len );
      double getLength( void );
};

// Member functions definitions
double Line::getLength(void) {
   return length ;
}

void Line::setLength( double len) {
   length = len;
}

// Main function for the program
int main() {
   Line line;

   // set line length
   line.setLength(6.0); 
   cout << "Length of line : " << line.getLength() <<endl;

   // set line length without member function
   line.length = 10.0; // OK: because length is public
   cout << "Length of line : " << line.length <<endl;

   return 0;
}

Ausgabe des obigen Codes:

Length of line : 6
Length of line : 10

Die privaten Mitglieder:

Auf eine private Mitgliedsvariable oder -funktion kann nicht zugegriffen oder von außerhalb der Klasse angezeigt werden. Nur die Klassen- und Freundfunktionen können auf private Mitglieder zugreifen.

Standardmäßig sind alle Mitglieder einer Klasse privat. In der folgenden Klassenbreite wird beispielsweise ein privates Mitglied angezeigt. Bis Sie ein Mitglied kennzeichnen, wird davon ausgegangen, dass es sich um ein privates Mitglied handelt:

class Box {
   double width;

   public:
      double length;
      void setWidth( double wid );
      double getWidth( void );
};

In der Praxis definieren wir Daten im privaten Bereich und verwandte Funktionen im öffentlichen Bereich, damit sie von außerhalb der Klasse aufgerufen werden können, wie im folgenden Programm gezeigt.

Code

#include <iostream>

using namespace std;

class Box {
   public:
      double length;
      void setWidth( double wid );
      double getWidth( void );

   private:
      double width;
};

// Member functions definitions
double Box::getWidth(void) {
   return width ;
}

void Box::setWidth( double wid ) {
   width = wid;
}

// Main function for the program
int main() {
   Box box;

   // set box length without member function
   box.length = 10.0; // OK: because length is public
   cout << "Length of box : " << box.length <<endl;

   // set box width without member function
   // box.width = 10.0; // Error: because width is private
   box.setWidth(10.0);  // Use member function to set it.
   cout << "Width of box : " << box.getWidth() <<endl;

   return 0;
}

Ausgabe des obigen Codes:

Length of box : 10
Width of box : 10

Denn obwohl Ihr typedef öffentlich ist, wird das tatsächliche Mitglied als privat deklariert. Weitere Informationen finden Sie unter Zugriffsspezifizierer für C ++ - Klassen.

Von class.access # 4

Weil die Zugriffssteuerung für Namen gilt, wenn die Zugriffssteuerung angewendet wird zu einem typedef-Namen nur die Zugänglichkeit des typedef-Namens selbst gilt als. Die Zugänglichkeit der Entität, auf die sich die typedef wird nicht berücksichtigt.

class A {
  class B { };
public:
  typedef B BB;
};

void f() {
  A::BB x;          // OK, typedef name A​::​BB is public
  A::B y;           // access error, A​::​B is private
}

Dies bedeutet also nicht, dass Ihr Typ öffentlich ist, sodass die Mitgliedsvariable öffentlichen Zugriff hat. typedef dient zum Benennen von Typen nicht zum Festlegen des Zugriffs eines Mitglieds.

Das Typelement unterscheidet sich vom Datenelement. Es ist eher ein statisches Zeug, auf das ich über eine Instanz nicht zugreifen kann. Definieren Sie es also als öffentlich oder privat und entscheiden Sie, ob ich über Screen::pos darauf zugreifen kann. Das ist es.