class Screen{
public:
      typedef std::string::size_type pos;
private:
      pos cursor = 0;
      pos height = 0, width = 0;
      std::string contents;
};

Ich habe versucht, eine Instanz von Screen zu erstellen. Keiner kann auf pos zugreifen. Ich kenne übrigens die Zugangskontrolle. Ich möchte nur die Bedeutung der Zugriffskontrolle für ein Typmitglied kennen.

c++
0
Rick 18 Apr. 2018 im 05:39

5 Antworten

Beste Antwort

Öffentlich bedeutet, dass jeder (andere Klassen) diese Variablen berühren kann. Privat bedeutet, dass nur Sie (Ihre Methoden) diese Variablen berühren können.

Es gibt eine Einschränkung, die "Freunde" einführt, die einer Funktion oder Klasse, die nicht Sie sind, Zugriff auf alle Variablen gewähren.

Elementtypen und Elementvariablen funktionieren auf dieselbe Weise. Ein privater Typ ist nicht über die Methoden und Freunde einer Klasse hinaus verfügbar, nur als private Methode oder Variable. Umgekehrt ist ein öffentlicher Typ, eine öffentliche Methode oder eine öffentliche Variable für jedermann zugänglich. Im Gegensatz zu (nicht statischen) Methoden und Variablen müssen Typen statisch sein.

Dies kann beispielsweise nicht kompiliert werden, da pos privat ist.

#include <string>
class Test {
  private:
    using pos = std::string::size_type;
  public:

};

int main(int argc, char *argv[])
{
  Test::pos a = 5;

  return 0;
}

Um von außerhalb der Bildschirmklasse auf den Typ pos zuzugreifen, verschieben Sie zuerst den Typedef in die öffentliche Barrierefreiheit. Dann ist es mit screen::pos verfügbar, genau wie mit einer statischen Methode oder Variablen.

Das Folgende sollte zwar einwandfrei kompiliert werden (möglicherweise eine Warnung, dass a nicht verwendet wird, aber das ist ein anderes Problem.)

#include <string>
class Test {
  public:
    using pos = std::string::size_type;    
};

int main(int argc, char *argv[])
{
  Test::pos a = 5;

  return 0;
}

Sie können damit ein bisschen verrückt werden und sogar eine ganze Klasse intern als öffentlich oder privat definieren.

3
Evan 18 Apr. 2018 im 05:54

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
0
Muhammad Usman 18 Apr. 2018 im 03:46

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

0
bashrc 18 Apr. 2018 im 03:58

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.

0
Joseph D. 18 Apr. 2018 im 04:02

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.

0
Rick 18 Apr. 2018 im 05:02