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(); 
}

Was spricht gegen ein paar geile STL-Container?

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

Willst du jetzt einen operator<< o der eine toString() Funktion? Deine gibt nähmlich nichts zurück, und gut ist das definitiv nicht (UB oder IB?)...

new int*[sizeof(ptr)]

Was zum Teufel ist denn das? Du allokierst hier genug Speicher für einen Pointer (der Typ ist int* ).

Edit: Ahh Natürlich, er braucht genug Speicher für 20 Pointer...
Gott hab' ich schon lange nicht mehr new[]/delete[] benutzt...

Ich habe kurz etwas gebastelt (keine Garantie auf Korrektheit):

#include <iostream>

using namespace std;

class Test
{
private:
	int** _ptr;
	size_t _length;
public:
	Test(int** ptr, size_t length)
		: _ptr(ptr), _length(length)
	{ }

	~Test()
	{
		for ( size_t i = 0; i < _length; ++i )
			delete _ptr[i];
		delete [] _ptr;
	}

	void toString()
	{
		for ( size_t i = 0; i < _length; ++i )
			cout << *_ptr[i] << endl;
	}
};

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

	Test t(arr, 20);
	t.toString();
}

Deine gibt nähmlich nichts zurück, und gut ist das definitiv nicht (UB oder IB?)...

Undefined behaviour.

new int*[sizeof(ptr)]

Was zum Teufel ist denn das? Du allokierst hier genug Speicher für einen Pointer (der Typ ist int* ).

Noch viel schlimmer: Ein Array von Zeigern auf int. Und zwar mit so vielen Elementen wie chars in einen int-Zeiger passen. Da hat vorher jemand entweder zu viel C gemacht oder bei Google nur malloc gefunden.

Sone schrieb:

Deine gibt nähmlich nichts zurück, und gut ist das definitiv nicht (UB oder IB?)...

Undefined behaviour.

new int*[sizeof(ptr)]

Was zum Teufel ist denn das? Du allokierst hier genug Speicher für einen Pointer (der Typ ist int* ).

Noch viel schlimmer: Ein Array von Zeigern auf int. Und zwar mit so vielen Elementen wie chars in einen int-Zeiger passen. Da hat vorher jemand entweder zu viel C gemacht oder bei Google nur malloc gefunden.

Also eigentlich nicht für einen sondern für soviele Pointer wie groß ein Zeiger (in Bytes also wie du gesagt hast) ist. Ich sehe aber trotzdem null Sinn in dieser Allokation.

Ich sehe aber trotzdem null Sinn in dieser Allokation.

Da ist ja auch keiner. Mit malloc wäre es halbrichtig (d.h. natürlich immer noch falsch), mit new ist es einfach nur Unsinn.