ich habe ein Problem in meinem Prog "UBoot Jagd":

Wenn ich es starte stürtzt es nach dem Aufruf der Funktion "Reagiere()" eines Enemy Objektes ab.
Mein Borland kompiler zeigt keine fehler an, jedoch der minimalist GNU für Windows nicht:

"WasserBombe.cpp": C:/***/UBoot Jagd/WasserBombe.cpp multiple definition of `WasserBombe::GetXKoord() const' in Zeile 24
windows\Debug_Build\data.obj:C:/***/UBoot Jagd/WasserBombe.cpp first defined here
windows\Debug_Build\StatePlayerUnknown.obj: In function `ZNK11WasserBombe9GetYKoordEv':

Das sagt er bei ALLEN Funktionen meiner Klassen. Ich habe das State Pattern Desing verwendet.

Hier mein Prog:

data.cpp:

#include <iostream>
#include <string>
#include "defs.h"
#include "UBoot.h"
#include "Enemy.h"
using namespace std;

int main()
{
  Enemy test;
  string input;

  while(input != "exit")
  {
    cout << "anfang der schleife" << endl;
    test.Reagiere();         // Hier Absturtz
  }
  return 0;
}

defs.h:

#ifndef DEFS_H
#define DEFS_H

#define NORDEN    0
#define WESTEN    1
#define OSTEN     2
#define SUEDEN    3
#define UNBEKANNT 4
#define GEFUNDEN  5

#endif

Koord.h:

#ifndef KOORD_H
#define KOORD_H

class Koord                                         // Klasse Koord um den
{                                                   // standort eines Objekts
  public:                                           // zu speichern.
  Koord();
  virtual ~Koord();

  virtual int GetX() const;
  virtual int GetY() const;
  virtual void SetX(int);
  virtual void SetY(int);
  virtual void SetAll(int, int);

  private:
  int itsX;
  int itsY;
};

#include "Koord.cpp"

#endif

Koord.cpp:

#ifndef KOORD_CPP
#define KOORD_CPP

#include "Koord.h"

Koord::Koord()
{
  itsX = 0;
  itsY = 0;
}

Koord::~Koord()
{}

int Koord::GetX() const
{
  return itsX;
}

int Koord::GetY() const
{
  return itsY;
}

void Koord::SetX(int x)
{
  itsX = x;
}

void Koord::SetY(int y)
{
  itsY = y;
}

void Koord::SetAll(int x, int y)
{
  itsX = x;
  itsY = y;
}

#endif

WasserBombe.h:

#ifndef WASSER_BOMBE_H
#define WASSER_BOMBE_H

#include "Koord.h"

class WasserBombe
{
  public:
  WasserBombe();
  virtual ~WasserBombe();

  virtual void SetXKoord(int);
  virtual void SetYKoord(int);
  virtual int GetXKoord() const;
  virtual int GetYKoord() const;

  private:
  Koord itsKoord;
};

#include "WasserBombe.cpp"

#endif

WasserBombe.cpp:

#ifndef WASSER_BOMBE_CPP
#define WASSER_BOMBE_CPP

#include "Koord.h"
#include "WasserBombe.h"

WasserBombe::WasserBombe()
{}

WasserBombe::~WasserBombe()
{}

void WasserBombe::SetXKoord(int x)
{
  itsKoord.SetX(x);
}

void WasserBombe::SetYKoord(int y)
{
  itsKoord.SetY(y);
}

int WasserBombe::GetXKoord() const
{
  return itsKoord.GetX();
}

int WasserBombe::GetYKoord() const
{
  return itsKoord.GetY();
}

#endif

Torpedo.h:

#ifndef TORPEDO_H
#define TORPEDO_H

#include "Koord.h"

class Torpedo                                   // Klasse Torpedo
{
  public:
  Torpedo();
  virtual ~Torpedo();

  virtual int GetRichtung() const;
  virtual int GetXKoord() const;
  virtual int GetYKoord() const;
  virtual int GetZielX() const;
  virtual int GetZielY() const;
  virtual void SetZiel(int, int);
  virtual void SetKoord(int, int);
  virtual void SetRichtung(int);

