Russian Qt Forum

C++ (Qt)
MyOpaqueRef * ref = CreateOpaqueRef(name);
....
// return; ???
...
DestroyOpaqueRef(ref);
 

C++ (Qt)
#define RETURN_AND_DELETE_REF(ref) DestroyOpaqueRef(ref); return
 
MyOpaqueRef * ref = CreateOpaqueRef(name);
...
RETURN_AND_DELETE_REF(ref);
...
RETURN_AND_DELETE_REF(ref) 0;

C++ (Qt)
#define RETURN_AND_DELETE_REF(ref) DestroyOpaqueRef(ref, ...) DestroyOpaqueRef(ref); return __VA_ARGS
 
MyOpaqueRef * ref = CreateOpaqueRef(name);
...
RETURN_AND_DELETE_REF(ref);
...
RETURN_AND_DELETE_REF(ref, 0);

C++ (Qt)
struct CScoped_OpaqueRef {
	CScoped_OpaqueRef( OpaqueRef * ref ) : mRef(ref) {}
       ~CScoped_OpaqueRef( void )		{ if (mRef) DestroyOpaqueRef(mRef); }	
	operator OpaqueRef * ( void )		{ return mRef; }
 
	void operator = ( OpaqueRef * ref ) 
	{
		if (mRef != ref) {
			if (mRef) DestroyOpaqueRef(mRef);
			mRef = ref;
		}	
	}
 
private:	
	OpaqueRef * mRef;
	CScoped_OpaqueRef( const CScoped_OpaqueRef & ref ) {}
	void operator = ( const CScoped_OpaqueRef & ref ) {}
};
 

C++ (Qt)
struct CScoped_OpaqueRef {
	CScoped_OpaqueRef( OpaqueRef * ref ) : mRef(ref) {}
       ~CScoped_OpaqueRef( void )		{ if (mRef) DestroyOpaqueRef(mRef); }	
	operator OpaqueRef * ( void )		{ return mRef; }
 
	void operator = ( OpaqueRef * ref ) 
	{
		if (mRef != ref) {
			if (mRef) DestroyOpaqueRef(mRef);
			mRef = ref;
		}	
	}
 
private:	
	OpaqueRef * mRef;
	CScoped_OpaqueRef( const CScoped_OpaqueRef & ref ) {}
	void operator = ( const CScoped_OpaqueRef & ref ) {}
};
 

C++ (Qt)
std::unique_ptr<OpaqueRef, DestroyOpaqueRef> ref = CreateOpaqueRef(name);
 

template <class Ref, class Deleter>
struct CScopedRef {
..

C++ (Qt)
template <typename TRef, typename TDeleter>
struct CScopedRef {
	CScopedRef( TRef * ref ) : mRef(ref) {}
	~CScopedRef( void )		{ if (mRef) TDeleter(mRef);	}	
	operator TRef * ( void )	{ return mRef; }
 
	void operator = ( TRef * ref ) 
	{
		if (mRef != ref) {
			if (mRef) TDeleter(mRef);
			mRef = ref;
		}	
	}
 
private:
	TRef * mRef;
	CScopedRef( const CScopedRef & ) {}
	void operator = ( const CScopedRef & ) {}
};
 
typedef CScopedRef <OpaqueRef, DestroyOpaqueRef> CScopedOpaqueRef;
 

C++ (Qt)
template <typename TRef, typename TDeleter = default_deleter>
struct CScopedRef {
	CScopedRef( TRef * ref, TDeleter deleter) : mRef(ref), mDeleter(deleter) {}
        CScopedRef( TRef * ref) : mRef(ref) {}
	~CScopedRef( void )		{ if (mRef) mDeleter(mRef);	}	
	operator TRef * ( void )	{ return mRef; }
 
	void operator = ( TRef * ref ) 
	{
		if (mRef != ref) {
			if (mRef) mDeleter(mRef);
			mRef = ref;
		}	
	}
 
private:
	TRef * mRef;
        TDeleter mDeleter;
	CScopedRef( CScopedRef & )
	void operator = ( CScopedRef & )
};
 

C++ (Qt)
typedef void (*FunctionType)(Ref *);
CScopedRef<Ref, FunctionType> ref(new Rew, DestroyOpaqueRef);
 

C++ (Qt)
template<typename T, void (*destroyer)( T )>
struct CScopedRef {
{
public:
        ~CScopedRef() { destroyer( mRef ); }
 

C++ (Qt)
typedef unsigned int HANDLE;
 
HANDLE create( ... );
destroy( HANDLE );
 

C++ (Qt)
CScoped<Data *, DestroyData> d1 = CreateData( ... );
CScoped<HANDLE, destroy> d2 = create( ... );
 

C++ (Qt)
template <typename TRef, void (*delFunc)(TRef *)>
struct CScopedRef {
	CScopedRef( TRef * ref ) : mRef(ref) {}
	~CScopedRef( void )		{ if (mRef) delFunc(mRef);	}	
	operator TRef * ( void )	{ return mRef; }
 
	void operator = ( TRef * ref ) 
	{
		if (mRef != ref) {
			if (mRef) delFunc(mRef);
			mRef = ref;
		}	
	}
 
private:
	TRef * mRef;
	CScopedRef( const CScopedRef & ) {}
	void operator = ( const CScopedRef & ) {}
};
 
typedef CScopedRef <OpaqueRef, DestroyOpaqueRef> CScopedOpaqueRef;
 

C++ (Qt)
OpaqueRef * src = CreateOpaqueRef();
CScopedOpaqueRef ref1(src);  // Ок
CScopedOpaqueRef ref2 = src;  // error
 

C++ (Qt)
explicit CScopedRef( TRef * ref ) 
 

Some obj = 10;

C++ (Qt)
Some obj;
obj = 10;   // вызывается оператор присваивания 
..
Some obj2 = 10;   // вызывается конструктор (но не оператор присваивания) 
 

C++ (Qt)
#include <iostream>
#include <memory>
 
void deleter(int *) {
    std::cout << "user deleter" << std::endl;
}
 
typedef void (*func_t)(int *);
 
int main()
{
 
    std::unique_ptr<int, func_t> p(new int(10), deleter);
 
    return 0;
}
 
 

C++ (Qt)
template <class Ref, class Deleter>
void TestProc( Ref * ref, Deleter del )
{
	del(ref);
}
 
void MyDel	( int * a )	{ printf("%d\n", *a); }
int  MyDel2	( int * a )	{ return *a + 1; }
 
int main( void )
{
	int a = 5;
	TestProc(&a, MyDel);
	TestProc(&a, MyDel2);
 
	return 0;
}

C++ (Qt)
        TestProc(&a, MyDel);
	TestProc(&a, MyDel2);
 

C++ (Qt)
#include <stdio.h>
 
struct CTest {
	CTest( int a ) : mA(a) 
	{
		printf("def ctor\n");
	}
 
	CTest( const CTest & src ) 
	{
		printf("copy ctor\n");
		mA = src.mA;
	}
 
	int mA;  
};
 
int main( void )
{
	CTest test = 5;
	return 0;
}
 

C++ (Qt)
typedef void (*DestroyFunc)(OpaqueRef);
std::unique_ptr<OpaqueRef, DestroyFunc> p(CreateOpaqueRef(name), DestroyOpaqueRef);
 

C++ (Qt)
void DoSomething( OpaqueRef * );
..
DoSomething(p);   // а так нельзя
DoSomething(p.get());   // можно так 
DoSomething(& *p);   // хммм...