zugriffsverletzung

BorisDieKlinge

Ist block ein 3 dim. array, wenn ich mir klammerung anschaue?

sowas:

Block*** block = new Block**[DIM_X];
for(int x=0; x<DIM_X;++x){
  block[x]= new Block*[DIM_Y];
  for(int y=0; y<DIM_Y;++y)
    block[x][y]= mew Block[DIM_Z];
}

oder sowas

Block[DIM_X][DIM_Y][DIM_Z] block;

kann es sein das du bei einer der drei dimension einen zu große index hast?

brums

block ist ein 3 dim array den ich in einer klasse angelegt habe und in der methode kommt die zugriffsverletzung. ( zeile 21 )

class hist
{
    struct cell 
    { 
        Block_OppHistory *ptrToNextBlock; 
        uint zaehler; 
        cell() 
        { 
            zaehler = 0; 
            ptrToNextBlock = 0; 
        } 
    };
    cell block[5][13][6];

    void add( infoData * _data )
	{
		int action = _data->finalAct[0];
		if( action == -1 )
			return;
		std::cout<<"p:"<<_data->position[0]<<",fA="<<_data->finalAct[0]<<",g="<<_data->gegnerAnzahl[0]<<"\n";
		++block[_data->position[0]][_data->finalAct[0]][_data->gegnerAnzahl[0]].zaehler;
		++gesamt_block_seen;

		for( uint i = 1; i < 4; ++i )
		{
			if( action == _data->finalAct[i] ){
				continue;}
			else{
				action = _data->finalAct[i];}
			if( action == -1 )
				return;
			++block[_data->position[i]][_data->finalAct[i]][_data->gegnerAnzahl[i]].zaehler;
			++gesamt_block_seen;
		}
	}
};

an den indezes kann es nicht liegen da sie wenn der fehler auftritt u.a. alle 0 ( Null ) sind. an dem strich vor der variablen eigentlich auch nicht da ich sehr viele dieser art habe.

crashterpiece

Mehrfach-Arrays sind ohnehin fehleranfällig und soweit ich meine Compiler-abhängig.

Von daher: schenk dir die Arbeit und lege alle Elemente in einem großen 1-dimensionalen Array an und schreib entsprechende Zugriffsmethoden anhand der Indizes

also

Index(x,y,z) = z * size_X * size_Y + y * size_X + x;

Mir ist nicht ganz klar, was der Präfix ++block bewirken soll? sieht so aus, als würde dadurch HINTER das array gesprungen, da der Compiler an der Stelle sozusagen ein weiteres block-Array anspringen will

crashterpiece schrieb:

Mehrfach-Arrays sind ... soweit ich meine Compiler-abhängig.

Nicht wirklich, oder? Quelle?

crashterpiece

echt? schrieb:

crashterpiece schrieb:

Mehrfach-Arrays sind ... soweit ich meine Compiler-abhängig.

Nicht wirklich, oder? Quelle?

wie gesagt: soweit ich meine.

wir hatten mal probleme zwischen visual studio und gcc, aber wenn ich mich irre, dann bitte ich um aufklärung...

brums

@crashterpiece

++block[][][].zaehler;

erhöht den zaehler... müsste doch funktionieren?!

naja werds dann mal umschreiben...

crashterpiece

brums schrieb:

naja werds dann mal umschreiben...

block[][][].zaehler++;

darthdespotism

crashterpiece schrieb:

brums schrieb:

naja werds dann mal umschreiben...
block[][][].zaehler++;

Das macht etwas durchaus aderes

Könnte allerdings durchaus an der Operator - Priorität liegen, versuchs mal mit Klammerung:

++(block[][][].zaehler);

brums

also... folgendes ist völlig gleich:

++block[][][].zaeler;
++(block[][][].zahler);
block[][][].zahler++; (<-- vll. bissl anders aber ergebnis gleich )
block[][][].zaehler+=1;

und das alles lässt die zugriffsverletzung nicht verschwinden.

nehm jetzt einfach mal an das der compiler das nicht handhaben kann, glaub zwar das ich irgendwo was übersehe aber dauert mir jetzt zulange...
ich mach das mit dem 1D array

dank & gruß
brums

Ceos

geh nochmal mit dem debugger durch, da du im debug build arbeitest, weisen speicheradressen wie 0xcdcdcdd1 also mit häufigen hexadezimalen wiederholungen auf eine nicht initialisierte variable hin ... auch WENN die werte innerhalb der dimension liegen, im debugbuild initialisiert der compiler alle zahlen und pointer mit einem markantem sich wiederholenden bytemuster.

zu dem inhaltlichen problem hab ich jetzt nichts tut mir leid

ansonsten versuchs doch mal mit generellen nullsetzen aller variablen bei der instantiierung (kontruktor)