  virtual void Move();

  private:
  int itsRichtung;
  Koord itsKoord;
  Koord itsZiel;
};

#include "Torpedo.cpp"

#endif

Torpedo.cpp:

#ifndef TORPEDO_CPP
#define TORPEDO_CPP

#include "defs.h"
#include "Koord.h"
#include "Torpedo.h"

Torpedo::Torpedo()
{}

Torpedo::~Torpedo()
{}

int Torpedo::GetRichtung() const
{
  return itsRichtung;
}

int Torpedo::GetXKoord() const
{
  return itsKoord.GetX();
}

int Torpedo::GetYKoord() const
{
  return itsKoord.GetY();
}

int Torpedo::GetZielX() const
{
  return itsZiel.GetX();
}

int Torpedo::GetZielY() const
{
  return itsZiel.GetY();
}

void Torpedo::SetZiel(int x, int y)
{
  itsZiel.SetX(x);
  itsZiel.SetY(y);
}

void Torpedo::SetKoord(int x, int y)
{
  itsKoord.SetX(x);
  itsKoord.SetY(y);
}

void Torpedo::SetRichtung(int richtung)
{
  itsRichtung = richtung;
}

void Torpedo::Move()
{
  int x = itsKoord.GetX();
  int y = itsKoord.GetY();
  switch(itsRichtung)
  {
    case NORDEN:
         itsKoord.SetY(y+1);

    case SUEDEN:
         itsKoord.SetY(y+1);

    case WESTEN:
         itsKoord.SetX(x-1);

    case OSTEN:
         itsKoord.SetX(x+1);
  }
}

#endif

State.h:

#ifndef STATE_H
#define STATE_H

class Enemy;

class State
{
  public:
  virtual ~State(){}
  virtual void Execute(Enemy*) = 0;
};

#endif

StatePlayerNorth.h:

#ifndef STATE_PLAYER_NORTH_H
#define STATE_PLAYER_NORTH_H

#include "Enemy.h"
#include "State.h"

class State_PlayerNorth : public State
{
  public:
  State_PlayerNorth(){}
  virtual void Execute(Enemy*);
};

#include "StatePlayerNorth.cpp"

#endif

StatePlayerNorth.cpp:

#ifndef STATE_PLAYER_NORTH_CPP
#define STATE_PLAYER_NORTH_CPP

#include "Enemy.h"
#include "defs.h"
#include "StatePlayerNorth.h"
#include "StatePlayerWest.h"
#include "StatePlayerEast.h"
#include "StatePlayerSouth.h"
#include "StatePlayerGot.h"
#include "StatePlayerUnknown.h"

void State_PlayerNorth::Execute(Enemy * someEnemy)
{
  switch(someEnemy->GetPlayer())
  {
    case NORDEN:
    {
      someEnemy->SetRichtung(NORDEN);
      someEnemy->Move(1);
    }
    case WESTEN:
    {
      someEnemy->ChangeState(new State_PlayerWest);
      someEnemy->Reagiere();
    }
    case OSTEN:
    {
      someEnemy->ChangeState(new State_PlayerEast);
      someEnemy->Reagiere();
    }
    case SUEDEN:
    {
      someEnemy->ChangeState(new State_PlayerSouth);
      someEnemy->Reagiere();
    }
    case UNBEKANNT:
    {
      someEnemy->ChangeState(new State_PlayerUnknown);
    }
    case GEFUNDEN:
    {
      someEnemy->ChangeState(new State_PlayerGot);
    }
  } 
}

#endif

StatePlayerEast.h:

#ifndef STATE_PLAYER_EAST_H
#define STATE_PLAYER_EAST_H

#include "Enemy.h"
#include "State.h"

class State_PlayerEast : public State
{
  public:
  State_PlayerEast(){}
  virtual void Execute(Enemy*);
};

#include "StatePlayerEast.cpp"

#endif

StatePlayerEast.cpp:

#ifndef STATE_PLAYER_EAST_CPP
#define STATE_PLAYER_EAST_CPP

