NULL undefiniert (in singelton Klasse)

pospiech

Ich bekomme folenden Fehler, den ich überhaupt nicht verstehe:

1>e:\Daten\Dev\SVN\hibiscus\Cpp\AdvancedBeamShaping\QBeamShaping\include\matthias\Common\singleton.h(26) : error C2065: 'NULL': nichtdeklarierter Bezeichner
1> e:\Daten\Dev\SVN\hibiscus\Cpp\AdvancedBeamShaping\QBeamShaping\include\matthias\Common\singleton.h(25): Bei der Kompilierung der Klassen-template der Singleton<C>::CGuard::~CGuard(void)-Memberfunktion
1> with
1> [
1> C=ApplicationMessage
1> ]

Die Klasse (die ein Sinleton sein soll) ist relativ simpel:

#include "singleton.h"
#include "widgetDockErrorMessage.h"
#include <QtCore/QPointer>

class ApplicationMessage;

class ApplicationMessage : public Singleton<ApplicationMessage>
{	
public:
	ApplicationMessage();
	virtual ~ApplicationMessage();

	friend class Singleton <ApplicationMessage>;
    static ApplicationMessage* instance ()
    {
       return Singleton <ApplicationMessage>::instance ();
    }

	void setWidget(widgetDockErrorMessage * widget)
	{
		this->widget = widget;
	}

	void addMessage(QString message) 
	{
		if (widget)
			widget->addError(message);
	}
private:
	QPointer<widgetDockErrorMessage> widget;

};

ApplicationMessage::ApplicationMessage() : Singleton <ApplicationMessage> () 
{
}

ApplicationMessage::~ApplicationMessage()
{
}

Die Singelton Klasse funktioniert schon in diversen Projekten und Klassen udn sieht wie folgt aus:

#ifndef SINGLETON_H_
#define SINGLETON_H_

template <typename C>
class Singleton
{
public:
    static C* instance ()
    {
		static CGuard g;   // Speicherbereinigung
        if (!_instance)
          _instance = new C ();
        return _instance;
    }
    virtual ~Singleton ()
    {
       _instance = 0;
    }

private:
	class CGuard
    {
    public:
       ~CGuard()
       {
          if( NULL != C::_instance )
          {
             delete C::_instance;
             C::_instance = NULL;
          }
       }
    };
    friend class CGuard;

	static C* _instance;
	Singleton( const Singleton& ); /* verhindert, dass eine weitere Instanz via
									Kopie-Konstruktor erstellt werden kann */
    Singleton & operator = (const Singleton &); //Verhindert weitere Instanz durch Kopie

protected:
    Singleton () { }
};

template <typename C> C* Singleton <C>::_instance = 0;

#endif

Warum könnte hier jetzt NULL unbekannt sein?

Tachyon

Vermutlich hast Du in diesem Projekt keinen der std-Header inkludiert, in denen NULL definiert wird (also bevor Singleton inkludiert wird, meine ich). Im Zweifelsfall solltest Du cstdlib in singleton inkludieren.

Dravere

Tachyon schrieb:

Vermutlich hast Du in diesem Projekt keinen der std-Header inkludiert, in denen NULL definiert wird (also bevor Singleton inkludiert wird, meine ich). Im Zweifelsfall solltest Du cstdlib in singleton inkludieren.

Oder vielleicht gleich auf den nullptr umsteigen?
http://www.c-plusplus.net/forum/viewtopic-var-t-is-220511.html

Grüssli

Tachyon

Dravere schrieb:

Tachyon schrieb:

Vermutlich hast Du in diesem Projekt keinen der std-Header inkludiert, in denen NULL definiert wird (also bevor Singleton inkludiert wird, meine ich). Im Zweifelsfall solltest Du cstdlib in singleton inkludieren.

Oder vielleicht gleich auf den nullptr umsteigen?
http://www.c-plusplus.net/forum/viewtopic-var-t-is-220511.html

Grüssli

Jo, das ist natürlich noch besser.

0 hinschreiben, geht auch.