//Spieler.h
#include <iostream>
#ifndef _SPIELER_H_
#define _SPIELER_H_
using namespace std;
class Spieler
{
private:
int Stufe = 10;
public:
int get_stufe();
};

Spieler* P = new Spieler; // <- diese zeile macht mir sorgen, hab hier wohl einen fehler gemacht

//Spieler.cpp
include <iostream>
using namespace std;
int Spieler :: get_stufe(){return stufe;}

Ähnlich aufgebaut ist jetzt auch das Konstrukt für die Klasse Waffe.
Nur darin gibts einen Quellcodeabschnitt in form von so etwas:

//iostream, und so
#include "Spieler.h"
using namespace std;
int Waffe :: Set_Schaden(){P->get_stufe() * 10;} // schaden soll also von der stufe abhängen

tja, und hier gibt mir der compiler eine fehlermneldung aus, er würde P nicht kennen.

Ich hoffe, ihr könnt mir helfen

Gruß,
Thracian

[edit] Achja, ne main.cpp samt main() hab ich auch noch, aber ich weiss nicht, ob die hier wichtig ist. in der hab ich alle .hs und .cpps includet und ein paar testfunktion implementiert

Globale Variablen sind böse!

//Spieler.cpp
include <iostream>
using namespace std;
int Spieler :: get_stufe(){return stufe;}

Würde ich inlinen. Außerdem muss spieler.h includet werden.

[edit] Achja, ne main.cpp samt main() hab ich auch noch, aber ich weiss nicht, ob die hier wichtig ist. in der hab ich alle .hs und .cpps includet und ein paar testfunktion implementiert

.cpp Dateien includet man nicht, man kompiliert sie seperat und linkt dann alles zusammen.

Also:
Ich habe ja zwei verschiedene .h und .cpps: einmal die für Spieler und einmal die für Waffe. Nun soll die Klasse Waffe allerdings eine Methode enthalten, in der Sie auf die Funktion Spieler :: Get_Stufe(); zugreift. Will heissen: Ohne ein Objekt Spieler P wird die Klasse fehlerhaft kompiliert.
Ich will nun einen Pointer

Spieler *P = new Spieler;

nutzen und dannach verschiedene Objekte der Klasse Waffe instanzieren, die dann korrekterweise auf die Stufe des Objekts Spieler zugreifen, der sie angelegt hat.
Mein Problem also: wie erkläre ich der Klasse Waffe, dass sie sich auf einen Spieler beziehen soll, der zum Zeitpunkt des kompilierens noch gar nicht existiert, bzw. in einer anderen .cpp/ .h Datei instanziert wurde?

Besser ist es imho, wenn die Waffe selber weiß, welchem Spieler sie gehört:

//waffe.h
class Spieler;

class Waffe
{
public:
  Waffe(Spieler* b = NULL):besitzer(b){}
  void setze_Besitzer(Spieler* b)
  { besitzer=b; }

  int schieße();
  ...
private:
  Spieler* besitzer;
};

//waffe.cpp
#include "Waffe.h"
#include "Spieler.h"

int Waffe::schieße()
{
  int stufe = besitzer->Get_Stufe();
  ...
}

//spieler.h
class Waffe;

class Spieler
{
public:
  void setze_Waffe(Waffe* w);//ruft wieder w->setze_besitzer()
  int Get_Stufe();
...
};