ich weiß, braucht man nicht unbedingt, dennoch würde ich
gerne wissen, wie ich nun in der entsprechenden Initialisierungs-
stelle das Array mit 0 - 19 füllen kann.

So wie es jetzt ist steht natürlich überall 20 drin, weil
jeder pointer auf i zeigt:

#include <iostream>
#include <stdio.h>

using namespace std;

class Test
{
	public:
		int** ptr;
		Test(int** ptr);
		~Test(void);
		char* toString(void);
};

Test::Test(int** ptr)
{
	this->ptr = new int*[sizeof(ptr)];
	this->ptr = ptr;
}

Test::~Test()
{
	delete[] this->ptr;
}

char* Test::toString()
{
	for(int i = 0; i < 20; i++)
	{
		cout << i << " : " << *ptr[i] << endl;
	}
}

int main(void)
{
	int** ptr = new int*[20];

	for(int i = 0; i < 20; i++)
	{
		ptr[i] = &i;
	}
	Test test(ptr);
	test.toString();
}

1. Was moechtest du genau machen? In C++ verwendet man keine rohen Arrays sondern std::vector oder std::array oder etwas vergleichbares.
2. Womit lernst du C++?

Nene, so Zeug darf ich nicht verwenden^^
Womit ich C++ lerne?
mit dem Skript meines Profs

Nene, so Zeug darf ich nicht verwenden^^

Warum nicht?

PointArray schrieb:

Womit ich C++ lerne?
mit dem Skript meines Profs

Ist wahrscheinlich einer derjenigen Profs, die vor 20 Jahren mal C++ gelernt haben und sich denken, dass alles gleich geblieben ist, weil der Code ja noch immer kompiliert ^^

Aber zurueck zum Thema: Was moechtest du genau haben? Wenn du ein Array mit Werten 0 - 19 initialisieren moechtest, dann nehme ich an, du brauchst ein 1D-Array. Sowas hier?

#include <iostream>

using namespace std;

class Test
{
private:
	int* _ptr;
	size_t _size;
public:
	Test (int* ptr, size_t size);
	~Test();
	char* to_string();
};

Test::Test(int* ptr, size_t size)
	: _ptr(ptr), _size(size)
{}

Test::~Test()
{
	delete [] _ptr;
}

char* Test::to_string()
{
	// Selber implementieren
}

int main()
{
	const int N = 20;
	int* ptr = new int(N);
	for ( size_t i = 0; i < N; ++i )
		ptr[i] = i;

	Test t( ptr, N );
}

(Ungetestet und nur so, weil du es offenbar so machen musst).

*Edit
Vielleicht ist das ja auch nur eine einzelne Aufgabe, in der ihr den Umgang mit rohen Arrays lernensollte, was durchaus sinnvoll ist. Aber sonst wirklich keine rohen Arrays verwenden - die sind boese

*Edit2
Da waren noch zwei peinliche Fehler im Code - ich hoffe es hat nicht noch mehr ^^

Zum Thema, Nein, mit Nutzung eines Arrays von Pointern ^^

1D kann ja jeder

int main()
{
	const size_t N = 20;
	int* arr[N];

	for ( size_t i = 0; i < N; ++i )
		arr[i] = new int(i);
}

Natuerlich brauchst du fuer jedes new auch ein delete - das habe ich weggelassen.

Im Zweifelsfall bitte auch folgende Hinweise beachten:
C/C++ Forum :: FAQ - Sonstiges :: Wohin mit meiner Frage?

Dieses Posting wurde automatisch erzeugt.

Übrigens macht dies hier nicht das was du denkst, nicht einmal ansatzweise:

new int*[sizeof(ptr)];