#include "Enemy.h"
#include "defs.h"
#include "StatePlayerNorth.h"
#include "StatePlayerWest.h"
#include "StatePlayerEast.h"
#include "StatePlayerSouth.h"
#include "StatePlayerGot.h"
#include "StatePlayerUnknown.h"

void State_PlayerEast::Execute(Enemy * someEnemy)
{
  switch(someEnemy->GetPlayer())
  {
    case NORDEN:
    {
      someEnemy->ChangeState(new State_PlayerNorth);
      someEnemy->Reagiere();
    }
    case WESTEN:
    {
      someEnemy->ChangeState(new State_PlayerWest);
      someEnemy->Reagiere();
    }
    case OSTEN:
    {
      someEnemy->SetRichtung(OSTEN);
      someEnemy->Move(1);
    }
    case SUEDEN:
    {
      someEnemy->ChangeState(new State_PlayerSouth);
      someEnemy->Reagiere();
    }
    case UNBEKANNT:
    {
      someEnemy->ChangeState(new State_PlayerUnknown);
      someEnemy->Reagiere();
    }
    case GEFUNDEN:
    {
      someEnemy->ChangeState(new State_PlayerGot);
      someEnemy->Reagiere();
    }
  } 
}

#endif

StatePlayerWest.h:

#ifndef STATE_PLAYER_WEST_H
#define STATE_PLAYER_WEST_H

#include "Enemy.h"
#include "State.h"

class State_PlayerWest : public State
{
  public:
  State_PlayerWest(){}
  virtual void Execute(Enemy*);
};

#include "StatePlayerWest.cpp"

#endif

StatePlayerWest.cpp:

#ifndef STATE_PLAYER_WEST_CPP
#define STATE_PLAYER_WEST_CPP

#include "Enemy.h"
#include "defs.h"
#include "StatePlayerNorth.h"
#include "StatePlayerWest.h"
#include "StatePlayerEast.h"
#include "StatePlayerSouth.h"
#include "StatePlayerGot.h"
#include "StatePlayerUnknown.h"

void State_PlayerWest::Execute(Enemy * someEnemy)
{
  switch(someEnemy->GetPlayer())
  {
    case NORDEN:
    {
      someEnemy->ChangeState(new State_PlayerNorth);
      someEnemy->Reagiere();
    }
    case WESTEN:
    {
      someEnemy->SetRichtung(WESTEN);
      someEnemy->Move(1);
    }
    case OSTEN:
    {
      someEnemy->ChangeState(new State_PlayerEast);
      someEnemy->Reagiere();
    }
    case SUEDEN:
    {
      someEnemy->ChangeState(new State_PlayerSouth);
      someEnemy->Reagiere();
    }
    case UNBEKANNT:
    {
      someEnemy->ChangeState(new State_PlayerUnknown);
      someEnemy->Reagiere();
    }
    case GEFUNDEN:
    {
      someEnemy->ChangeState(new State_PlayerGot);
      someEnemy->Reagiere();
    }
  } 
}

#endif

StatePlayerSouth.h:

#ifndef STATE_PLAYER_SOUTH_H
#define STATE_PLAYER_SOUTH_H

#include "Enemy.h"
#include "State.h"

class State_PlayerSouth : public State
{
  public:
  State_PlayerSouth(){}
  virtual void Execute(Enemy*);
};

#include "StatePlayerSouth.cpp"

#endif

StatePlayerSouth.cpp:

#ifndef STATE_PLAYER_SOUTH_CPP
#define STATE_PLAYER_SOUTH_CPP

#include "Enemy.h"
#include "defs.h"
#include "StatePlayerNorth.h"
#include "StatePlayerWest.h"
#include "StatePlayerEast.h"
#include "StatePlayerSouth.h"
#include "StatePlayerGot.h"
#include "StatePlayerUnknown.h"

