3. String als Parameter

String als Parameter

  • F

    Guten Abend,

    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

    0
  • B

    Lass das .h auf weg. Es heißt dann aber natürlich std::vector. Das gleiche trifft auf string zu.

    0
  • N

    Standardheader haben keine Endung, richtig. Aber die Bezeichner befinden sich alle im Namensraum std , deshalb musst du diesen mittels vorgestelltem std:: angeben. Von using namespace rate ich ab, vor allem in Headern.

    0
  • F

    Hallo,

    Ich danke euch. Jetzt Funktioniert es. 😃

    mfg,
    Fettpet

    0
  • S

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

    0
  • U
     

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

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

    bb

    0
  • J

    Skym0sh0 schrieb:

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

    Ja, und sogar Kommentare 😉

    0
  • F

    unskilled schrieb:

    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.

    0
  • L

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

    0
  • F

    LordJaxom schrieb:

    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?

    0
  • B

    Wenn dein Feld so aussieht

    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]; }
    0
  • U

    Man macht es über ein Proxy-Objekt...
    Es gibt auch nen Artikel über Operatorüberladung hier - imho wird da dieses Prob auch angesprochen...

    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

    0
  • N

    Oder wenn dir das Aussehen nicht so wichtig ist, kannst du auch eine einfache Memberfunktion mit zwei Parametern schreiben.

    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.
    0
  • U

    Nexus schrieb:

    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

    0
Anmelden zum Antworten