不过快速开发时，我们并不会局限于一种语言，很多时候都是混用多种语言，实现一个强大又绚丽的UI的软件，而且可以保证开发速度很快。

　　每一种语言都有独特的优势，有优势的部分恰恰就是很适合应用的场景，因此编码实现方便快速。并不是说C++开发程序就一定很慢，也不是说C#开发程序就一定快。如果要做偏底层的功能，往往C++实现起来还是很快，而且程序的执行效率也是很高的。对于底层的操作，使用C#等语言来说，就非常不方便。比如调用个系统API函数，C/C++包含一个头文件，然后直接写函数名称即可，而其他语言则比较麻烦了。因为他们要通过一层函数库的封装间接调用底层API的，所以也就很麻烦了。

　　不过，正是封装的多，使用的库多，对于C#这类语言来说，实现界面就很快了。所以说，做UI是他们的长处，所以也很简单。

　　那么既然如此，我们就将C++和C#结合来使用就很好，这叫做强强联合！选择C#也是因为语法上和C++很相似，VB这些语言语法和C++相差很大，不习惯。

　　那么C++做底层功能封装和C#界面开发如何混合起来呢？这个估计是大家最为关心的一个问题吧。在实现界面时，C#可以选择wpf做界面，非常的不错。学习难度也不大，C#代码，对于C++熟悉的人，也觉得很好掌握。C++从业者去使用C#问题不大，只是会多吐槽一下C#的不方便操作指针之类的，不过C#的string确实挺不错的，我蛮喜欢。

　　C++封装代码成dll形式提供给C#等语言使用。C++代码中，你可以尽情的使用类来完成功能，只是在导出函数时，只要提供C语言的函数，而不要将类导出，不建议这么做。而导出函数时，为了让更多语言方便使用dll，导出函数使用C调用约定导出函数。一般语言都支持标准C函数调用约定。

　　更多的细节，就不在本文讲述。这里就是概述性的给大家一个印象，让你知道写程序还可以这样玩哦。不要将自己的思维局限于一种语言，不要再为学习哪一种语言而纠结，也不要为哪一种语言好而争执。

　　不过，初学者总要选定一种语言作为出发，而我的建议时，学习时尽可能基础而全面的学习。在入门的时候，相对来说是比较沉得下心学习的。所以选择学习C++作为入门语言是非常不错的选择。当你C++学的不错的时候，再学其他语言做应用开发，都是轻松掌握的。但是如果工作了，再来学习C++，精力有限，而且很难静下心学习又大又全又细的C++。

　　然而做底层开发时，C++无疑是一个很好的选择。如果C++借用界面库，自然也是可以做很不错的UI的。其他语言之所以可以快速开发，也就是有很多库的支持。当C++的第三方库多了，开发速度自然也是很不错的。

　　如果你有一些不错的想法，就到C++技术网分享下吧。我会仔细阅读每一个字透露出来的气息，给你分享我的相关经验，尽量开阔你的思维范围，一起进步。

全讯网,www.hz1s.com 

　　什么是RAII以及几个例子

　　在C++等面向对象语言中，为了管理局部资源的分配以及释放(resource allocation and deallocation)，实现异常安全(exception-safe)、避免内存泄露等问题，C++之父Bjarne Stroustrup发明了一种叫做”初始化中获取资源“ (RAII, Resource Acquisition Is Initialization，也可以叫做Scope-Bound Resource Management)的技术。简单来说，它的目的就是利用一个局部对象，在这个对象的构造函数内分配资源，然后在其析构函数内释放资源。这样，当这个局部对象退出作用域时，它所对应的的资源即可自动释放。在实现上，它通常有三个特点：

　　创建一个特殊类，在其构造函数初申请资源;

　　封装目标对象，将申请资源的目标对象作为这个特殊类的成员变量;

　　在这个类的析构函数内，释放资源。

　　一个典型的例子就是标准库中提供的模板类std::auto_ptr。如在《C++程序设计语言》(《The C++ Programming Language, Special Edition》, Bjarne Stroustrup著，裘宗燕译)中第327页所描述的SAT答案

　　1: template

　　2: class std::auto_ptr {

　　3:

　　4: public:

　　5: //在构造函数中，获得目标指针的管理权

　　6: explicit auto_ptr(X *p = 0) throw() { ptr = p; }

　　7: //在析构函数中，释放目标指针

　　8: ~auto_ptr() throw() { delete ptr; }

　　9:

　　10: //...

　　11:

　　12: //重装*和->运算符，使auto_ptr对象像目标指针ptr一样使用

　　13: X& operator*() const throw() { return *ptr; }

　　14: X* operator->() const throw() { return ptr; }

　　15:

　　16: //放弃对目标指针的管理权

　　17: X* release() throw() { X* t = ptr; ptr = 0; return t; }

　　18:

　　19: private:

　　20: X *ptr;

　　21: };