void State_PlayerSouth::Execute(Enemy * someEnemy)
{
  switch(someEnemy->GetPlayer())
  {
    case NORDEN:
    {
      someEnemy->ChangeState(new State_PlayerNorth);
      someEnemy->Reagiere();
    }
    case WESTEN:
    {
      someEnemy->ChangeState(new State_PlayerWest);
      someEnemy->Reagiere();
    }
    case OSTEN:
    {
      someEnemy->ChangeState(new State_PlayerEast);
      someEnemy->Reagiere();
    }
    case SUEDEN:
    {
      someEnemy->SetRichtung(SUEDEN);
      someEnemy->Move(1);
    }
    case UNBEKANNT:
    {
      someEnemy->ChangeState(new State_PlayerUnknown);
    }
    case GEFUNDEN:
    {
      someEnemy->ChangeState(new State_PlayerGot);
    }
  } 
}

#endif

StatePlayerGot.h:

#ifndef STATE_PLAYER_GOT_H
#define STATE_PLAYER_GOT_H

#include "Enemy.h"
#include "State.h"

class State_PlayerGot : public State
{
  public:
  State_PlayerGot(){}
  virtual void Execute(Enemy*);
};

#include "StatePlayerGot.cpp"

#endif

StatePlayerGot.cpp:

#ifndef STATE_PLAYER_GOT_CPP
#define STATE_PLAYER_GOT_CPP

#include "Enemy.h"
#include "defs.h"
#include "StatePlayerNorth.h"
#include "StatePlayerWest.h"
#include "StatePlayerEast.h"
#include "StatePlayerSouth.h"
#include "StatePlayerGot.h"
#include "StatePlayerUnknown.h"

void State_PlayerGot::Execute(Enemy * someEnemy)
{
  switch(someEnemy->GetPlayer())
  {
    case NORDEN:
    {
      someEnemy->ChangeState(new State_PlayerNorth);
      someEnemy->Reagiere();
    }
    case WESTEN:
    {
      someEnemy->ChangeState(new State_PlayerWest);
      someEnemy->Reagiere();
    }
    case OSTEN:
    {
      someEnemy->ChangeState(new State_PlayerEast);
      someEnemy->Reagiere();
    }
    case SUEDEN:
    {
      someEnemy->ChangeState(new State_PlayerSouth);
      someEnemy->Reagiere();
    }
    case UNBEKANNT:
    {
      someEnemy->ChangeState(new State_PlayerUnknown);
      someEnemy->Reagiere();
    }
    case GEFUNDEN:
    {
      //            Schießen und wegfahren
    }
  } 
}

#endif

StatePlayerUnknown.h:

#ifndef STATE_PLAYER_UNKNOWN_H
#define STATE_PLAYER_UNKNOWN_H

#include "Enemy.h"
#include "State.h"

class State_PlayerUnknown : public State
{
  public:
  State_PlayerUnknown(){}
  virtual void Execute(Enemy*);
};

#include "StatePlayerUnknown.cpp"

#endif

StatePlayerUnknown.cpp:

#ifndef STATE_PLAYER_UNKNOWN_CPP
#define STATE_PLAYER_UNKNOWN_CPP

#include "Enemy.h"
#include "defs.h"
#include "StatePlayerNorth.h"
#include "StatePlayerWest.h"
#include "StatePlayerEast.h"
#include "StatePlayerSouth.h"
#include "StatePlayerGot.h"
#include "StatePlayerUnknown.h"

void State_PlayerUnknown::Execute(Enemy * someEnemy)
{
  switch(someEnemy->GetPlayer())
  {
    case NORDEN:
    {
      someEnemy->ChangeState(new State_PlayerNorth);
      someEnemy->Reagiere();
    }
    case WESTEN:
    {
      someEnemy->ChangeState(new State_PlayerWest);
      someEnemy->Reagiere();
    }
    case OSTEN:
    {
      someEnemy->ChangeState(new State_PlayerEast);
      someEnemy->Reagiere();
    }
    case SUEDEN:
    {
      someEnemy->ChangeState(new State_PlayerSouth);
      someEnemy->Reagiere();
    }
    case UNBEKANNT:
    {
      someEnemy->SearchPlayer();
    }
    case GEFUNDEN:
    {
      someEnemy->ChangeState(new State_PlayerGot);
      someEnemy->Reagiere();
    }
  } 
}

