identif: .) Rückgabewert void
.) keine Parameter
.) setzt identified auf true
.) Ausgabe (I/O-Handler): "[NichtIdentifizierterName] is identified as [IdentifizierterName]"

destroy: .) Rückgabewert void
.) keine Parameter
.) setzt destroyerd auf true
.) Ausgabe (I/O-Handler): "[Objektname] is destroyed"

getName .) Rückgabewert Zeichenkette
.) keine Parameter
.) retourniert, basierend auf identified, den richtigen Member

Noch eine Beschreibung der Klassen:

Members:
- IOHandler& handler_
- char* name_identified_
- char* name_not_identified_
- char* use_message_
- bool identified_
- bool destroyed_

Methoden:
+ virtual bool use(const Character& character) const
Wird ausgeführt, wenn der Charakter ein Objekt verwendet. In der jetzigen Version wird
nur eine Meldung (siehe Angabe) ausgegeben und true zurückgegeben (success).

+ virtual void identify()
Setzt das Attribut identified auf true. Eine Meldung (siehe Angabe) wird ausgegeben.

+ virtual void destroy()
Setzt das Attribut destroyed auf true. Eine Meldung (siehe Angabe) wird ausgegeben.

+ virtual char *getName() const
Gibt den identifizierten Namen des Objekts zurück, wenn identified_ true ist. Sonst gibt
die Methode den nicht identifizierten Namen des Objekts zurück.

Ich weiß es ist sehr viel zu lesen. aber ich wäre sehr dankbar für nützliche Tipps!

Danke im voraus!

mfg rene

#ifndef OBJECT_H
#define OBJECT_H

class Object
{
private:
IOHandler& handler_;
char* name_identified_;
char* name_not_identified_;
char* use_message_;
bool identified_;
bool destroyed_;

public:
Object(IOHandler& handler, char* name_identified, char* name_not_identified, char* use_message, bool identified, bool destroyed);
~Object();
virtual bool use(const Character& character) const;
virtual void identify();
virtual void destroy();
virtual char *getName() const;

};

#endif

und hier der Teil wo ich mich nicht auskenne:

#include <iostream>
#include <cstring>

#include "Object.h"

//Constructor
Object::Object(IOHandler& handler,	char* name_identified,	char* name_not_identified,
	             char* use_message, bool identified, bool destroyed) 
							 :handler_(handler), name_identified_(name_identified), name_not_identified_(name_not_identified),
							 use_message(use message), identified_(identified), destroyed_(destroyed)
{ 

}
//Destructor
Object::~Object()
{

}

virtual bool use (const Character& character) const
{
 return 0;
}

virtual void identify()
{
	object_identified = true;
	handler_.printMessage("[NichtIdentifizierterName] is identified as [IdendifizierterName]");
	return;
}

virtual void destroy()
{
	destroyed = true;
	handler.printMessage("[ObjektName] is destroyed");
	return;
}

Des Weiteren kannst du klassenintern durchaus std::strings verwenden. Entscheidend ist ja, dass das Interface gleich bleibt. Eben darum hat man ja auch OOP erdacht.

Grüße ... Heiko

mfg

Die Beschreibungen, was die einzelnen Methoden erledigen sollen, sind gegeben. Im Grunde musst Du das nur noch umsetzen. Das sind Grundlagen, welche Du Dir durch entsprechende Lektüre (im Forum gibt es einige Buchvorschläge und auch Titel, um welche man einen Bogen machen sollte) relativ schnell selbst aneignen kannst.

Des weiteren noch einige Anmerkungen zu deinem Code:

* Const-Correctness beachten
* (ich wiederhole nochmal) STL-Klassen gehören nicht umsonst zum Standard
* Die Deklaration der Methoden als virtuell scheint mir (mit Ausnahme von use) überflüssig.

Grüße ... Heiko