Array aus Pointern

Huhu,

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

icarus2

Das ist kein C sondern C++. Oder zumindest sowas wie "C with Classes".

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++?

Achso, stimmt, sorry, falsches Forum, soll schon C++ sein...

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

icarus2

PointArray schrieb:

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 Porf: Ja, er hat vor 40 Jahren programmieren gelernt

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

1D kann ja jeder

icarus2

Hier ein Beispiel fuer ein Array von Zeigern auf int.

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.

C++ Forumbot

Dieser Thread wurde von Moderator/in SeppJ aus dem Forum C (C89 und C99) in das Forum C++ (auch C++0x und C++11) verschoben.

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

Dieses Posting wurde automatisch erzeugt.

SeppJ

Warum der Umweg, eine Klasse, die ein dynamisches Array so schön kapselt, mit einem frickeligem, händischen, dynamischen Array zu initialisieren? Gib der Arrayklasse die Möglichkeit, auf die Elemente zuzugreifen und gut ist. Zum Beispiel durch Überladung des operator[].

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

new int*[sizeof(ptr)];

Sone

Ganz nebenbei ist das ein Doppelpost.