Nachdem ich einige Zeit nun mit C Programmiere, wollte ich meinen Kenntnisstand auf C++ ausweiten. Als Geeignetes Testbeispiel hatte ich ein Snake Klon im Sinn. Nur habe ich einen Fehler gemacht, den ich irgentwie nicht verstehe:

Bisher dachte ich das die Libs von C++ kein Endung haben. Wenn ich allerdings das ".h" weg lasse erhalte ich, für den vector feld, folgende Fehlermeldungen:

error: ISO C++ forbids declaration of vector' with no type error: expected;' before '<' token

Beim String ist es egal ob mit oder ohne Endung ich erhalte immer:

error: expected `)' before "dateinname"

Und nun zu meiner Frage:
Was mache ich Falsch? Wie wäre die Richtige Schreibweise?

Hier die Spielfeld.hpp

#ifndef H_SPIELFELD
#define H_SPIELFELD

#include <cstdarg>
#include <vector.h>
#include <fstream.h>
#include <string>

class spielfeld {
    private:
    //  Feld variablen
        int feldx, feldy;
        vector<char> feld;

    public:
    // Konstruktur
        spielfeld(int x, int y);
        spielfeld(char *dateinname);
        spielfeld(string dateinname);
        spielfeld(fstream &datei);
    // Indexoperator
        char&  operator[](int x,...) ;
    // Destruktur
       //  ~spielfeld();

    // getter

        int size_x(void) const;
        int size_y(void) const;

    ////////////////////////////////////////////////////////////////////////////
    // Löschen des Feldinhaltes
    ////////////////////////////////////////////////////////////////////////////

    // ein Feld löschen
        void clear(const int x, const int y);
    //einzelnen Wert
        void clear(const char was);
    // das komplette feld
        void clear(void);
};

#endif

mfg
Fettpet

Ich danke euch. Jetzt Funktioniert es.

mfg,
Fettpet

Wieso haste da ne Elipse (die 3 Pkt)? der op[] unterstützt so und so nur einen Parameter...

bb

übrigens: shcön formatierter code, gefällt mir...

Ja, und sogar Kommentare

char&  operator[](int x,...) ;

Wieso haste da ne Elipse (die 3 Pkt)? der op[] unterstützt so und so nur einen Parameter...

Also ich schreibe an einem Snack Spiel. Hierfür habe ich das Spielfeld in eine Klasse gesteckt. Das Feld ist 2 Dimensional. Ich kann aber nur die x Koordinate abfragen. Hierfür brauche ich die Ellipse.

Also ich schreibe an einem Snack Spiel. Hierfür habe ich das Spielfeld in eine Klasse gesteckt. Das Feld ist 2 Dimensional. Ich kann aber nur die x Koordinate abfragen. Hierfür brauche ich die Ellipse.

Zum einen sind Ellipsen in C++ bestenfalls unschön, zum zweiten wirst Du damit nicht das erreichen was Du möchtest, denn: Der operator[] hat nur einen Parameter (per Definition).

Fettpet schrieb:

Also ich schreibe an einem Snack Spiel. Hierfür habe ich das Spielfeld in eine Klasse gesteckt. Das Feld ist 2 Dimensional. Ich kann aber nur die x Koordinate abfragen. Hierfür brauche ich die Ellipse.

Zum einen sind Ellipsen in C++ bestenfalls unschön, zum zweiten wirst Du damit nicht das erreichen was Du möchtest, denn: Der operator[] hat nur einen Parameter (per Definition).

Mhhhh....

Ok, was für eine schreibweiße würdest du mir empfehlen?

std::vector<std::vector<char> > feld;

dann kannst du ja einfach ein std::vector<char>& von deinem operator[] zurückgeben lassen.
Eine Alternative wäre der Zugriff über eine normale Memberfunktion.

char& getElem(size_t x, size_t y) { return feld[x][y]; }

also so was in etwa:

class proxy
{
private:
  char *first;
  size length; //oder std::vector
public:
  char& operator[](size_t i) {assert (i < length); return first[i];}
  const char& operator[](size_t i) const {assert (i < length); return first[i];}
};

class asd
{
public: //manche definieren auch hier ihr proxy-objekt, um die zugehörigkeit zu zeigen - kann man auch machen - wäre in dem fall wahrscheinlich auch richtiger
private:
  std::vector <proxy> content;
public:
  proxy& operator[](size_t i) {assert (i < content.size()); return content[i];}
  const proxy& operator[](size_t i) const {assert (i < content.size()); return content[i];}
};

#inlude "asd.h"

int main()
{
 asd a;
 a[2][3];
}

verstanden? ^^

bb

edit: die ersten beiden zeilen

Was mir sonst noch aufgefallen ist:

• Klassentypen solltest du eher als Const-Referenz anstatt als Kopie an Funktionen übergeben. Also const std::string& statt std::string .
• Der Konstruktor mit dem std::fstream -Parameter kommt mir komisch vor. Willst du nicht besser nur einen Dateinamen angeben und dann das Streamen lokal vornehmen? Sonst muss der Aufrufer immer sicherstellen, dass er einen gültigen, an die richtige Position zeigenden Stream übergibt.
• Parameter, die sowieso kopiert werden, macht man üblicherweise nicht const (bei dir const int und const char ). Das hat damit zu tun, dass es den Aufrufer nicht zu interessieren hat, was innerhalb der Funktion passiert. Ob eine Kopie nun konstant ist oder nicht, ist von aussen gesehen irrelevant.

Parameter, die sowieso kopiert werden, macht man üblicherweise nicht const (bei dir const int und const char ). Das hat damit zu tun, dass es den Aufrufer nicht zu interessieren hat, was innerhalb der Funktion passiert. Ob eine Kopie nun konstant ist oder nicht, ist von aussen gesehen irrelevant.

Und die Funktionen haben die gleiche Signatur:

void bar(const char i);
void bar(char i);

Wenn man also den Parameter const machen möchte, dann kann das auch in der Source-Datei erst machen:

//*.h
void bar (char i);

//*.cpp
#include "a.h"
void bar (const char i)
{
 //...
}

Ich mach das zwar auch ab und an mal so, aber sinnvoll find ich es nicht ^^

bb