#endif

ship.h:

#ifndef SHIP_H
#define SHIP_H

#include "Koord.h"
#include "Torpedo.h"

class ship                                    // Klasse ship, die Klassen UBoot
{                                             // und Enemy leiten sich von ihr
  public:                                     // ab.
  ship();
  virtual ~ship();

  virtual int GetRichtung() const;
  virtual int GetXKoord() const;
  virtual int GetYKoord() const;
  virtual void SetKoord(int, int);
  virtual void SetRichtung(int);

  virtual void Move(int);
  virtual void Shoot(int, int, int);
  virtual void TorpLaden() = 0;
  virtual int CheckTorpedo() const;
  virtual void SetTorp(int x);

  protected:
  int itsRichtung;
  Koord itsKoord;
  Torpedo* itsTorp[25];
};

#include "ship.cpp"

#endif

ship.cpp:

#ifndef SHIP_CPP
#define SHIP_CPP

#include "defs.h"
#include "Koord.h"
#include "ship.h"

ship::ship()
{}

ship::~ship()
{}

int ship::GetRichtung() const
{
  return itsRichtung;
}

int ship::GetXKoord() const
{
  return itsKoord.GetX();
}

int ship::GetYKoord() const
{
  return itsKoord.GetY();
}

void ship::SetKoord(int x, int y)
{
  itsKoord.SetX(x);
  itsKoord.SetY(y);
}

void ship::SetRichtung(int richtung)
{
  itsRichtung = richtung;
}

void ship::Move(int i)
{
  int x = itsKoord.GetX();
  int y = itsKoord.GetY();
  switch(itsRichtung)
  {
    case NORDEN:
         itsKoord.SetY(y+i);

    case SUEDEN:
         itsKoord.SetY(y+i);

    case WESTEN:
         itsKoord.SetX(x-i);

    case OSTEN:
         itsKoord.SetX(x+i);
  }
}

void ship::Shoot(int richtung, int x, int y)
{
  int i = CheckTorpedo();
  itsTorp[i]->SetRichtung(richtung);
  itsTorp[i]->SetZiel(x, y);
}

int ship::CheckTorpedo() const               // Funktion zur überprüfung welcher
{                                            // Torpedo der erste nicht
  int i;                                     // abgefeuerte Torpedo ist.
  for(i = 0; i < 25; i++)
  {
    if (itsTorp[i] != 0)
    {
      break;
    }
  }
  return i;
}

void ship::SetTorp(int x)
{
  delete itsTorp[x];
  itsTorp[x] = 0;
}

#endif

Enemy.h:

#ifndef ENEMY_H
#define ENEMY_H

#include "ship.h"
#include "State.h"
#include "WasserBombe.h"

class Enemy : public ship
{
  public:
  Enemy();
  Enemy(int, int);
  ~Enemy();

  void BombeLaden();
  int CheckBombe() const;
  void ShootBombe();
  void TorpLaden();

  void Reagiere();
  void ChangeState(State * newState);
  int GetPlayer() const;
  void SearchPlayer() const;

  private:
  State * CurrentState;
  WasserBombe * itsBomben[30];
};

#include "Enemy.cpp"

#endif

Enemy.cpp:

#ifndef ENEMY_CPP
#define ENEMY_CPP

#include <iostream>

#include "defs.h"
#include "State.h"
#include "Torpedo.h"
#include "WasserBombe.h"
#include "Enemy.h"

Enemy::Enemy()
{
  this->TorpLaden();
  this->BombeLaden();
}

Enemy::Enemy(int x, int y)
{
  itsKoord.SetX(x);
  itsKoord.SetY(y);
}

Enemy::~Enemy()
{}

int Enemy::CheckBombe() const
{
  int i;
  for(i = 0; i < 25; i++)
  {
    if (itsBomben[i] != 0)
    {
      break;
    }
  }
  return i;
}

void Enemy::ShootBombe()
{

}

void Enemy::BombeLaden()
{
  for (int i = 0; i < 30; i++)
  {
    itsBomben[i] = new WasserBombe;
  }
}

