[C++]Speicherleck ?

[Keksdose12]

Ich habe ein Programm mit einem Zwei-Dimensionalen Array das mir als Anzeige dient geschrieben,wenn ich nun mit meiner Maus (=ein X das in dem Array durch die Pfeiltasten wandern kann) an den rechten Rand stoße beginnt das Programm etwas in Richtung von dem gezeigten im Anhang zu zeigen und ich höre ein hochfrequentes Piepen.

Was ist das ? und muss ich mir Sorgen machen ?

mfg

Keks

 

[Leandros]

Also ohne Code ist dir zu Helfen schwierig.

 

[Keksdose12]

Spoiler

#include<iostream>
#include<conio.h>
#include<windows.h>
using namespace std;

class welt
{

public:

void ausgeben()
{
for(y=0;y<beg_y;y++)
{
for(x=0;x<beg_x;x++)
{
felder[x][y]=' '; //Fuellzeichen im Hintergrund
}
}
felder[x_pos][y_pos]='o'; //Zeichen für Spieler

system("cls");
for(y=0;y<beg_y;y++)
{
for(x=0;x<beg_x;x++)
{
cout << felder[x][y];
}
cout<<endl;
}
}

void edit_x_pos(int x_neu)
{
x_pos=x_neu;
}

void edit_y_pos(int y_neu)
{
y_pos=y_neu;
}

private:

const int beg_x=79; // Dies ist der Bereich in dem
const int beg_y=24; // gezeichnet wird.
char felder[79][24];

int x=0;
int y=0;
int x_pos=0;
int y_pos=0;

};

class spieler
{

public:

void bewegen(int richtung)
{
if(richtung==77) //rechts
{
x_pos++;
//x_pos++;
}

else if(richtung==75) //links
{
x_pos=x_pos-1;
//x_pos=x_pos-1;
}

else if(richtung==80) //runter
{
y_pos++;
//y_pos++;
}

else if(richtung==72) //hoch
{
y_pos=y_pos-1;
//y_pos=y_pos-1;
}
}

int ask_x_pos()
{
return x_pos;
}

int ask_y_pos()
{
return y_pos;
}

private:

int x_pos=0;
int y_pos=0;

};

main()
{

int eingabe;

welt stage1;
spieler me;

cout<< "Zum starten bitte Enter druecken." <<endl;

while(eingabe!=27)
{
eingabe=getch();
me.bewegen(eingabe);
stage1.edit_x_pos(me.ask_x_pos());
stage1.edit_y_pos(me.ask_y_pos());
stage1.ausgeben();
}
}

Das Programm soll dieses o auf dem Bildschirm bewegen, wenn du aber gleich am Anfang Pfeiltaste nach oben klickst wirst du schon sehen (du musst über taskmanager beenden). Ach ja der Code ist nicht der beste ich weiss aber man sollte ihn doch schon lesen können

 

[Bunny_Joe]

Du hast bei ersten [spoiler/] geschrieben. Nimm das / raus^^

 

[DarkMo]

öh, code tags fetzen auch ^^

aber so wie ich das seh: du hast 0 begrenzung drin. du kannst x und y inkrementieren oder dekremeniteren wie du magst - auch ÜBER die grenzen des arrays hinaus -> boom.

 

[Keksdose12]

aha ? und wie könnte man diese begrenzungen realisieren ?

 

[VikingGe]

Das ist auch kein Wunder, dass das nicht geht, denn y_pos wird dann negativ. Du verlässt also den zulässigen Bereich, schreibst aber trotzdem in das Array.

Ich musste den Code zwar etwas umbauen, um das unter Linux verwenden zu können (conio ist Windows-spezifisch), aber ich hab mal die Problemquelle kommentiert:

Spoiler

class Welt {

public:

  void ausgeben() {
    
    // Du kannst und solltest Schleifenvariablen direkt
    // im Kopf der Schleife deklarieren, wenn möglich,
    // aber nicht als Klassen-Member. Die Variable wird
    // ja sonst nirgendwo mehr benutzt, ihr Wert ist nach
    // der Schleife sinnlos und hat für das Objekt keine
    // wirkliche Bedeutung.
    for (int y = 0; y < this->_begY; y++) {
      
      for (int x = 0 ; x < this->_begX; x++)
        this->_felder[x][y] = ' ';
        
    }
    
    // Und genau hier ist das Problem. Du prüfst nicht,
    // ob die Array-Indizes überhaupt zwischen 0 und 79
    // bzw. zwischen 0 und 24 liegen - d.h. du überschreibst
    // irgendwas, was für das Programm wichtig sien kann.
    // Daher kommt der Absturz. Eine einfache If-Abfrage
    // könnte das Problem lösen, oder du implementierst
    // es so, dass Werte jenseits des zulässigen Bereichs
    // wieder in ihn hineingewrappt werden - z.B. dass yPos
    // statt -1 den Wert 23 annimmt und die Figur dann am
    // unteren Rand der Konsole startet.
    this->_felder[this->_xPos][this->_yPos] = 'o'; //Zeichen für Spieler

    // Hier wieder dasselbe mit den Schleifen.
    for (int y = 0; y < this->_begY; y++) {
      
      for (int x = 0; x < this->_begX; x++)
        cout << this->_felder[x][y];
      
      cout << endl;
      
    }
    
  }

  void setXPos(int xNeu) {
    this->_xPos = xNeu;
  }

  void setYPos(int yNeu) {
    this->_yPos = yNeu;
  }

private:

  const int _begX = 79; // Dies ist der Bereich in dem
  const int _begY = 24; // gezeichnet wird.
  
  char _felder[79][24];

  int _xPos = 0;
  int _yPos = 0;

};

 

[DarkMo]

aha ? und wie könnte man diese begrenzungen realisieren ?

öh...? if?
if(keine grenze verletzt) {operation;}
also in deinem falle zum bsp y_pos--; if(y_pos < 0) y_pos = 0;

 

[Keksdose12]

öh...? if?
if(keine grenze verletzt) {operation;}
also in deinem falle zum bsp y_pos--; if(y_pos < 0) y_pos = 0;

Stimmt ich hatte es vorher schon versucht aber dann konnnte ich mein o garnicht mehr bewegen

 

[Keksdose12]

Und was ist dieses piepsen ? Wenn ich mit meinem o aus dem arrray rutsche ?

 

[Crysis nerd]

Darüber kann man nur spekulieren. Du schreibst in irgendeinen Speicherbereich.. Wer weiß, was der komisches anstellt. Wenn ich das mal bei mir unter Linux probiert habe, hat er mir haufenweise komisches Zeugs ausgegeben. Wer weiß wo du landest und was du damit kaputt machst.
Im übrigen ist die Variable eingabe in der main Funktion nicht initialisiert, was auch eine schlechte Sache ist. Außerdem heißt es
int main()
Du hast das int vergessen, was nicht sein darf.

 

[Keksdose12]

Ok alles gefixt ich hab alles so vereinfacht, dass die main funktion gar keine varibeln mehr hat