#pragma once

template<class C> class CSafeBase
{
private:	
						CSafeBase(const CSafeBase&)
	{
	};
						CSafeBase& operator=(const CSafeBase&)
	{
	};

protected:
	C					m_Type;

public:
	C&					Get()
	{
						return m_Type;
	}
	const C&			Get() const
	{
						return m_Type;
	}

						CSafeBase(C Type)
	{
		m_Type=Type;
	}
						virtual ~CSafeBase()
	{
	};
};

template<class C> class CSafe //DUMMY
{
};

template<> class CSafe<SC_HANDLE> : public CSafeBase<SC_HANDLE>
{
public:
						CSafe(SC_HANDLE pType) : CSafeBase(pType)
	{
	}

						~CSafe()
	{
		CloseServiceHandle(m_Type);
	}
};
//... weitere spezielle CSafe#s für andere Windows-Typen

template<> class CSafe<void*> : public CSafeBase<void*>
{
private:
	bool				m_bArray;

public:
						CSafe(void* pType, const bool& bArray) : CSafeBase(pType)
	{
		m_bArray=bArray;
	}

						~CSafe()
	{
		if(m_bArray)
		{
			delete[] m_Type;
		}
		else
		{
			delete m_Type;
		}
	}
};

ist dies so OK oder seht ihr Probleme?
Danke,
S.

a. Versteh ich nicht?
b. Gemacht
c. Gemacht.
d. Das ist mir zu aufwendig. ich brauche die Klasse hauptsächlich für lokale Funktion, welche am Anfang verschiedene WinAPI-Handels erstellen... Da brauche ich die Zuweisung einfach nicht

ist dies so OK oder seht ihr Probleme?

Nun ja; Es übersetzt nicht, weil SC_HANDLE und 'CloseServiceHandle( SC_HANDLE )' nicht definiert sind. Davon abgesehen kann man keinen 'allgemeinen Smart-Pointer' für z.B. ein int anlegen.

Warum nicht einfach die sehr schönen und praxis-erprobten Smart-Pointer von boost verwenden.

Dort kann man auch ein CloseServiceHandle mit einbauen. Etwa so:

#include <boost/shared_ptr.hpp>
SC_HANDLE getHandleIrgendwoher();
typedef /*implementation depended*/ DEREF_SC_HANDLE; // bei windows-HANDLE wäre das z.B. void
    // ...
    boost::shared_ptr< DEREF_SC_HANDLE> hnd( getHandleIrgendwoher(), &CloseServiceHandle );
    // Zugriff über hnd.get()

bei Löschen der letzten Kopie von 'hnd' wird CloseServiceHandle gerufen.

Gruß
Werner

Davon abgesehen kann man keinen 'allgemeinen Smart-Pointer' für z.B. ein int anlegen.

Wollte ich ja gar nicht. Eigentlich nur für Windows-Handles und für mit new oder new[] allokierte Speicherbreiche

Boost kenne ich nicht, wobei

boost::shared_ptr< DEREF_SC_HANDLE> hnd( getHandleIrgendwoher(), &CloseServiceHandle );

mir schon zu lang ist

Safe<SC_HANDLE> Manager(getHandleIrgendwoher());

ist doch viel schöner?

a. Versteh ich nicht?

kurz: "CSafe(void* val,const bool& isarray)" ist Overkill - für eingebaute Typen ist "CSafe(void* val,bool isarray)" praktischer.

@WinAPI-Handles: Da solltest du eventuell auf eine Bibliothek wie MFC umsteigen, damit hättest du für jeden Handle-Typ eine passende Wrapper-Klasse.
(außerdem sind afaik die meisten HANDLE-Typen nur typedef's auf long, also kannst du deine CSafe-Klasse nicht getrennt für (z.B.) HWND und HDC spezialisieren)

SC_HANDLE ist von der WindowsTreiberProgrammierung

Davon abgesehen kann man keinen 'allgemeinen Smart-Pointer' für z.B. ein int anlegen.

Wollte ich ja gar nicht. Eigentlich nur für Windows-Handles und für mit new oder new[] allokierte Speicherbreiche

Klaro! hinter new steht doch immer ein Typ - z.B. int oder halt sowas wie MyClass. Und mit Deinem Code kannst Du kein

CSafe< MyClass > p( new MyClass ); // compiliert nicht

schreiben, da es keine allgemeine Implementierung gibt. Die Variante mit void* ist nicht typsicher und bringt Unsicherheiten.

Socker schrieb:

Boost kenne ich nicht,

was nicht ist, kann ja werden . C++ machen und boost nicht kennen ist - wie soll ich sagen - ist einfach indiskutabel; da fehlt einfach was.

Socker schrieb:

wobei

boost::shared_ptr< DEREF_SC_HANDLE> hnd( getHandleIrgendwoher(), &CloseServiceHandle );

mir schon zu lang ist

.. kürzer als Deine Klasse

Gruß
Weerner

class C
	{

	};
	CSafe<C*> T(new C);

//mit...

template<class T> class CSafe<T*> : public CSafeBase<T*>
{
private:
	bool				m_bArray;

public:
						CSafe(T* pType, const bool& bArray=false) : CSafeBase(pType)
	{
		m_bArray=bArray;
	}

						~CSafe()
	{
		if(m_Type)
		{
			if(m_bArray)
			{
				delete[] m_Type;
			}
			else
			{
				delete m_Type;
			}
		}
	}
};

Anyway, boost werde ich mir dann mal zu Gemüte führen