3. zugriffsverletzung

zugriffsverletzung

  • B

    hallo liebe leute,

    benutze visual c++ 2005 express edition, und bekomme beim debuggen folgende
    fehlermeldung:

    "Unbehandelte Ausnahme bei 0x0041869a in programm.exe: 0xC0000005: Zugriffsverletzung beim Lesen an Position 0xcdcdcdd1."

    die zugriffsverletzung passiert laut MVC++ in dieser zeile: ( hoffe doch das der gelbe pfeil bedeutet das da der fehler ist?! )

    ++block[_data->position[0]][_data->finalAct[0]][_data->gegnerAnzahl[0]].zaehler;

    nun habe ich mir _data->position[0], _data->... etc. vorher ausgeben lassen was mir A) gezeigt hat das alle werte innerhalb der größe der einzelnen dimensionen sind ( waren alle 0 ) und 😎 _data->... keine zugriffsverletzung verursacht.

    block ist übrigens vom typ cell:

    struct cell 
{
	Block_OppHistory *ptrToNextBlock; 
	uint zaehler;
	cell()
	{
		zaehler = 0;
		ptrToNextBlock = 0;
	}
};

    nun meine frage:

    Woran liegt es bzw. woran könnte es noch liegen?

    vielen dank schonmal

    gruß
    brums

    0
  • ?

    Keine Ahnung, ob es das sein kann, aber man soll keine Unterstriche am Anfang von variablen haben, weil die auch vom compiler verwendet werden.

    0
  • B

    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?

    0
  • B

    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.

    0
  • C

    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

    0
  • ?

    crashterpiece schrieb:

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

    Nicht wirklich, oder? Quelle?

    0
  • C

    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...

    0
  • B

    @crashterpiece

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

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

    naja werds dann mal umschreiben...

    0
  • C

    brums schrieb:

    naja werds dann mal umschreiben...

    block[][][].zaehler++;
    0
  • D

    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);
    0
  • B

    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

    0
  • C

    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)

    0
Anmelden zum Antworten