Privater Pointer ?



  • Hallo Leute , ich habe mal wieder eine kurze Frage .
    Nehmen wir mal an ich habe eine Klasse mit der folgenden Member Variable.

    class A
    {
    private:   
    char *bla;
    public:
    char *getBla()
    {
    return bla;
    };
    }
    

    Ist nun der Inhalt der Variablen selbst also die Adresse privat ?
    Oder ist der Inhalt Privat auf den der Pointer verweist ?
    Oder ist sogar beides privat ?

    Es wäre super wenn mich da mal jemand aufklären könnte .

    Mfg



  • beides

    aber char* ist ein schlechtes beispiel weil es ja einen string darstellt

    bei anderen datentypen wäre nur die addresse wo der pointer drauf zeigt privat

    (merke int *p; merkt sich die addresse einer anderen variable)



  • Das heißt dass nur bei einem char * , inhalt und inhalt der Adresse auf die gezeigt wird private sind und bei einem int * nur der Inhalt des Pointers selbst ?

    Habe ich das jetzt richtig verstanden ?



  • Speicher an sich kann nicht privat sein, Zugriffsspezifizierer beziehen sich immer auf Symbole wie Variablen, Typen oder Funktionen.

    In deinem Beispiel ist also jegliche Verwendung von A::bla ausserhalb der Klasse verboten, aber über eine Indirektion kannst du dennoch auf den Speicher (d.h. den Zeiger selbst oder den char dahinter) zugreifen.



  • Was verstehst du unter privat? Das dient letztendlich nur der Kapselung.

    Was du vielleicht suchst ist const



  • Was soll den "Inhalt ist privat" bedeuten? Wenn man keinen Zugriff auf den Pointer hat, kann man diesen natürlich auch nicht dereferenzieren um an den Inhalt zu kommen. Das heißt aber nicht das der Inhalt dieser Adresse irgendwie geschützt ist.



  • Mit "private", "public" (etc) steuerst Du die "Zugriffskontrolle". Die Zugriffskontrolle bezieht sich auf den Namen von dem, was Du deklarierst/definierst. Ob das nun ein Zeiger ist oder nicht, spielt keine Rolle.



  • Vielen dank , das beantwortet meine Frage .

    Wäre folgender Zugriff also möglich oder nicht ?
    Wir nehmen einfach mal an dass ein korrekter C'tot ebenso wie ein D'tor implementiert worden sind .:D

    A instance("name");
    char * a = instance.getName();
    *a = "bbbb";
    


  • denke ja...

    das ist ja das thema (manchmal ganz lustig zu nutzen) dass man eine variable und ihren inhalt versteckt, aber dann per zeiger wieder von ausserhalb drauf zugreift



  • Bacid90210 schrieb:

    Vielen dank , das beantwortet meine Frage .

    Wäre folgender Zugriff also möglich oder nicht ?
    Wir nehmen einfach mal an dass ein korrekter C'tot ebenso wie ein D'tor implementiert worden sind .:D

    A instance("name");
    char * a = instance.getName();
    *a = "bbbb";
    

    Bei solchen Schweinereien sollte man immer schön auf Objekt-Verantwortung achten.
    Wenn "name" im Kontruktor kopiert wird, dann hasse schnell mal nen Memory-Leak
    oder delete eines Stack-Objektes...

    Lass solche design-technisch schmutzigen Sachen lieber sein.
    Implementier einen Setter und alles ist gut.
    Wenn du externe Klasse hast, die so einen Setter nicht zur Verfügung stellt,
    solltest du dich fragen, warum es so ist...

    Gruß,
    XSpille



  • Bacid90210 schrieb:

    A instance("name");
    char * a = instance.getName();
    *a = "bbbb";
    

    *a ist ein char, "bbbb" ist ein const char * const.

    *a = "bbbb";
    

    dürfte Dir also um die Ohren fliegen.

    *a = 'b';
    

    sollte gehen. (sofern Dein Ctor korrekt ist)



  • Dass das programmiertechnisch nicht sauber ist war mir ja klar 😃 ..
    Es ging mir eigentlich nur darum zu verstehen was denn jetzt wirklich private ist.

    Dankeschön für die schnellen Antworten .
    Ein tolles Forum ist das hier 😃



  • Bacid90210 schrieb:

    Es ging mir eigentlich nur darum zu verstehen was denn jetzt wirklich private ist.

    class A
    {
     public:
      int x;
    };
    
    class B
    {
     private:
      int x;
    };
    
    int main()
    {
     A a;
     a.x = 10; // Okay, da public
    
     B b;
     b.x = 100; // Error, da private
    }
    


  • class A
    {
    	private:  
    		char *bla;
    	public:
    		const char* getBla()
    		{
    			return bla;
    		}
    };
    
    int main(int argc, char* argv[])
    {
    	A a;
    	char* b = a.getBla(); //Fehler const char* kann nicht in char* umgewandelt werden
    	const char* c = a.getBla();
    
    	*c = '\0'; //Fehler da die Variable const ist
    
    	return 0;
    }
    

Log in to reply