　　想要使用它，非常简单，例如

　　1: #include

　　2:

　　3: void func()

　　4: {

　　5: std::auto_ptr p(new int);

　　6:

　　7: //use p just like ptr

　　8:

　　9: return;

　　10: }

　　另一个例子，是利用GCC中的cleanup attribute。它可以指定一个函数，在该变量退出作用域时可以执行。例如Wikipedia上提到的宏

　　1: #define RAII_VARIABLE(vartype,varname,initval,dtor) \

　　2: void _dtor_ ## varname (vartype * v) { dtor(*v); } \

　　3: vartype varname __attribute__((cleanup(_dtor_ ## varname))) = (initval)

　　我们可以这样使用，例如

　　1: void example_usage() {

　　2: RAII_VARIABLE(FILE*, logfile, fopen("logfile.txt", "w+"), fclose);

　　3: fputs("hello logfile!", logfile);

　　4: }

　　还有一个例子，是在刘未鹏的博客文章”C++11 (及现代C++风格)和快速迭代式开发“中的”资源管理“一节中看到的，他借助C++11的std::function实现了这一特性。感兴趣的码友可以到他博客内阅读。

　　笔者采用的方法

　　对于new/delete，使用上面提到的std::auto_ptr就可以了，但是对于new/delete[]一个动态的一维数组，甚至二维数组，auto_ptr就无能为力了。而且在一些项目中，特别是一些有着悠久历史的代码中，还存在着使用malloc, new混用的现象。所以笔者设计了一个auto_free_ptr类，实现目标资源的自动回收。它的实现比较简单，只利用了RAII的第三个特点——”在类的析构函数内释放资源”，但有一个优点是可以在申请堆内存代码前使用托福答案

　　代码如下，

　　1: //auto_free_ptr is only used for automation free memory

　　2: template

　　3: class auto_free_ptr

　　4: {

　　5: public:

　　6: typedef enum {invalid, new_one, new_array, alloc_mem} EFLAG;

　　7: auto_free_ptr() { initialize(); }

　　8: ~auto_free_ptr(){ free_ptr(); }

　　9:

　　10: ///set the pointer needed to automatically free

　　11: inline void set_ptr(T** new_ptr_address, EFLAG new_eflag)

　　12: { free_ptr(); p_ptr = new_ptr_address; eflag = new_eflag; }

　　13:

　　14: ///give up auto free memory

　　15: inline void give_up() { initialize(); }

　　16:

　　17: protected:

　　18: inline void initialize() { p_ptr = NULL; eflag = invalid; }

　　19: inline void free_ptr() throw()

　　20: {

　　21: if(!p_ptr || !(*p_ptr)) return;

　　22:

　　23: switch(eflag)

　　24: {

　　25: case alloc_mem: { free(*p_ptr), (*p_ptr) = NULL, p_ptr = NULL; break; }

　　26: case new_one: { delete (*p_ptr), (*p_ptr) = NULL, p_ptr = NULL; break; }

　　27: case new_array: { delete[] (*p_ptr),(*p_ptr) = NULL, p_ptr = NULL; break; }

　　28: }

　　29: }

　　30:

　　31: protected:

　　32: T** p_ptr; //!< pointer to the address of the set pointer needed to automatically free

　　33: EFLAG eflag; //!< the type of allocation

　　34:

　　35: private:

　　36: DISABLE_COPY_AND_ASSIGN(auto_free_ptr);

　　37: };
　　为了使用方便，封装两个宏：

　　1: // auto-free macros are mainly used to free the allocated memory by some local variables in the internal of function-body

　　2: #define AUTO_FREE_ENABLE( class, ptrName, ptrType ) \

　　3: auto_free_ptr auto_free_##ptrName; \

　　4: auto_free_##ptrName.set_ptr(&ptrName,auto_free_ptr::ptrType)

　　5:

　　6: #define AUTO_FREE_DISABLE( ptrName ) auto_free_##ptrName.give_up()

　　使用起来很简单，例如

　　1: void func(int nLftCnt, int nRhtCnt)

　　2: {

　　3: if (!nLftCnt && !nRhtCnt)

　　4: return;

　　5:

　　6: unsigned *pLftHashs = NULL;

　　7: unsigned *pRhtHashs = NULL;

　　8:

　　9: //在申请堆内存之前，使用auto_free_ptr

　　10: AUTO_FREE_ENABLE(unsigned, pLftHashs, new_array);

　　11: AUTO_FREE_ENABLE(unsigned, pRhtHashs, new_array);

　　12:

　　13: //....

　　14:

　　15: if (nLftCnt)

　　16: {

　　17: pLftHashs = new unsigned[nLftCnt];

　　18: //...a

　　19: }

　　20:

　　21: if (nRhtCnt)

　　22: {

　　23: pRhtHashs = new unsigned[nRhtCnt];

　　24: //...b

　　25: }

　　26:

　　27: //....

　　28:

　　29: if (...)

　　30: {

　　31: //因为下面这个函数可以释放资源，所以在它前面放弃对目标指针的管理权

　　32: AUTO_FREE_DISABLE(pLftHashs);

　　33: AUTO_FREE_DISABLE(pRhtHashs);

　　34:

　　35: //这个函数可以释放资源

　　36: free_hash_arrays(pLftHashs, pRhtHashs);

　　37: }

　　38: }

　　同样的，有时我们需要申请一个动态二维数组，所以也实现一个对应的auto_free_2D_ptr

　　1: //auto_free_2D_ptr is only used for automation free memory of 2D array

　　2: template

　　3: class auto_free_2D_ptr

　　4: {

　　5: public:

　　6: typedef enum {invalid, new_one, new_array, alloc_mem} EFLAG;

　　7: auto_free_2D_ptr() { initialize(); }

　　8: ~auto_free_2D_ptr() { free_ptr(); }

　　9:

　　10: ///set the pointer needed to automatically free

　　11: inline void set_ptr( T** new_ptr_address,EFLAG new_eflag, int new_length_row )

　　12: { free_ptr(); p_ptr = new_ptr_address; eflag = new_eflag; length_row = new_length_row; }

　　13:

　　14: //give up auto free memory

　　15: inline void give_up() { initialize(); }

　　16:

　　17: protected:

　　18: inline void initialize() { p_ptr = NULL; eflag = invalid; length_row = 0;}

　　19: inline void free_ptr() throw()

　　20: {

　　21: if(!p_ptr || !(*p_ptr)) return;

　　22:

　　23: for(int i = 0; i < length_row; i++)

　　24: {

　　25: if(!(*p_ptr)[i]) continue;

　　26: switch(eflag)

　　27: {

　　28: case alloc_mem: { free((*p_ptr)[i]); break; }

　　29: case new_one: { delete (*p_ptr)[i]; break; }

　　30: case new_array: { delete[] (*p_ptr)[i]; break; }

　　31: }

　　32: (*p_ptr)[i] = NULL;

　　33: }

　　34: switch(eflag)

　　35: {

　　36: case alloc_mem: { free((*p_ptr)); break; }

　　37: default: { delete[] (*p_ptr); break; }

　　38: }

　　39: (*p_ptr) = NULL, p_ptr = NULL;

　　40: }

　　41:

　　42: protected:

　　43: T** p_ptr; //!< pointer to the address of the set pointer needed to automatically free

　　44: EFLAG eflag; //!< the type of allocation

　　45: int length_row; //!< the row length such as ptr[length_row][length_col]

　　46:

　　47: private:

　　48: DISABLE_COPY_AND_ASSIGN(auto_free_2D_ptr);

　　49: };

　　50:

　　51: #define AUTO_FREE_2D_ENABLE( class, ptrName, ptrType, rowNum ) \

　　52: auto_free_2D_ptr auto_free_##ptrName; \

　　53: auto_free_##ptrName.set_ptr(&ptrName,auto_free_2D_ptr::ptrType, rowNum)

　　54:

　　55: #define AUTO_FREE_2D_DISABLE( ptrName ) AUTO_FREE_DISABLE( ptrName )

　　下面是个例子

　　1: void func(int row, int col)

　　2: {

　　3: if (!row && !col)

　　4: return;

　　5:

　　6: int **ptr = new int*[ row ];

　　7: for( int r = 0; r < row; ++r ) { ptr[r] = new int[ col ];}

　　8:

　　9: AUTO_FREE_2D_ENABLE( int, ptr, new_array, row );

　　10:

　　11: //....

　　12: }

　　到这里就结束了，有些码友可能会说，何必这么麻烦，boost内有很多智能指针供选择，用share_ptr, scoped_ptr, scoped_array，unique_ptr, auto_ptr 中的一个不就行了吗? 没错!如果你正在开发的代码中，允许用boost，并且在相关程序接口统一都用智能指针来管理、不会用到源对象指针的话，当然优先选boost，但是当你的代码中由于历史原因，有些接口不可变更，且new/delete, malloc/free都存在，而且依然需要使用源对象指针来完成大部分工作时，不妨试试我设计的这个阉割版的scoped_ptr/scoped_array。总之，根据自己的实际情况来选择合适的方案，如果标准方案不适用，就自己写一个托福答案