Private const Zeiger auf new char element welches erst im Konstrukteur entsteht

Matyr

Hi,

Ich habe eine klasse in der ich im Ptivate bereich einen char * const habe.

Im Konstrukteur der Klasse wird das 3D Dynamische Array initialiesiert
(hier nochmal dank an drakon & Skym0sh0). Mein Problem ist jetzt das der zeiger auf ein spezielles element aus diesem Array zeigen soll.

wie mache ich das?

Ich habe es mit initialiesierungsliste versucht weiß aber nicht wie das funktionieren soll.

Mfg. Matyr

drakon

Zeig bitte mal ein wenig Code. Im Grunde genommen ist es das gleiche, wie du sonst auch einen Zeiger zuweist. Dann hast du hald einfach irgendwie p* = &a[5], oder so.

BorisDieKlinge

class XXX{

const char *p;

 XXX() : p(new char[50]){}
 ~XXX() { delete p;}
};

glaub so

Matyr

Verkürzter auschnitt:

class Beispiel
{
    private:

    char * const my_null;
    char * const my_max;

    public:

    Beispiel()
    { 

     Karte = new char**[Daten.a];  // sternchen dahinter 

		for(int i=0;i<=Daten.a;i++)
		{
			Karte[i] = new char*[Daten.b]; 
		}// sternchen dahinter, und nicht dereferenzieren 

		for(int i=0;i<=Daten.a;i++) 
		{
			for(int j=0;j<=Daten.b;j++)
			{
				Karte[i][j] = new char[Daten.c]; 
			}
		}

    }       //// Hier soll my_null=Karte[0][0][0] gesetzt werden und my_max    auf          den Maximal wert;

camper

Matyr schrieb:

Karte = new char**[Daten.a];  // sternchen dahinter

und Karte ist wo definiert?

Matyr

Im Private bereich

char* const my_null;
	char ***Karte;

drakon

Wie würdest du auf den Wert den zugfreien?
Macht genau das und dann ganz einfach einem Pointer auf den Datentypen die Adresse mittels &-Opderator zuweisen. Fertig.

Matyr

Das Problem ist das man const werte bei der initialiesierung uweisen muss (soweit ich mich erinner).

und wenn ich :my_null(&Karte[0][0][0])

mache klappt es nicht.

Folgender runtime error:

Unbehandelte Ausnahme bei 0x00411c58 in Auslesen.exe: 0xC0000005: Zugriffsverletzung beim Lesen an Position 0xcccccccc.

camper

Ein char*** ist kein Array, es sei denn, die bloße Möglichkeit, den Indexoperator anwenden zu können, genügt dir zur Charakterisierung eines Arrays. Zudem liegen die einzelnen Elemente nicht in einem zusammenhängenden Speicherblock, womit mir der Sinn von my_null und my_max fraglich erscheint.
Sei das wie es sei... konstante nicht-statische Member (auch etwas, dass selten gerechtfertigt ist) müssen in der Initialisierungsliste initialisiert werden. Da der Inhalt voraussetzungsgemäß vom Wert von Karte abhängen soll, muss Karte vor diesen Membern initialisiert werden. Das geht nur, wenn Karte ebenfalls in der Initialisierungsliste auftaucht und in der Klassendefinition vor my_null bzw. my_max auftaucht. Die eigentliche Initialisierung von Karte und mynull,mymax ist demgegenüber einfach: die Ermittelung des Wertes von Karte (und aller damit zusammenhängenden Allokationen) können auch in einer separaten Initialisierungsfunktion durchgeführt werden, die den Wert einfach zurückgibt. Da die Funktion auch bei der Definition des Copy-ctors nützlich sein dürfte, schlägst du gleich 2 Fliegen mit einer Klappe.

class Beispiel
{
    private:
    char*** Karte;
    char * const my_null;
    char * const my_max;
    static char*** Init(const foo& daten)
    {
        char*** p = new char**[daten.a];
        ... // der ganze Kram von oben
        return p;
    }
    public:

    Beispiel()
    : Karte(Init(daten)),my_null(&Karte[0][0][0]),my_max(&Karte[a][b][c])
    {}

bwbg

Wenn ich zwei- oder dreidimensionale Datenfelder verwalten will, lege ich immer ein eindimensionales Feld (Array) an. Auf die einzelnen Elemente greife ich immer über eine Index-Berechnung zu:

2d
Länge des Feldes = Spalten x Zeilen
Zugriff auf Element = zeile x Spalten + spalte

3d
Länge des Feldes = Spalten x Zeilen x Ebenen (==z)
Zugriff auf Element = ebene x (Spalten x Zeilen) + zeile x Spalten + spalte

So habe ich alle Datenelemente "beisammen" und kann so vor allem das Feld einfach initialisieren.

for(size_t i = 0; i < field_length; ++i) data[i] = initial_value;

Welche Vorzüge "meine" Variante gegenüber der deinen hat, kann ich dir leider nicht sagen, da mir hierfür die nötige Erfahrung fehlt.

Grüße... Heiko

drakon

bwbg schrieb:

Welche Vorzüge "meine" Variante gegenüber der deinen hat, kann ich dir leider nicht sagen, da mir hierfür die nötige Erfahrung fehlt.

Grüße... Heiko

Sie ist einfacher, fehlerunanfälliger, intuitiver und (wahrscheinlich) schneller.

Allerdings ist auch dem immer noch std::vector vorzuziehen..