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?

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

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.

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?

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?