in folgendem Code (hier nur wesentliche Fragmente) erhalte ich beim Compilieren eine Fehlermeldung, die ich mir nicht erklären kann:

player.h
--------

class Player {
  public:  

	...

    char GetColor();

  private:

    ...

    char m_Color;
};

player.cpp
----------

#include "player.h"

...

char Player::GetColor() {
  return m_Color;
}

fieldcell.h
-----------

#include "player.h"

class Fieldcell {

  public:

	...

    bool isOpponent(const Player& player);

  private:

    ...

    char m_Color;   

fieldcell.cpp
-------------

#include "fieldcell.h"
#include "player.h"

...

bool Fieldcell::isOpponent(const Player& player) {
  if (m_Color != 'N')
    return m_Color != player.GetColor();
  else
    return false;
}

Die Meldung (compiliert mit g++) lautet:

fieldcell.cpp: In member function ‘bool Fieldcell::isOpponent(const Player&)’:
fieldcell.cpp:60: error: passing ‘const Player’ as ‘this’ argument of ‘char Player::GetColor()’ discards qualifiers

Danke für Eure Hilfe.

class Player {
  public:  

    ...

    char GetColor() const; // sag dem Compiler, dass das hier nix ändert

  private:

    ...

    char m_Color;
};

GetColor ist keine const Funktion und kann daher nicht auf ein const Objekt aufgerufen werden.

Vielen Dank! Kannst Du mir noch sagen, warum

bool Fieldcell::isEmpty() {
 return m_Stones = 0; 
}

false liefert, wenn m_Stones = 0 ist? Sollte doch genau dann true sein?

bool Fieldcell::isEmpty() {
 return m_Stones == 0; 
}

heisen muss.

Gut Schuß
VuuRWerK

Weil es

bool Fieldcell::isEmpty() {
 return m_Stones == 0; 
}

heisen muss.

Gut Schuß
VuuRWerK

Oh mei, danke.

Deklariere Memberfunktionen als const , wenn sie das Objekt nicht verändern!

Genau diesen Fehler hättest du mit korrekter Anwendung von Const-Correctness vermeiden können.

Deklariere Memberfunktionen als const , wenn sie das Objekt nicht verändern!

Bin noch Anfänger, was C++ betrifft.

Was mir in dem Kontext noch nicht klar ist; für sich alleine betrachtet, hätte GetColor() ja nicht const sein müssen. Nun habe ich "zufällig" mal eine konstante (hätte ich ja, naiv betrachtet, nicht konstant machen müssen) Referenz auf ein Objekt der Klasse Player als Parameter im Methodenaufruf einer anderen Klasse übergeben und schon muss GetColor const sein. Angenommen, ich hätte auch noch andere Memberfunktionen aus Player nutzen wollen, dann müssten die alle const sein, obwohl das, für die Klasse alleine betrachtet, vielleicht garnicht nötig oder sogar hinderlich wäre?!

struct Test {
    void test1() const;
    void test2();
    void test3(const Test& t) {
        t.test1(); // OK
        t.test2(); // ERROR
    }
    void test4(Test& t) {
        t.test1(); // OK
        t.test2(); // OK
    }
};

Es geht nicht um wollte oder könnte, sondern darum, dass alle Methoden die das Objekt nicht verändern ein const bekommen sollen. Mehr nicht. ....

Danke für den Hinweis, das beantwortet meine Frage.

Nun habe ich ein weiteres Problem;

main.h
------
const char PLAYERW = 'W';
const char PLAYERB = 'B';
const char PLAYERN = 'N';

fieldcell.h
-----------
#include "player.h"
#include "main.h"

class Fieldcell {

  public:
    Fieldcell(int stones = 0, const char& color = PLAYERN);
    ~Fieldcell();
    bool isEmpty();
    ...

playfield.h
-----------

#include "main.h"
#include "player.h"
#include "fieldcell.h"
#include <iostream>
#include <string>
#include <vector>

class Playfield {

  public:
    Playfield(int rows = 3, int columns = 3);
    ~Playfield();
    void Visualize();

    std::vector<Fieldcell> battlefield;

