C++语法游戏之，模拟C#的using(...){}

2003-05-18 05:33:59 80 阅读 AI 写同款 · GEO 优化AI 选题数据监测一键分发 ›

lostinetdotcom 墨衍会员 · AI 创作全网分发关注 + 加入社区

VirtualBox创建虚拟机（为安装Ubuntu桌面系统） Ubuntu的安装非常灵活。但是万变不离其宗，归纳起来，无非就是以下3种：（1）用户可以下载完整的ISO镜像文件，将其转移到各种介质上面，例如DVD或者U盘，然后以该介质引导系统进行安装。（2）用户可以下载一个非常小的网络安装器，利用该安装器引导系统进行在线安装。（3）用户可以将Ubuntu安装到一个U盘中，随身携带。为了便于读者学习，本节将介绍通过完整的ISO镜像文件安装Ubuntu。其他的安装方式将在后面介绍。阅读详情

C++语法游戏之，模拟C#的using(...){}
游戏而已，，可以用来锻炼脑筋。。~~

//using.h

#pragma once

//for IUnknown
#include "atlbase.h"

#define USING_SCOPE_ASSERT(x) ATLASSERT(x);

#define USING_SCOPE_INLINE inline

#define Using(expression) if(UsingScope UsingScope_LocalVar=(expression))

class UsingScope
{
class Container
{
public:
virtual ~Container()
{
}
};

Container* pc;
public:
USING_SCOPE_INLINE operator bool ()
{
return true;
}

USING_SCOPE_INLINE ~UsingScope()
{
delete pc;
}

template<typename T>
class SimplePointerContainer:public Container
{
T* p;
public:
SimplePointerContainer(T* p)
{
USING_SCOPE_ASSERT(p!=NULL);
this->p=p;
}
virtual ~SimplePointerContainer()
{
delete p;
}
};

template<typename T>
USING_SCOPE_INLINE UsingScope(T* p)
{
pc=new SimplePointerContainer<T>(p);
}

class IUnknownContainer:public Container
{
IUnknown* punk;
public:
IUnknownContainer(IUnknown* punk)
{
USING_SCOPE_ASSERT(punk!=NULL);
this->punk=punk;
}
virtual ~IUnknownContainer()
{
punk->Release();
}
};
USING_SCOPE_INLINE UsingScope(IUnknown* punk)
{
pc=new IUnknownContainer(punk);
}

class BSTRContainer:public Container
{
BSTR bstr;
public:
BSTRContainer(BSTR bstr)
{
USING_SCOPE_ASSERT(bstr!=NULL);
this->bstr=bstr;
}
virtual ~BSTRContainer()
{
SysFreeString(bstr);
}
};
USING_SCOPE_INLINE UsingScope(BSTR bstr)
{
pc=new BSTRContainer(bstr);
}

//vc7 m 可以为System::IDisposable* 添加 .Dispose() 的调用
//以支持所有的dotnet System::IDisposable的实现者
};

//usingT.h

#include "Using.h"

#define UsingT(type,varname,expression) if(UsingScopeT<type> varname=(expression))

template<typename T>
class UsingScopeT
{
template<typename T>
class Container
{
public:
T* p;
Container(T* p)
{
USING_SCOPE_ASSERT(p!=NULL);
this->p=p;
}
virtual ~Container(){}
};

Container<T>* pc;
public:
USING_SCOPE_INLINE operator bool ()
{
return true;
}

USING_SCOPE_INLINE T* operator -> ()
{
return (pc->p);
}
USING_SCOPE_INLINE operator T*() const
{
return (T*)(pc->p);
}
USING_SCOPE_INLINE T& operator*() const
{
return *(pc->p);
}
USING_SCOPE_INLINE T** operator&()
{
return &(pc->p);
}
USING_SCOPE_INLINE bool operator==(T* pT) const
{
return (pc->p) == pT;
}

USING_SCOPE_INLINE ~UsingScopeT()
{
delete pc;
}

template<typename T>
class SimplePointerContainer:public Container<T>
{
public:
SimplePointerContainer(T* p):Container<T>(p)
{
}
virtual ~SimplePointerContainer()
{
delete p;
}
};
template<typename T>
USING_SCOPE_INLINE UsingScopeT(T* p)
{
pc=new SimplePointerContainer<T>(p);
}

class IUnknownContainer:public Container<IUnknown>
{
public:
IUnknownContainer(IUnknown* punk):Container<IUnknown>(punk)
{
}
virtual ~IUnknownContainer()
{
p->Release();
}
};
USING_SCOPE_INLINE UsingScopeT(IUnknown* punk)
{
pc=new IUnknownContainer(punk);
}

class BSTRContainer:public Container<OLECHAR>
{
public:
BSTRContainer(BSTR bstr):Container<OLECHAR>(bstr)
{
}
virtual ~BSTRContainer()
{
SysFreeString(p);
}
};
USING_SCOPE_INLINE UsingScopeT(BSTR bstr)
{
pc=new BSTRContainer(bstr);
}

//vc7 m 可以为System::IDisposable* 添加 .Dispose() 的调用
//以支持所有的dotnet System::IDisposable的实现者
};

//Using.Cpp

// Using.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"

#include "atlbase.h"

#include "Using.h"
#include "UsingT.h"

class ClassA
{
public:
ClassA()
{
_tprintf(_T("ClassA()\n"));
}
virtual ~ClassA()
{
_tprintf(_T("~ClassA()\n"));
}

virtual void Write()
{
_tprintf(_T("ClassA::Write\n"));
}
};
class ClassB:public ClassA
{
public:
virtual void Write()
{
_tprintf(_T("ClassB::Write\n"));
}
};

ClassA* CreateClassA()
{
return new ClassB();
}

IUnknown* ReturnUnknown()
{
HRESULT hres;
IUnknown* p;
CLSID cid;
hres=CLSIDFromProgID(L"JScript",&cid);
hres=CoGetClassObject(cid,CLSCTX_INPROC_SERVER,NULL,IID_IClassFactory,(void**)&p);
return p;
}

void DoIt()
{
CoInitialize(NULL);

IUnknown* punk;
Using(punk=ReturnUnknown())
{
ClassA* pa;
Using(pa=CreateClassA())
{
_tprintf(_T("DoWork\n"));
pa->Write();
}
}

UsingT(ClassB,pb,new ClassB())
{
pb->Write();
ClassA* pa=pb;
if(pa==pb)
pa->Write();
}

UsingT(IUnknown,p,ReturnUnknown())
{
//p->..
}

CoUninitialize();
}

int main(int argc, char* argv[])
{
DoIt();
return 0;
}

...全文