void Enemy::TorpLaden()
{
  for (int i = 0; i < 25; i++)
  {
    itsTorp[i] = new Torpedo;
  }
}

void Enemy::Reagiere()
{
  CurrentState->Execute(this);
}

void Enemy::ChangeState(State * newState)
{
  delete CurrentState;
  CurrentState = newState;
}

int Enemy::GetPlayer() const
{
  std::cout << "Get Player" << std::endl;
  return UNBEKANNT;
}

void Enemy::SearchPlayer() const
{
  std::cout << "Search Player" << std::endl;
}

#endif

UBoot.h:

#ifndef UBOOT_H
#define UBOOT_H

#include "ship.h"

class UBoot : public ship
{
  public:
  UBoot();
  UBoot(int, int);
  ~UBoot();

  void TorpLaden();
};

#include "UBoot.cpp"

#endif

UBoot.cpp:

#ifndef UBOOT_CPP
#define UBOOT_CPP

#include <iostream>
#include "UBoot.h"

UBoot::UBoot()
{
  itsKoord.SetX(0);
  itsKoord.SetY(0);
}

UBoot::UBoot(int x, int y)
{
  itsKoord.SetX(x);
  itsKoord.SetY(y);
}

UBoot::~UBoot()
{}

void UBoot::TorpLaden()
{
  for(int i = 0; i < 25; i++)
  {
    itsTorp[i] = new Torpedo;
    i++;
    std::cout << "Torpedo " << i << " geladen!";
    i--;
  }
}

#endif

sry dass es so viel code is.

Mfg Yazoo

Dann zeig doch mal eine deiner Header-Dateien. Der Fehler sieht danach aus, daß du die Funktionen direkt im Header definiert - und diese dann in mehreren Quelldateien eingebunden hast.

^
|
|
|

Hab des ganze prog oben rein geschrieben, hab was zu schnell absendedn geklickt und es deshalb noch ma editiert, sry

All sowas entfernen. Ich kenne keinen vernünftigen Anwendungsfall in dem man Sourcedateien includen müsste/könnte/sollte.

Gruß
Don06

#include "UBoot.cpp"

All sowas entfernen. Ich kenne keinen vernünftigen Anwendungsfall in dem man Sourcedateien includen müsste/könnte/sollte.

Gruß
Don06

hab ich gemacht fehler is der gleiche.

#include "UBoot.cpp"

All sowas entfernen. Ich kenne keinen vernünftigen Anwendungsfall in dem man Sourcedateien includen müsste/könnte/sollte.

Ich schon - Templates. Aber das trifft hier nicht zu.
(und normalerweise sollte man die dafür verwendeten Dateien nicht ".cpp" nennen)

@Yazoo: Don hat es schon auf den Punkt gebracht: du solltest die .cpp Dateien nicht direkt includen - die werden vom Compiler einzeln übersetzt und dann als Paket an den Linker übergeben, der sich das passende heraussucht.

Alle #ifndef in den *.cpp Dateien sind überflüssig.

wieso?

EDIT: Aso weil die cpps net included werden, richtig?

hat einer ne Idee???

CurrentState->Execute(this);

dabei zeigt CurrentState ins nirvana. Du must mit new ein Object diesen Typs erstellen.

ich hab das prob gelöst indem ich im Konstrucktor erst ma ein new State_PlayerUnkown gemacht.

nu hab ich noch ein prob:

wenn ich das prog starte klapp alles, aber wenn ich iwas eingebe sagt er

anfang der schleife
Get Player
Search Player

so wie es sein sollte, aber jedes 2. mal wo ich iwas eingebe sagt er nur:

anfang der schleife
Get Player

Search Player fehlt, warum???

Dass jemand den kompletten Quellcode manuell durchsieht, oder jedes Dateischnipsel per Copy&Paste zu einem Compiler bringt, kannst Du nicht erwarten (was keine Aufforderung ist, ein Zipfile hier einzustellen :D)

Weißt einer ob und wo es ein gutes tut für den debugger vom Borland C++ BuilderX gibt???