  private:
    int m_Rows;
    int m_Columns;
};

playfield.cpp
-------------
#include "playfield.h"
#include "fieldcell.h"
#include "player.h"
#include "main.h"
#include <vector>

using namespace std;

Playfield::Playfield(int rows, int cols) {

  m_Rows = rows;
  m_Columns = cols;

  // battlefield.reserve(m_Rows * m_Columns);

  for(int i = 0; i < m_Rows; i++) {
    for(int j = 0; j < m_Columns; j++) {
      battlefield.push_back(0, PLAYERN);
    }
  }
}

(hier) Zeile 63 wird vom Compiler als Fehler gemeldet:

playfield.cpp: In constructor ‘Playfield::Playfield(int, int)’:
playfield.cpp:19: error: no matching function for call to ‘std::vector<Fieldcell, std::allocator<Fieldcell> >::push_back(int, const char&)’
/usr/include/c++/4.4/bits/stl_vector.h:733: note: candidates are: void std::vector<_Tp, _Alloc>::push_back(const _Tp&) [with _Tp = Fieldcell, _Alloc = std::allocator<Fieldcell>]
make: *** [playfield.o] Fehler 1

Habe ich die vector deklaration falsch verstanden?

Fieldcell::isEmpty() wäre übrigens nocht ein Kandidat für const, ebenso Playfield::Visualize(), was ja nur das Spielfeld ausgibt und nicht ändert, oder?
Im übrigen sagt mir dict.leo.org, dass Spielfeld im englischen nur "field" heißt, oder "playing field" nicht aber "playfield", was ja die Übersetzung 1:1 ins Deutsche wäre

http://www.cplusplus.com/reference/stl/vector/push_back/
push_back hat nur einen Parameter, du übergibst 2.

Schon klar, aber in dem Fall addiere ich kein int, sondern ein Objekt. Im Buch wird als Beispiel ein string addiert, der direkt als literal angegeben wird. Nun dachte ich, dass das string-objekt anonym erzeugt wird und ein Parameter des string-Konstruktors angegeben wird (also vectorobj.push_back("test"). Also ging ich davon aus, dass ich die Parameter des Konstruktors von Fieldcell übergeben muss. Letztlich muss ich also zuerst eine (nicht anonyme) Instanz von Fieldcell erzeugen und die an push_back übergeben?

Fieldcell::isEmpty() wäre übrigens nocht ein Kandidat für const, ebenso Playfield::Visualize(), was ja nur das Spielfeld ausgibt und nicht ändert, oder?
Im übrigen sagt mir dict.leo.org, dass Spielfeld im englischen nur "field" heißt, oder "playing field" nicht aber "playfield", was ja die Übersetzung 1:1 ins Deutsche wäre

Ja, aber Leerstellen in Klassennamen sind nicht erlaubt und field hört sich so uneindeutig an.
Übrigens, nicht dass hier jemand denkt, ich lasse meine "Hausaufgaben" hier machen (wird ja für Neulinge ganz klar angedeutet). Ich mache zwar ein Studium, aber da wird Java gelernt und das hier war eine Programmieraufgabe aus vergangener Zeit (mit der ich selbst nichts zu tun hatte/habe), die ich als Übung just for fun versuche, in c++ zu schreiben (ohne dass ich den Java-Code besitze, nur die Spezifikation), da das Lernen von c++ rein eigenes Interesse ist. Hoffe, das ist klar genug.

Im Buch wird als Beispiel ein string addiert, der direkt als literal angegeben wird. Nun dachte ich, dass das string-objekt anonym erzeugt wird und ein Parameter des string-Konstruktors angegeben wird (also vectorobj.push_back("test"). Also ging ich davon aus, dass ich die Parameter des Konstruktors von Fieldcell übergeben muss. Letztlich muss ich also zuerst eine (nicht anonyme) Instanz von Fieldcell erzeugen und die an push_back übergeben?

Er kann das eine Argument, das push_back erwartet als einzelnen Parameter für den Konstruktor "std::string(const char*)" erkennen und damit den passenden Konstruktor identifizieren.
Aber wie soll er wissen, dass push_back(0, PLAYERN) diesen Konstruktor aufrufen soll? push_bask erwartet EINEN Parameter. Wenn du ein Objekt anhängen (nicht addieren, btw) willst musst du ein Objekt erstellen, auch wenn du das nur temporär direkt in push_back machst:

battlefield.push_back(Fieldcell(0, PLAYERN));

Ja, aber Leerstellen in Klassennamen sind nicht erlaubt und field hört sich so uneindeutig an.

Dafür gibt es doch wunderbare Möglichkeiten
class playing_field, oder mit CamelCase class PlayingField. Denn wenn du schon englische Namen vergibst, sollten die auch passen (mMn), sonst kannst du das auch gleich mit deutschen Namen machen

Im Buch wird als Beispiel ein string addiert, der direkt als literal angegeben wird. Nun dachte ich, dass das string-objekt anonym erzeugt wird und ein Parameter des string-Konstruktors angegeben wird (also vectorobj.push_back("test"). Also ging ich davon aus, dass ich die Parameter des Konstruktors von Fieldcell übergeben muss. Letztlich muss ich also zuerst eine (nicht anonyme) Instanz von Fieldcell erzeugen und die an push_back übergeben?

Das funktioniert bei Klassen, die einen impliziten Konstruktor mit einem Parameter besitzen, z.B. bei std::string .

std::string::string(const char* c_str);

Dann kannst du einen const char* übergeben, wo ein std::string gefordert ist, und es wird eine implizite Typkonvertierung durchgeführt. Man spricht auch von Konvertierungskonstruktor. Wenn der Konstruktor von String als explicit deklariert wäre, würde das nicht mehr funktionieren.

Auf mehrere Parameter kannst du das nicht übertragen. Da musst du ein temporäres Objekt übergeben:

battlefield.push_back(Fieldcell(0, PLAYERN));

danke Euch für die Antwort. Ich hatte zwischenzeitlich

Fieldcell newCell(0, PLAYERN);
battlefield.push_back(newCell);

benutzt, was auch funktioniert. Ist das "unschön", oder ohnehin das Gleiche wie

battlefield.push_back(Fieldcell(0, PLAYERN));

da bin ich mir garnicht so sicher, Letzteres sieht "anonymer" aus.

da bin ich mir garnicht so sicher, Letzteres sieht "anonymer" aus.

Ist es auch.

Während das temporäre Objekt nach der Zeile nicht mehr existiert, kannst du auf newCell immer noch zugreifen. Ist zwar eine potenzielle Fehlerquelle, aber keine schlimme. Wenn es dir in der Übersicht hilft, kannst du das Objekt ruhig separat deklarieren.

Während das temporäre Objekt nach der Zeile nicht mehr existiert, kannst du auf newCell immer noch zugreifen. Ist zwar eine potenzielle Fehlerquelle, aber keine schlimme. Wenn es dir in der Übersicht hilft, kannst du das Objekt ruhig separat deklarieren.

@Nexus: Ok, danke, die temporäre Lösung gefällt mir sogar besser.
@l'abra d'or: Die Klasse heisst jetzt PlayingField.

Weitere Frage (ich hoffe, ich nerve nicht zuviel!):

PlayingField::PlayingField(int rows, int cols) {

  m_Rows = rows;
  m_Columns = cols;

  // BattleArray.reserve(m_Rows * m_Columns);

  int k = 0;
  for(int i = 0; i < m_Rows; i++) {
    for(int j = 0; j < m_Columns; j++) {
      BattleArray.push_back(BattleArrayField(0, PLAYERN));      
      if (i == 0 || i == m_Rows - 1) {
        if (j == 0 || j == m_Columns - 1)
          BattleArray[k].setMaxstones(1);
        else
          BattleArray[k].setMaxstones(2);
      }
      else {
        if (j == 0 || j == m_Columns - 1)
          BattleArray[k].setMaxstones(2);
        else
          BattleArray[k].setMaxstones(3);
      }
      k++;
    }
  }
}

Ist es guter/schlechter Programmierstiel, solche Initialisierungen im Konstruktor zu machen? Und gibt es zweidimensionale vektoren?

Und gibt es zweidimensionale vektoren?

Ja, du kannst std::vector verschachteln. Oder sowas wie boost::multi_array verwenden.

std::vector<std::vector<FieldCell> > myCells;
// hier Grösse setzen
myCells[x][y] = /* ... */;

Alternativ 2D-Feld auf ein eindimensionales Array abbilden. Dann schreibst du dir eine Zugriffsfunktion, um eine 2D-Schnittstelle zu haben.

std::vector<FieldCell> myCells;

FieldCell& At(unsigned int x, unsigned int y)
{
    return myCells[x + myWidth*y];
}

// Const-Überladung, wenn nur lesend zugegriffen wird
const FieldCell& At(unsigned int x, unsigned int y) const;

wollewausfander schrieb:

Ist es guter/schlechter Programmierstiel, solche Initialisierungen im Konstruktor zu machen?

Es ist durchaus guter Stil, wenn eine Klasse nach dem Konstruktoraufruf bereits fertig initialisiert ist. Was du allerdings tun könntest, ist die Initialisierungsliste statt Zuweisungen zu verwenden:

PlayingField::PlayingField(int rows, int cols)
: m_Rows(rows)
, m_Columns(cols)
{
   // ...
}

Wenn dein Konstruktorrumpf länger wird, könntest du die Schleifen auch in eine private Memberfunktion auslagern und diese Funktion im Konstruktor aufrufen.

Alternativ 2D-Feld auf ein eindimensionales Array abbilden. Dann schreibst du dir eine Zugriffsfunktion, um eine 2D-Schnittstelle zu haben.

std::vector<FieldCell> myCells;

FieldCell& At(unsigned int x, unsigned int y)
{
    return myCells[x + myWidth*y];
}

// Const-Überladung, wenn nur lesend zugegriffen wird
const FieldCell& At(unsigned int x, unsigned int y) const;

Danke. Was wird denn hier zurück gegeben? Eine Referenz auf das Objekt, oder eine Kopie des Objekts?

Eine Referenz auf das Objekt.

Vielen Dank.

In folgendem Code

void PlayingField::recursiveCascade() {
    bool isOverflow = false;
    int row = 0;
    int col = 0;
    int k = 0;
    char color = ' ';
    vector<BattleArrayField>::const_iterator myIterator;

    for (myIterator = BattleArray.begin(); myIterator != BattleArray.end(); myIterator++) {
        if ((*myIterator).isOverflow()) {
            color = (*myIterator).getColor();
            isOverflow = true;
            row = k / m_Columns;
            col = k % m_Columns;
            // cout << "Zeile: " << row << ", Spalte: " << col << endl;
            if (row == 0) {
                if (col == 0) {
                    BattleArray[k].decStones();
                    BattleArray[k+1].incStones();
                    ...
                    ...
               }
            }
        }
        k++;
    }
    if (isOverflow)
      recursiveCascade();
}

hatte ich Zeile 28 zuvor so:

this.recursiveCascade();

da ich mich ja in einer PlayingField-Instanz befinde. Dies wurde aber vom Compiler beanstandet:

PlayingField.cpp: In member function ‘void PlayingField::recursiveCascade()’:
PlayingField.cpp:189: error: request for member ‘recursiveCascade’ in ‘this’, which is of non-class type ‘PlayingField* const’
make: *** [PlayingField.o] Fehler 1

Das kann ich mir garnicht erklären. Und dann noch:

void PlayingField::setStone(const Player& player, const string& coord) {

  // Bsp: coord = "C5"
  // Im header: alpha_index = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";

  const char * scolumn = &coord[1];
  int column = atoi(scolumn) - 1;  

  char srow = coord[0];
  size_t rowsearch = alphaIndex.find(srow);
  int row = (int)rowsearch;

  int k = row * m_Columns + column;

  cout << "Zeile: " << row << ", Spalte: " << column << ", Feld: " << k << endl;

  if (!BattleArray[k].isOpponent(player) || BattleArray[k].isEmpty()) {
  ....

Zeile 5 hatte ich ursprünglich so:

char scolumn = coord[1];

was aber beanstandet wurde, was ich mir nicht erklären kann. Und überhaupt; gibt es einen besseren Weg, coord zu dekodieren?

// this.recursiveCascade();
this->recursiveCascade();

Ansonsten ist das ein Konstanter Zeiger auf ein PlayingField (1) und nicht ein Zeiger auf ein konstantes PlayingField (2).

PlayingField const *ptr1; // (1)
const PlayingField *ptr2; // (1)
PlayingField * const ptr3; // (2)

Zeile 5 hatte ich ursprünglich so:

char scolumn = coord[1];

was aber beanstandet wurde, was ich mir nicht erklären kann. Und überhaupt; gibt es einen besseren Weg, coord zu dekodieren?

1. "beanstandet wurde" ist keine Fehlermeldung. Die brauchen wir aber um das Problem korrekt einschätzen zu können.
2. Nehm ich dir das Statement nicht ab.
   Ich nehme eher an, das sah vorher so aus:

char* scolumn = &coord[1];

Und das geht eben wegen dem kleinen dummen const wieder nicht
http://www.cplusplus.com/reference/string/string/operator[]/
Denn die Zeile wie du sie da stehen hast kompiliert einwandfrei.

Überhaupt den Link http://www.cplusplus.com/reference/ gut aufheben, die Doku ist das wichtigste Werkzeug für dich, ohne der bist du aufgeschmissen

1. "beanstandet wurde" ist keine Fehlermeldung. Die brauchen wir aber um das Problem korrekt einschätzen zu können.

Sorry:

PlayingField.cpp: In member function ‘void PlayingField::setStone(const Player&, const std::string&)’:
PlayingField.cpp:196: error: invalid conversion from ‘char’ to ‘const char*’
PlayingField.cpp:196: error:   initializing argument 1 of ‘int atoi(const char*)’
make: *** [PlayingField.o] Fehler 1

l'abra d'or schrieb:

2. Nehm ich dir das Statement nicht ab.
   Ich nehme eher an, das sah vorher so aus:

char* scolumn = &coord[1];

Und das geht eben wegen dem kleinen dummen const wieder nicht
http://www.cplusplus.com/reference/string/string/operator[]/
Denn die Zeile wie du sie da stehen hast kompiliert einwandfrei.

Als Anfänger widerspreche ich natürlich nicht gerne, aber es ist leider genau umgekehrt. Nur mit

const char* scolumn = &coord[1];

läuft alles ohne Meldung durch.

l'abra d'or schrieb:

Überhaupt den Link http://www.cplusplus.com/reference/ gut aufheben, die Doku ist das wichtigste Werkzeug für dich, ohne der bist du aufgeschmissen

Den habe ich in der Linkliste, aber mein Buch liegt auch hier auf dem Tisch.

this ist eine Zeiger!

// this.recursiveCascade();
this->recursiveCascade();

Oh ja, stimmt ja, sorry.

l'abra d'or schrieb:

Ansonsten ist das ein Konstanter Zeiger auf ein PlayingField (1) und nicht ein Zeiger auf ein konstantes PlayingField (2).

PlayingField const *ptr1; // (1)
const PlayingField *ptr2; // (1)
PlayingField * const ptr3; // (2)

Woher weiss man (weiss ich) denn, dass es sich um einen konstanten Zeiger handelt? Oder sind this-Zeiger immer konstant?

Oder sind this-Zeiger immer konstant?

Genau genommen sind es skalare RValues, und diese können nicht verändert werden. Das ist wie wenn du 3 = 4 schreibst.

Befindest du dich zudem in einer const -Methode, zeigt this auf ein konstantes Objekt, ansonsten nicht.

void MyClass::MemberFunction()
{
    this; // Typ MyClass*
}

void MyClass::MemberFunction() const
{
    this; // Typ const MyClass*
}

Als Anfänger widerspreche ich natürlich nicht gerne, aber es ist leider genau umgekehrt. Nur mit

const char* scolumn = &coord[1];

läuft alles ohne Meldung durch.

Die Fehlermeldung spricht aber ein anderes Wort
Dass "const char* c = &coord[1];" geht bezweifle ich nicht.
Dass "char c = coord[1];" hingegen einen Fehler gibt - jenen von dir geposteten - bezweifle ich sehr wohl!
Deiner Fehlermeldung zufolge machst du so etwas:

const char* c = s[0];

Was willst du jetzt eigentlich genau haben, einen char oder einen (const) char*?

BTW: eine Klasse "FieldIndex" wäre nicht schlecht. Denn die Koordinate in allen benötigten Funktionen erst aus nem String zu extrahieren ist witzlos