Pointer to Pointer als konstanter Rückgabewert

Warum kompiliert die zweite Funktion hier nicht?

class Test
{
	int *m_Pointer;
	int **m_P2P;

	const int *GetPointer() const { return m_Pointer; }
		// Funktioniert

	const int **GetP2P() const { return m_P2P; }
		// Funktioniert nicht
};

Er sagt dann

error: invalid conversion from 'int**' to 'const int**'

Was muss ich hier ändern?

Dobi

Hallo Jens,

meinst du vielleicht eigentlich

int * const *GetP2P() const { return m_P2P; }

an Stelle von

const int **GetP2P() const { return m_P2P; }

?

Also was soll bei deinem Konstrukt konstant sein?

Gruß
Dobi

Bei meinem Code soll der Wert, der hinter dem Zeiger liegt, konstant sein, während die Adresse, auf die der Zeiger verweist, nicht konstant sein muss.

Das heißt, bei:

p = test.GetP2P();

soll das hier möglich sein:

p = NULL;
p = new ...;

Aber das hier soll nicht möglich sein:

**p = 23;
*p = NULL

Das heißt, die lokale Variable, die den Zeiger hält, soll veränderbar sein (Wieso auch nicht? Es ist ja nur die lokale Vraible, die auf nichts Außenstehendes Einfluss hat.), aber alles, was tatsächlich den Zustand in der Klasse ändert, soll nicht möglich sein.

Dobi

Falls du mit

p = new ...;

sowas wie

p = new int( 2 );

meintest, wird das nicht gehn.
Dafür müsste p ein int* und kein int** sein.
Ansonsten hörts sich für mich so an als, als wolltest du

const int * const *

Mit den Testzeilen siehts dann so aus:

class Test
{
public:
    const int *GetPointer() const { return m_Pointer; }
    const int * const * GetP2P() const { return m_P2P; }
private:
    int *m_Pointer;
    int **m_P2P;
};

int main()
{
	Test test;
	const int * const *p = test.GetP2P();
	p = 0;
	**p = 23; // error: assignment of read-only location '*(const int*)(* p)'
	*p = 0; // error: assignment of read-only location '* p'
	return 0;
}

Vielleicht sollte man den lustigen Zeigertyp da noch typedeffen.

Ist das eigentlich nur ne Übung zu Zeigern und zum const-Verständnis, oder hast du vor wirklich sowas verwirrendes zu machen?

Das hat tatsächlich praktische Relevanz. Die Zeiger stellen nämlich eigentlich Arrays dar bzw. ein Array auf Arrays. (Und ja, ich weiß, dass es dafür bereits den std::vector-Datentyp gibt, aber in meinem konkreten Fall ist es ein DOS-Programm unter Turbo C++.) Wobei die inneren Arrays jeweils unterschiedlich lang sein können, es ist also kein simples zweidimensionales Array, sondern mehr sowas:

Array von Array von char (3 Einträge)
|
+--Array von char (5 Einträge)
|  |
|  +-- 'A', 'X', 'G', 'F', 'T'
|
+--Array von char (2 Einträge)
|  |
|  +-- 'K', 'W'
|
+--Array von char (4 Einträge)
   |
   +-- 'M', 'Z', 'Z', 'V'

Und hier soll es eben so sein, dass wenn man sich in der main mit GetP2P() den Zeiger auf den Zeiger holt, man nicht in der Lage sein soll, irgendwas in der Klasse zu ändern. Das heißt, man soll nicht das 'K' in ein 'U' umwandeln dürfen, man soll auch nicht das zweite innere Array auf NULL setzen dürfen. Und man darf natürlich auch nicht das äußere Array auf NULL setzen. Was man aber machen kann: Man darf seinen lokalen Zeiger auf NULL setzen, denn das würde ja den Inhalt der Klasse nicht beeinflussen.

Unter diesen Voraussetzungen: Ist const T * const * die richtige Wahl?

Dobi

Japp.
Gar keine Zeiger rausgeben und sattdessen Funktionen zum Elementzugriff anbieten geht nicht?