亚洲国产欧美一区二区三区同亚洲 ,欧美大片专区,国产在线精品二区

C++��装dll�l�C#�{�其他语�a�使用�Ҏ��

HAOSOLA — Thu, 31 Mar 2016 09:54:00 GMT

　　C++在开发底层程序时�Q�是一个不错的选择。不�q�想用C++快速做一个一般美观的界面�Q�不如C#、VB�{�语�a�快速。当�Ӟ��如果你想做一个个性绚丽的界面�Q�C++完全是可以的�?

　　不过快速开发时�Q�我们�ƈ不会局限于一�U�语�a��Q�很多时候都是�؜用多�U�语�a��Q�实��C��个强大又�l�丽的UI的��Y�Ӟ��而且可以保证开发速度很快�?

　　每一�U�语�a�都有独特的优势，有优势的部分恰恰��是很适合应用的场景，因此�~�码实现方便快速。�ƈ不是说C++开发程序就一定很慢，也不是说C#开发程序就一定快。如果要做偏底层的功能，往往C++实现��h��q�是很快�Q�而且�E�序的执行效率也是很高的。对于底层的操作�Q��用C#�{�语�a�来说�Q�就非常不方�ѝ��比如调用个�pȝ��API函数�Q�C/C++包含一个头文�g�Q�然后直接写函数名称卛_��Q�而其他语�a�则比较麻烦了。因��Z��们要通过一层函数库的封装间接调用底层API的，所以也��很�ȝ��了�?

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

　　那么既然如此�Q�我们就��C++和C#�l�合来��用就很好�Q�这叫做强强联合�Q�选择C#也是因�ؓ语法上和C++很相��|��VB�q�些语言语法和C++相差很大�Q�不习惯�?/font>

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

　　C++��装代码成dll形式提供�l�C#�{�语�a�使用。C++代码中，你可以尽情的使用�c�L��完成功能�Q�只是在导出函数�Ӟ��只要提供C语言的函敎ͼ�而不要将�c�d��出，不徏议这么做。而导出函数时�Q��ؓ了让更多语言方便使用dll�Q�导出函��C��用C调用�U�定导出函数。一般语�a�都支持标准C函数调用�U�定�?

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

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

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

　　如果你有一些不错的��x��Q�就到C++技术网分��n下吧。我会仔�l�阅��L��一个字透露出来的气息，�l�你分��n我的相关�l�验�Q�尽量开阔你的思维范围�Q�一赯��步�?

HAOSOLA 2016-03-31 17:54 发表评论

利用C++ RAII技术自动回收堆内存

HAOSOLA — Sun, 16 Nov 2014 01:05:00 GMT

　　帔R��到的动态内存回攉��?/strong>

　　在C++的编�E�过�E�中�Q�我们经帔R��要申请一块动态内存，然后当用完以后将光��放。通常而言�Q�我们的代码是这��L��Q?br />
　　1: void func()

　　2: {

　　3: //allocate a dynamic memory

　　4: int *ptr = new int;

　　5:

　　6: //use ptr

　　7:

　　8: //release allocated memory

　　9: delete ptr;

　　10: ptr = NULL;

　　11: }

　　如果�q�个函数func()逻辑比较��单，问题不大�Q�但是当中间的代码有可能抛出异常�Ӟ��上面的代码就会��生内存泄�?memory leak)�Q�如下面代码中第11行和12行将不会被执行。当然有码友会说用try-catch包�v来就可以了，对，没错�Q�但是代码中到处的try-catch也挺被�h诟病�?strong>SAT�{�案 www.sats686.com

　　1: void func()

　　2: {

　　3: //allocate a dynamic memory

　　4: int *ptr = new int;

　　5:

　　6: throw “error”; //just an example

　　7:

　　8: //use ptr

　　9:

　　10: //release allocated memory

　　11: delete ptr;

　　12: ptr = NULL;

　　13: }

　　而且当函数有多个�q�回路径�Ӟ��需要在每个return前都要调用delete去释放资源，代码也会变的不优雅了�?br />
　　1: void func()

　　2: {

　　3: //allocate a dynamic memory

　　4: int *ptr = new int;

　　5:

　　6: if (...)

　　7: {

　　8: //...a

　　9:

　　10: //release allocated memory

　　11: delete ptr;

　　12: ptr = NULL;

　　13: return;

　　14: } else if (....)

　　15: {

　　16: //...b

　　17:

　　18: //release allocated memory

　　19: delete ptr;

　　20: ptr = NULL;

　　21: return;

　　22: }

　　23:

　　24: //use ptr

　　25:

　　26: //release allocated memory

　　27: delete ptr;

　　28: ptr = NULL;

　　29: }

　　鉴于此，我们��p��惛_��法利用C++的一些语�a��Ҏ��，在函数退栈时能够��局部申��L��动态内存自动释放掉。熟悉C++的码友们都知道，当一个对象退出其定义的作用域�Ӟ��会自动调用它的析构函数。也��是说如果我们在函数内定义一个局部对象，在函数返回前�Q�甚��x��异常产生�Ӟ��q�个局部对象的析构函数都会自动调用。如果我们能够将释放资源的代码交付给�q�个对象的析构函敎ͼ�我们��可以实现资源的自动回收。这�c�L��术，通常被称为RAII (初始化中获取资源)托福�{�案

　　什么是RAII以及几个例子

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

　　创徏一个特�D�类�Q�在其构造函数初甌��资源;

　　��装目标对象�Q�将甌��资源的目标对象作��个特�D�类的成员变�?

　　在这个类的析构函数内�Q�释放资源�?br />
　　一个典型的例子��是标准库中提供的模板类std::auto_ptr。如在《C++�E�序设计语言�?《The C++ Programming Language, Special Edition�? Bjarne Stroustrup著，裘宗燕译)中第327��|��描述�?strong>SAT�{�案

　　1: template

　　2: class std::auto_ptr {

　　3:

　　4: public:

　　5: //在构造函��C��Q�获得目标指针的��理�?br />
　　6: explicit auto_ptr(X *p = 0) throw() { ptr = p; }

　　7: //在析构函��C��Q�释攄��标指�?br />
　　8: ~auto_ptr() throw() { delete ptr; }

　　9:

　　10: //...

　　11:

　　12: //重装*�?>�q�算�W�，使auto_ptr对象像目标指针ptr一样��?br />
　　13: X& operator*() const throw() { return *ptr; }

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

　　15:

　　16: //攑ּ�对目标指针的��理�?br />
　　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。它可以指定一个函敎ͼ�在该变量退��Z��用域时可以执行。例如Wikipedia上提到的�?br />
　　1: #define RAII_VARIABLE(vartype,varname,initval,dtor) \

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

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

　　我们可以�q�样使用�Q�例�?br />
　　1: void example_usage() {

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

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

　　4: }

　　�q�有一个例子，是在刘未鹏的博客文章”C++11 (及现代C++风格)和快速�P代式开�?#8220;中的”资源��理“一节中看到的，他借助C++11的std::function实现了这一�Ҏ��。感兴趣的码友可以到他博客内阅读�?br />
　　�W�者采用的�Ҏ��

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

　　代码如下�Q?br />
　　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: };
　　��Z��使用方便�Q�封装两个宏�Q?br />
　　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()

　　使用��h��很简单，例如

　　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: //在申请堆内存之前�Q��用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: //因�ؓ下面�q�个函数可以释放资源�Q�所以在它前面放弃对目标指针的管理权

　　32: AUTO_FREE_DISABLE(pLftHashs);

　　33: AUTO_FREE_DISABLE(pRhtHashs);

　　34:

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

　　36: free_hash_arrays(pLftHashs, pRhtHashs);

　　37: }

　　38: }

　　同样的，有时我们需要申请一个动态二�l�数�l�，所以也实现一个对应的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: }

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

HAOSOLA 2014-11-16 09:05 发表评论

��无声的视频剪辑加入应用�E�序

HAOSOLA — Sun, 16 Nov 2014 00:55:00 GMT

使用多媒�?/strong>
C++Builder可在应用�E�序中加入多媒体�l��g。可以��用组仉��板Win32��中的TAnimate�l��g或System��中的TMediaPlayer�l��g。需要在应用�E�序中加入无声的视频剪辑�Ӟ��使用动画�l��g。需要把声音�?或视频剪辑加入应用程序时�Q��用媒体播攑֙��l��g�?br />本节讨论下列内容�Q?br />· ��无声的视频剪辑加入应用�E�序�?br />· ��声韛_��/或视频剪辑加入应用程序�?br />
��无声的视频剪辑加入应用�E�序
使用C++Builder的动��L��件可把无声的视频剪辑加入应用�E�序�?br />
要把无声的视频剪辑加入应用程序：
1) 在组仉��板的Win32��中双击动画控�g的图标。这��自动把动画控�g攑֜��H�体上欲在其中显�C��频剪辑的�H�口中�?br />2) 使用对象观察�?选择Name属性�ƈ�l�动��L��件输入一个新名字。调用动��L��件时��用这个名字（遵��@标准的C++标识�W�命名规则）。当讄��设计时属性及创徏事�g处理�E�序�Ӟ��L��直接在对象观察器中工作�?br />3) 选择下列操作之一�Q?br />· 选择CommonAVI属性�ƈ选择下拉列表中可用的AVI�?br />· 或选择FileName属性�ƈ点击省略�Q?..�Q�按钮，从本地或�|�络目录中选择一个可用的AVI文�g�Q��ƈ在OpenAVI对话框中点击Open�?br />· 或��用ResName或ResID属性选择一个AVI资源。��用ResHandle指定包含由ResName或ResID属性标识的资源的模块�?br />�q�将把AVI文�g载入内存。将Open属性设为true会把AVI剪辑的第一帧显�C�在屏幕上，直到使用Active属性或Play�Ҏ��播放AVI剪辑�?br />
4) 讄��Repetitions属性可讄��AVI剪辑播放的重复次数。若其��gؓ0�Q�AVI剪辑会一直重复直到Stop�Ҏ��被调用�?br />5) 修改动画控�g的其他设�|�。例�?若要改变动画控�g打开时显�C�的�W�一帧，可将StartFrame属性设为需要的帧�?br />) 使用下拉列表��Active属性设为true或编写事件处理程序以在运行时特定的事件发生时播放AVI剪辑。例�?要在一个按钮对象被点击�Ӟ��应�ؓ按钮的OnClick事�g�~�写事�g处理�E�序。也可以调用Play�Ҏ��指定播放AVI剪辑托福�{�案

注意若在Active属性设为true以后在修改窗体或�H�体中的�l��g,Active属性将变�ؓfalse�Q�必��重新将它设为true。应仅在�q�行以前或在�q�行时做�q�些工作。加入无声视频剪辑的�C�Z��Q�假定想要在应用�E�序启动时将动画徽标作�ؓ初始的屏�q�显�C�。在动画徽标播放完后�q�幅屏幕消失。要�q�行�q�个例子,先创造一个新工程�q�将Unit1.cpp文�g保存为Frmlogo.cpp�Q�以及将Project1.bpr文�g保存为Logo.bpr。然后：

1) 在组仉��板的Win32��中双击动画�l��g图标�?br />2) 使用对象观察�?��其Name属性设为Logo1�?br />3) 选择其FileName属�?点击省略�Q?..�Q�按�?从你�?.\Examples\Coolstuf目录中选择cool.avi文�g�?br />
然后在OpenAVI对话框中点击Open。这��把cool.avi文�g载入内存�?br />4) 通过点击和拖动把动画控制框放�|�在�H�体的右上角�?br />5) ��其Repetitions属性设�? SAT�{�案
) 点击�H�体使其获得焦点�q�将其Name属性设为LogoForm1�Q�Caption属性设为LogoWindow。然后减��窗体的高度以便��动��L��件放到窗体正中�?br />7) 双击�H�体的OnActivate事�g�q�编写下列代码以当窗体在�q�行时获得焦�Ҏ��播放AVI剪辑�Q?br />
Logo1→Active = true;

8) 在组仉��板Standard��上双击标签控�g图标。选择它的Caption属性�ƈ输入“WelcometoCool Images4.0”。然后选择Font属�?点击省略�Q?..�Q�按钮�ƈ从字体对话框中选择字体样式�Q�Bold,Size�Q?8,Color�Q�Navy�Q��ƈ单击OK。点��dƈ拖动标签控�g以将它放到窗体正�?strong>托福�{�案
9) 点击动画控�g使其获得焦点。双��d��OnStop事�g�q�编写下列代码以当AVI文�g停止时关闭窗体：
LogoForm1→Close();

10) 选择RunRun执行动画徽标�H�口�?/p>

HAOSOLA 2014-11-16 08:55 发表评论

C/C++中容器vector使用�Ҏ��

HAOSOLA — Sat, 20 Sep 2014 07:13:00 GMT

　　此文�ȝ��常用vector操作�Q�是前一��的�l�作!只有代码�Q�详�l�请看代码中的注释�?br /> 　　[cpp] view plaincopy/*
　　* file_name: vector_test.cpp
　　*
　　* Created on: 2014�q?�?8�?下午3:34:23
　　* Author: The_Third_Wave,
　　* Last modified: 2014�q?�?8�?下午3:34:23
　　#include
　　#include
　　#include "Headers/Myfunc.h"
　　#include "Headers/Person.h"
　　void output(const std::vector &vec)
　　// 因�ؓ是输��不是修改，定义形参为常量引用，提高可靠�?const)和效�?&)!
　　{
　　std::cout << "size: " << vec.size()<< ", capacity: " <
　　}
　　int main()
　　{
　　std::vector vec = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
　　pr_vector(vec);
　　// 讉K��首位元素�Q�原生方法之vec.front()和vec.back() 使用前一般最好做元素��查vec.size()
　　std::cout << vec.front() << std::ends << vec.back() << std::endl;
　　// 通过�q�代器【注�?*(--vec.end())】，使用前一般最好做元素��查vec.size()
　　std::cout << *vec.begin() << std::ends << *(--vec.end()) << std::endl;
　　auto a = vec.size(); // 让编译器自动分析表达式所属类�?br /> 　　auto b = vec.capacity(); // 不重新分配内存的话，vector可以保存多少元素
　　std::cout << "size: " << a << std::ends << "capacity: " <
　　vec.reserve(50); // 分配臛_��能容�U�n个元素的内存�I�间
　　output(vec);
　　vec.shrink_to_fit(); // ��capacity()减少为size()相同大小
　　output(vec);
　　vec.reserve(50); // 分配臛_��能容�U?0个元素的内存�I�间
　　// 以下��d��元素
　　for (decltype(vec.size()) ix = 0; ix != 40; ++ix) // decltype从表辑ּ��c�d��推导出变量类�?br /> 　　{
　　vec.push_back(ix*ix);
　　}
　　pr_vector(vec);
　　output(vec); // s输出证明没超�q�size�Q�vector��׃��会分配超额的�I�间
　　// 我们不分配空��_��看看自动��理
　　for (decltype(vec.size()) ix = 0; ix != 40; ++ix) // decltype从表辑ּ��c�d��推导出变量类�?br /> 　　{
　　vec.push_back(ix*ix);
　　}
　　pr_vector(vec);
　　output(vec); // 输出表示分配了超额的�I�间,【测试表明：分配的空间�ؓ当前�?倍，也就意味着��大��浪贏V�?br /> 　　// 以下重新初始化，开始插入操作的学习【�ƈ学习及几�U�赋值的操作�Ҏ��?br /> 　　std::vector vec2 = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}; // 重新初始�?br /> 　　pr_vector(vec); pr_vector(vec2);
　　std::swap(vec, vec2); // 【快速】交换两容器的数�?swap(a, b)
　　pr_vector(vec); pr_vector(vec2);
　　vec2.assign(vec.begin(), vec.end()); // 参数为另外一个同�c�d��vector的�P代器
　　pr_vector(vec); pr_vector(vec2);
　　vec.assign({0, 0, 0, 0, 0}); // 参数为初始化列表
　　pr_vector(vec);
　　vec.assign(10, 1); // 替换�?0�?
　　pr_vector(vec);
　　// vector没有向头部插入数据的原生�Ҏ��Q�只能通过insert()�Ҏ��来操作，插入位置都�ؓ指针指向的前一个位�|?br /> 　　// 具体�?�U?br /> 　　// �W�一�U�vec.insert(p, t); p��w�的�q�代器，t为需要插入的��|��q�回��gؓ指向新添加元素的�q�代�?br /> 　　auto p = vec.insert(vec.begin() + vec.size()/2, 6688);
　　// �W�二�U�vec.insert(p, n, t); p��w�的�q�代器，插入n个t�Q�返回��gؓ指向新添加的�W�一个元素的�q�代器，如果n�?�Q�则�q�回p
　　vec.insert(p, 3, 4);
　　// �W�三�U�vec.insert(p, b, e); p��w�的�q�代器，b、e为同�c�d��其他vec对象的�P代器�Q�返回��gؓ指向新添加的�W�一个元素的�q�代器。范围�ؓ�I�，则返回p
　　vec.insert(p, vec2.crbegin(), vec2.crend()); // const 反向�q�代�?strong>SAT�{�案
　　// �W�四�U�vec.insert(p, il); p��w�的�q�代器，il为元素值列表，�q�回��gؓ指向新添加的�W�一个元素的�q�代器，列表为空�Q�则�q�回p
　　vec.insert(vec.begin(), {9,8,7,6,5,4,3,2,1,0});
　　pr_vector(vec);
　　// 善用使用insert�q�回��|��可以实现特定位置的反复插�?以上�l�果已说�?strong>托福�{�案
　　// emplace操作�Q?【c++11】emplace_front【vector没有】、emplace、emplace_back对应push_front【vector没有】、insert、push_back
　　std::vector per = {{"The_Third_Wave", 100, }}; // �c�d��始化+vector初始化，所以{{}�Q?{}}必须�?br /> 　　per.emplace_back("The_Third_Wave", 188, );
　　per.emplace(per.begin() + 1, Person("The_Third_Wave", 168, ));
　　for (auto &p: per)
　　{
　　print(std::cout, p);
　　}
　　// 删除操作�Q�注意编译器不检查元素是否存在，所以坑自己�?br /> 　　// vec.pop_back(),vector没有pop_front()
　　vec = {0, 1, 2, 3, 4, 5, 6, 7, 8 ,9};
　　vec.pop_back();
　　pr_vector(vec);
　　// vec.erase(p)【删除�P代器p所指元素，�q�回��gؓ�Q�被删元素之后的�q�代器。p指向��N��Q�返回尾后�P代器�Q�如果p是尾后�P代器�Q�那��坑��M��了，恭喜!�?br /> 　　vec.erase(vec.begin() + 8);
　　pr_vector(vec);
　　// vec.erase(b, e)【删除�P代器b�Q�e所指范围元素，�q�回��gؓ�Q�被删元素之后的�q�代器。如果e是尾后�P代器�Q�返回的�q�是��֐��q�代器，不坑�Q�恭�?�?br /> 　　vec.erase(vec.begin() + 3 , vec.end() - 1);
　　pr_vector(vec);
　　// vec.clear()删除所有，�q�回��gؓvoid
　　vec.clear();
　　pr_vector(vec);
　　std::cout << "上面有空行就对了!否则��是出错了�?;
　　}
　　�l�果为：

　　[cpp] view plaincopy
　　0 1 2 3 4 5 6 7 8 9
　　0 9
　　0 9
　　size: 10 capacity: 10
　　size: 10, capacity: 50
　　size: 10, capacity: 10
　　0 1 2 3 4 5 6 7 8 9 0 1 4 9 16 25 36 49 64 81 100 121 144 169 196 225 256 289 324 361 400 441 484 529 576 625 676 729 784 841 900 961 1024 1089 1156 1225 1296 1369 1444 1521
　　size: 50, capacity: 50
　　0 1 2 3 4 5 6 7 8 9 0 1 4 9 16 25 36 49 64 81 100 121 144 169 196 225 256 289 324 361 400 441 484 529 576 625 676 729 784 841 900 961 1024 1089 1156 1225 1296 1369 1444 1521 0 1 4 9 16 25 36 49 64 81 100 121 144 169 196 225 256 289 324 361 400 441 484 529 576 625 676 729 784 841 900 961 1024 1089 1156 1225 1296 1369 1444 1521
　　size: 90, capacity: 100
　　0 1 2 3 4 5 6 7 8 9 0 1 4 9 16 25 36 49 64 81 100 121 144 169 196 225 256 289 324 361 400 441 484 529 576 625 676 729 784 841 900 961 1024 1089 1156 1225 1296 1369 1444 1521 0 1 4 9 16 25 36 49 64 81 100 121 144 169 196 225 256 289 324 361 400 441 484 529 576 625 676 729 784 841 900 961 1024 1089 1156 1225 1296 1369 1444 1521
　　0 1 2 3 4 5 6 7 8 9
　　0 1 2 3 4 5 6 7 8 9
　　0 1 2 3 4 5 6 7 8 9 0 1 4 9 16 25 36 49 64 81 100 121 144 169 196 225 256 289 324 361 400 441 484 529 576 625 676 729 784 841 900 961 1024 1089 1156 1225 1296 1369 1444 1521 0 1 4 9 16 25 36 49 64 81 100 121 144 169 196 225 256 289 324 361 400 441 484 529 576 625 676 729 784 841 900 961 1024 1089 1156 1225 1296 1369 1444 1521
　　0 1 2 3 4 5 6 7 8 9
　　0 1 2 3 4 5 6 7 8 9
　　0 0 0 0 0
　　1 1 1 1 1 1 1 1 1 1
　　9 8 7 6 5 4 3 2 1 0 1 1 1 1 1 9 8 7 6 5 4 3 2 1 0 4 4 4 6688 1 1 1 1 1
　　0 1 2 3 4 5 6 7 8
　　0 1 2 3 4 5 6 7
　　0 1 2 7
　　上面有空行就对了!否则��是出错了�?img src ="http://www.shnenglu.com/haosola/aggbug/208361.html" width = "1" height = "1" />

HAOSOLA 2014-09-20 15:13 发表评论

C++�q�代器的两种实现方式

HAOSOLA — Mon, 25 Aug 2014 13:36:00 GMT

　　一、�P代器概述
　　�q�个标题其实有点"标题�?的含义，因�ؓC++在标准库中的实现�q�代器的方式只有一�U�，也就是�ؓ�c�d��义begin�Q�）和end�Q�）函数�Q�C++11增加了range for语句�Q�可以用来遍历�P代器中的元素。实现�P代器的第二种方式�Q�就是用C++模拟C#和Java中的�q�代器模式，�q�且我们可以定义��q��foreach语句。除此之外，�q�代器可能还有很多种实现的方法，各个库也会多自己的�P代器的实现有所定义�Q�在�q�里只要明白�q�代器的本质意义卛_��?br />　　�q�代器，也称作游标，是一�U�设计模式，我们可以对它�q�行递增�Q�或选择下一个）来访问容器中的元素，而无需知道它内部是如何实现的�?br />　　很多语言提供foreach语句来访问容器中的每一个元素，其实也就是调用容器中的�P代器�Q�抽象地来说��是�Q?br />　　foreach �Q?元素 : 容器 �Q?{ … }
　　上面的代码等效于�Q?br />　　for �Q?游标=获得�q�代器的开��_��获得�q�代器的末尾�Q?游标 != �q�代器末��；游标�U�d��一个单�?�Q?{…} // C++ 的�P代器模式
　　或者：
　　while �Q?�q�代器游标移动一个单位（�q�回是否存在下一个单位）�Q?{ … } // C#、Java的�P代器模式�Q�可以用�q�代器。Current之类的方法返回游标所指向的元�?br />　　二、C++中的�q�代器实现方�?br />　　�q�代器其实是一个类�Q�要自定义一个�P代器�Q�就要重载�P代器的！=、解引用�Q?�Q��?+�q�算�W�，以便它在range for语句中��用。range for 是C++11中新增的语句�Q�如我们对一个集合��用语句for �Q�auto i : collection �Q?�Ӟ��它的含义其实为：
　　for �Q?auto __begin = collection.begin�Q�）�Q?auto __end = collection.end�Q�）�Q?__begin != __end�Q�）�Q?++__begin �Q?br />　　{ i = *__begin;
　　… //循环�?br />　　}
　　begin和end是集合的成员函数�Q�它�q�回一个�P代器。如果让一个类可以有range for的操作，它必��： · 拥有begin和end函数�Q�它们均�q�回�q�代�?· end函数�q�回一个指向集合末��，但是不包含末��օ�素的��|��即用集合范围来表�C�，一个�P代器的范围是 [ begin, end �Q?一个左闭右开区间对于�q�代器，它的要求臛_��是： · 必须重蝲++、！=和解引用�Q?�Q�运��符�Q��P代器看�v来会像一个指�?· �q�代器必��d��以通过++最后满��I��=条�g�Q�这��h��能够�l�止循环
　　下面�l�出最��单的实现代码。我们定义一个CPPCollection�c�，里面有个字符串数�l�，我们让它能够通过range for��每个字�W�串输出来�?br />　　#include
　　class CPPCollection {
　　public:
　　class Iterator{
　　public:
　　int index;
　　CPPCollection& outer;
　　Iterator�Q�CPPCollection &o, int i�Q?: outer�Q�o�Q�， index�Q�i�Q?{ }
　　void operator++�Q�）{
　　index++;
　　}
　　std::string operator*�Q�） const{
　　return outer.str[index];
　　}
　　bool operator !=�Q�Iterator i�Q�{
　　return i.index != index - 1;
　　}
　　};
　　public:
　　std::string str[10] {"a", "b", "c", "d", "e", "f", "g", "h", "i", "j"};
　　Iterator begin�Q�） {
　　return Iterator�Q?this, 0�Q�；
　　}
　　Iterator end�Q�） {
　　return Iterator�Q?this, 9�Q�；
　　}
　　};
　　我们定义了个内部的嵌套类Iterator,�q��ؓ它重载了++�?、！=�q�算�W�。由于C++中的内部嵌套�c�M��外围的类没有联系�Q��ؓ了访问外部类对象的��|��我们必须要传入一个引用（或指针，本例中传入引用）。Iterator的自增方法其实就是增加内部的一个烦引倹{��判断！=的方法是和另外一个�P代器做比较，�q�个�q�代器一般是集合的末��，当我们的索引��g��{�于末尾的烦引�?1�Q?[begin, end�Q?�Q�时�Q�认��P代器已经辑ֈ�了末��?在CPPCollection�c�M��Q�定义了begin�Q�）、end�Q�）分别�q�回开头、结束�P代器�Q�调用如下代码：
　　CPPCollection cpc;
　　for �Q�auto i : cpc�Q�{
　　std::cout �?i �?std::endl;
　　}
　　卛_��遍历集合中的所有元素了�?br />　　在泛型算法中�Q��ؓ了对集合中的每一个元素进行操作，我们通常要传入集合的�q�代器头、�P代器��，以及谓词�Q�例如std::find_if�Q�vec.begin�Q�）�Q?vec.end�Q�）�Q?…�Q�，�q�种泛型��法其实��是在�P代器的首位反复�P代，然后�q�行相应的行为�?br />　　三、模拟C#�Q�Java�Q�中的�P代器实现方式
　　C#和Java的�P代器实现方式较�ؓ�c�M��Q�在�q�里以C#��Z��Q�我用C++来模拟它的实现。C#中，可�P代的�cȝ��承IEnumerable接口�Q�它声明了一个方法GetEnumerator,�q�回一个�P代器。�P代器�l�承IEnumerator接口�Q�接口定义了MoveNext�Q�）�Ҏ��Q�将游标�U�d��一个单位，�q�返回是否还可以�U�d��Q�Reset�Q�）�Ҏ��Q�游标归位； Current属性：�q�回当前游标所指向的��|��在C#中，Current是一个属性，��Z��模拟它，在C++中将它定义�ؓ一个函敎ͼ��Q��ƈ且用只包含抽象函数的�c�L��模拟接口托福�{�案
　　#define interface struct
　　template
　　interface IEnumerator {
　　virtual T& Current�Q�） = 0;
　　virtual bool MoveNext�Q�） = 0;
　　virtual void Reset�Q�） = 0;
　　virtual ~IEnumerator�Q�） { };
　　};
　　template
　　interface IEnumerable {
　　virtual IEnumerator& GetEnumerator�Q�） = 0;
　　virtual ~IEnumerable �Q�） { };
　　};
　　��Z��自定义一个foreach"关键�?,可以用宏定义来进行�P代器的等效替代：
　　#define foreach�Q�item, collection�Q?\
　　auto &__item_enumerator = collection.GetEnumerator�Q�）�Q?\
　　__item_enumerator.Reset�Q�）�Q?\
　　while �Q�item = __item_enumerator.Current�Q�）�Q?__item_enumerator.MoveNext�Q�）�Q?br />　　当我们��用foreach的时候，宏展开自动展开��用集合类collection的GetEnumerator�Q�）函数来获得一个�P代器的引用，复位之，�q�将当前��D��予item,�q�代器向前移动。需要注意的是，我们在代码中不能重复定义__item_enumerator变量�Q�且�c�d��一定要为auto&:auto变量不会保留引用�W�号�Q�且如果不是引用�Q�或指针�Q�，会触发拷贝构造函敎ͼ�从而失��d��象的多态性�?如同刚才一��P��我们定义一个集合类�Q?br />　　class CSharpCollection : public IEnumerable{
　　public:
　　class Enumerator : public IEnumerator {
　　public:
　　CSharpCollection &outer; //外部�c?br />　　int index = 0; //下标
　　Enumerator �Q�CSharpCollection &o�Q?: outer�Q�o�Q�{
　　}
　　bool MoveNext�Q�） override {
　　index++;
　　if �Q�index <= 10�Q?return true;
　　delete this;
　　return false;
　　}
　　void Reset�Q�） override {
　　index = 0;
　　}
　　std::string &Current�Q�） override {
　　return outer.str[index];
　　}
　　~Enumerator �Q�）{
　　std::cout �?"Enumerator 被析�? �?std::endl;
　　}
　　};
　　public:
　　std::string str[10] {"a", "b", "c", "d", "e", "f", "g", "h", "i", "j"};
　　IEnumerator& GetEnumerator�Q�） override{
　　return *new Enumerator�Q?this�Q�；
　　}
　　};
　　需要注意的是，凡是体现多态性的函数�Q�返回值必��Mؓ引用或者指针，且不得�ؓ栈中的��时变量，因此我们调用完GetEnumerator�Q�）后，要将生成的�P代器删除�Q�删除的代码写在了MoveNext�Q�）内，当游标不可移动的时候，�q�代器被删除托福�{�案
　　以后��可以用自己的foreach宏定义来遍历元素了：
　　std::string a;
　　CSharpCollection csc;
　　IEnumerable& refcsc = csc;
　　foreach �Q�a , refcsc �Q�{
　　std::cout �?a �?std::endl;
　　}
　　上面代码的第三行意在说明�Q�如果一个类中��承了IEnumerable�c�，它一定是可�P代的�Q�可以调用它的Reset�Q�）、MoveNext�Q�）、Current�Q�）�Q�也可以用我们刚刚写的foreach来进行遍历�?/p>

HAOSOLA 2014-08-25 21:36 发表评论

HAOSOLA — Mon, 25 Aug 2014 13:15:00 GMT

有时候错误的代码会让我们更深�ȝ��理解一门编�E�语�a��Q�所以在Learn c the hard way一书中�Q�作者不停的让我们把正确的代码破坏掉�Q�发挥我们的好奇心与惌��力，��d��觉c语言的一些特性�?br />��Z��弄清弄清c中int与char型变量存储的异同和gcc�Ҏ��'\0'字符数组的的反应�Q�修改了Learn c the hard way书中的ex8
代码如下
#include
int main�Q�int argc,char *argv[]�Q?br />{
int areas[] = {10, 12, 13, 14, 20};
char name [] = "Zed";
char full_name[] = {
'Z', 'e', 'd',
' ', 'A', '.', ' ',
'S', 'h', 'a', 'w'
};
unsigned int interg[2];
interg[0] = '\0' * 0x01000000 + 'A'*0x00010000 + 'B' * 0x00000100 + 'C' * 0x00000001;
unsigned int inter = interg[0];
// WARNING: On some system you may have to change the
// %ld in this code to a %u since it will use unsignt ints
printf�Q?The size of an int: %ld\n",sizeof�Q�int�Q�）�Q?br />printf�Q?The siez of areas �Q�int[]�Q�：%ld\n",
sizeof�Q�areas�Q�）�Q?br />printf�Q?The number of ints in areas: %ld\n",
sizeof�Q�areas�Q?sizeof�Q�int�Q�）�Q?br />printf�Q?The first area is %d, the 2nd %d.\n",
areas[0],areas[10]�Q�；
printf�Q?The size of a char: %ld\n",sizeof�Q�char�Q�）�Q?br />printf�Q?The size of name �Q�char[]�Q�： %ld\n",
sizeof�Q�name�Q?sizeof�Q�char�Q�）�Q?br />printf�Q?The size of full_name �Q�char[]�Q�： %ld\n",
sizeof�Q�full_name�Q�）�Q?br />printf�Q?The number of chars: %ld\n",
sizeof�Q�full_name�Q?/ sizeof�Q�char�Q�）�Q?br />// !!!其中full_name未设�|�null�l�尾
printf�Q?name=\"%s\" and full_name=\"%s\"\n",
name, full_name�Q�；
// test 证明了gcc把未初始化的地方初始�?
printf�Q?the char after the full_name�Q�shuold be error�Q�：%c\n",full_name[12]�Q�；
// �?int 存储字符�?br />printf�Q?interg=%X\n", interg�Q�；
printf�Q?inter=\"%s\"\n", &inter�Q�；
printf�Q?interg=\"%s\"\n", interg�Q�；
return 0;
}
重点在于
char full_name[] = {
'Z', 'e', 'd',
' ', 'A', '.', ' ',
'S', 'h', 'a', 'w'
};
unsigned int interg[2];
interg[0] = '\0' * 0x01000000 + 'A'*0x00010000 + 'B' * 0x00000100 + 'C' * 0x00000001;
unsigned int inter = interg[0];
可以看到full_name字符串初始化的时候是没有null�l�尾的，如果的vc中编译�ƈ以字�W�串形式输出的话会跟上�ؕ�?br />interg的数�l�第一个元素中我分别在四个字节中放入了'\0'�Q�即0�Q��?A'�?B'�?C',�W�二个元素未初始化�?br />inter中放的是同样的数字�?br />输出如下�Q?br />The size of an int: 4
The siez of areas �Q�int[]�Q�：20
The number of ints in areas: 5
The first area is 10, the 2nd -1493946707.
The size of a char: 1
The size of name �Q�char[]�Q�： 4
The size of full_name �Q�char[]�Q�： 11
The number of chars: 11
name="Zed" and full_name="Zed A. Shaw"
the char after the full_name�Q�shuold be error�Q�：
interg=6EB11E70
inter="CBA"
interg="CBA"
可以看到以字�W�串输出的full_name�q�没有因为无null�l�尾而输��Zؕ码或错误�Q�在csdn论坛上了解到可能是因为gcc��字�W�串存储区全部初始化为零�?br />PS:对于数组的初始化�Q�可以只初始化一个元素，��可以��其他元素为零�Q�Learn c the hard way�Q�；
inter以字�W�串输出的结果是按我赋值的倒序输出的，�q�个是因为小端的数据存储造成�?strong>托福�{�案

HAOSOLA 2014-08-25 21:15 发表评论

C语言/C++递归��法

HAOSOLA — Fri, 30 May 2014 01:53:00 GMT

　　递归��法也是C语言��法中一个比较简单与常用的算法，本文我们��来谈谈递归��法�Q�我们首先了解一下什么是递归��法�Q�关于递归��法的概念只有一句话�Q�一个过�E�（或函敎ͼ�直接或间接调用自己本�w�，�q�种�q�程�Q�或函数�Q�叫递归�q�程�Q�或函数�Q?br />　　我们再来看看递归��法的特点：
　　�Q?�Q?递归��是在过�E�或函数里调用自�w��?br />　　�Q?�Q?在��用递归�{�略�Ӟ��必须有一个明��的递归�l�束条�g�Q�称为递归出口�?br />　　�Q?�Q?递归��法解题通常昑־�很简�z�，但递归��法解题的运行效率较低。所以一般不提倡用递归��法设计�E�序�?br />　　�Q?�Q?在递归调用的过�E�当中系�l��ؓ每一层的�q�回炏V��局部量�{�开辟了栈来存储。递归�ơ数�q�多�Ҏ��造成栈溢出等。所以一般不提倡用递归��法设计�E�序�?br />　　再看看递归的分�c�：
　　直接递归
　　�E�序设计中，�q�程或函数直接或者间接调用自己，��p��U�Cؓ递归调用。子�E�序直接调用自己�Q�这�U�Cؓ直接递归�Q�嵌套关�pȝ��子程序A和B,内层的B调用外层的A,�q�是间接低归�Q��^�U�关�pȝ��子程序A和B,其中A调用了B,B调用了A,�q�也是间接递归�Q�不�q�，�q�种间接递归用到�?��前引用"的规则�?br />　　下面�Q�博��L��C��一些有关于递归��法的题目。我们看看第一个题目�?br />　　�q�是一道很�l�典的题目：阶乘。相信大部分的�h都知道什么是阶乘�Q�但是你如果不知道的话，不妨参见一下百度百�U�：阶乘�?br />　　好了�Q�其实这题非常简单，我们只需要一个函数即可解决问题�?br />　　1 int recursive�Q�int i�Q?br />　　2 {
　　3 int sum = 0;
　　4 if �Q? == i�Q?br />　　5 return �Q?�Q�；
　　6 else
　　7 sum = i * recursive�Q�i-1�Q�；
　　8 return sum;
　　9 }
　　��是上面的递归函数�Q�这题我��׃��费��幅讲解了，重点攑֜��W�二个例题：汉诺塔问题�?br />　　一个庙里有三个柱子�Q�第一个有64个盘子，从上往下盘子越来越大。要求庙里的老和��把�q?4个盘子全部移动到�W�三个柱子上。移动的时候始�l�只能小盘子压着大盘子。而且每次只能�U�d��一个�?、此时老和��（后面我们叫他�W�一个和��）觉得很难�Q�所以他惻I��要是有一个�h能把�?3个盘子先�U�d��到第二个柱子上，我再把最后一个盘子直接移动到�W�三个柱子，再让那个人把刚才的前63个盘子从�W�二个柱子上�U�d��到第三个柱子上，我的��d��完成了�Q�简单。所以他找了比他�q�轻的和��（后面我们叫他�W�二个和��）�Q�命令：
　　① 你把�?3个盘子移动到�W�二柱子�?strong>托福�{�案
　　② 然后我自己把�W?4个盘子移动到�W�三个柱子上�?br />　　③ 你把�?3个盘子移动到�W�三柱子�?br />　　2、第二个和尚接了��d��Q�也觉得很难�Q�所以他也和�W�一个和��一��h��Q�要是有一个�h能把�?2个盘子先�U�d��到第三个柱子上，我再把最后一个盘子直接移动到�W�二个柱子，再让那个人把刚才的前62个盘子从�W�三个柱子上�U�d��到第三个柱子上，我的��d��完成了�Q�简单。所以他也找了比他年�ȝ��和尚�Q�后面我们叫他第三和��）�Q�命令：
　　① 你把�?2个盘子移动到�W�三柱子�?br />　　② 然后我自己把�W?3个盘子移动到�W�二个柱子上�?br />　　③ 你把�?2个盘子移动到�W�二柱子�?br />　　3、第三个和尚接了��d��Q�又把移动前61个盘子的��d��依葫芦话瓢的交给了第四个和尚�Q�等�{�递推下去�Q�直到把��d��交给了第64个和��ؓ止（估计�W?4个和��很郁闷�Q�没��Z��也命令下别�h�Q�因为到他这里盘子已�l�只有一个了�Q��?br />　　4、到此�Q务下交完成，到各司其职完成的时候了。完成回推了�Q?br />　　�W?4个和��移动第1个盘子，把它�U�d��Q�然后第63个和��移动他�l�自己分配的�W?个盘子�?br />　　�W?4个和��再把第1个盘子移动到�W?个盘子上。到�q�里�W?4个和��的��d��完成�Q�第63个和��完成了�W?2个和��交�l�他的�Q务的�W�一步�?br />　　从上面可以看出，只有�W?4个和��的��d��完成了，�W?3个和��的��d��才能完成�Q�只有第2个和��?---�W?4个和��的��d��完成后，�W?个和��的��d��才能完成。这是一个典型的递归问题�?现在我们以有3个盘子来分析�Q?br />　　�W?个和��命令：
　　① �W?个和��你先把�W�一柱子�?个盘子移动到�W�二柱子。（借助�W�三个柱子）
　　② �W?个和��我自己把第一柱子最后的盘子�U�d��到第三柱子�?br />　　③ �W?个和��你把前2个盘子从�W�二柱子�U�d��到第三柱子�?br />　　很显�Ӟ��W�二步很�Ҏ��实现托福�{�案
　　其中�W�一步，�W?个和��他�?个盘子，他就命��o�Q?br />　　① �W?个和��你把第一柱子�W?个盘子移动到�W�三柱子。（借助�W�二柱子�Q?br />　　② �W?个和��我自己把第一柱子�W?个盘子移动到�W�二柱子上�?br />　　③ �W?个和��你把第1个盘子从�W�三柱子�U�d��到第二柱子�?br />　　同样�Q�第二步很容易实玎ͼ�但第3个和��他只需要移�?个盘子，所以他也不用在下派��d��了。（注意�Q�这��是停止递归的条�Ӟ��也叫边界��|��
　　�W�三步可以分解�ؓ�Q�第2个和��还是有2个盘子，命��o�Q?br />　　① �W?个和��你把第二柱子上的第1个盘子移动到�W�一柱子�?br />　　② �W?个和��我把第2个盘子从�W�二柱子�U�d��到第三柱子�?br />　　③ �W?个和��你把第一柱子上的盘子�U�d��到第三柱子�?br />　　分析�l�合��h��是�Q?→3 1→2 3→2 借助�W�三个柱子移动到�W�二个柱�?|1→3 | 2→1 2→3 1→3借助�W�一个柱子移动到�W�三个柱子|共需要七步�?br />　　如果�?个盘子，则第一个和��的命��o中第1步和�W?步各�?个盘子，所以各需�?步，�?4步，再加上第1个和��的1步，所�?个盘子��d��需要移�?+1+7=15步，同样�Q?个盘子需�?5+1+15=31步，6个盘子需�?1+1+31=64�?#8230;…由此可以知道�Q�移动n个盘子需要（2的n�ơ方�Q?1步�?br />　　从上面整体综合分析可知把n个盘子从1座（相当�W�一柱子�Q�移�?座（相当�W�三柱子�Q�：
　　�Q?�Q�把1座上�Q�n-1�Q�个盘子借助3座移�?座�?br />　　�Q?�Q�把1座上�W�n个盘子移�?座�?br />　　�Q?�Q�把2座上�Q�n-1�Q�个盘子借助1座移�?座�?br />　　下面用hanoi�Q�n,a,b,c�Q�表�C�把1座n个盘子借助2座移动到3座�?br />　　很明显： �Q?�Q�步上是 hanoi�Q�n-1,1,3,2�Q?�Q?�Q�步上是 hanoi�Q�n-1,2,1,3�Q?br />
　　用C语言表示出来�Q�就是：
　　1 #include
　　2 int method�Q�int n,char a, char b�Q?br />　　3 {
　　4 printf�Q?number%dform%cto%c"n",n,a,b�Q�；
　　5 return 0;
　　6 }
　　7 int hanoi�Q�int n,char a,char b,char c�Q?br />　　8 {
　　9 if�Q?n==1 �Q?move �Q?,a,c�Q�；
　　10 else
　　11 {
　　12 hanoi�Q�n-1,a,c,b�Q�；
　　13 move�Q�n,a,c�Q�；
　　14 hanoi�Q�n-1,b,a,c�Q�；
　　15 };
　　16 return 0;
　　17 }
　　18 int main�Q�）
　　19 {
　　20 int num;
　　21 scanf�Q?%d",&num�Q�；
　　22 hanoi�Q�num,'A','B','C'�Q�；
　　23 return 0;
　　24 }
　　�q�就是递归��法�Q�其实，在C语言中，递归��法比枚举法�q�要实用�Q�但是这两种��法都很��单�?/p>

HAOSOLA 2014-05-30 09:53 发表评论

HAOSOLA — Wed, 28 May 2014 12:29:00 GMT

　　对于二维数组和二�l�指针的内存的分�?br />　　�q�里首选说一下一�l�指针和一�l�数�l�的内存分配情况�?br />　　一�l�_��
　　数组�Q��Ş如int a[5];�q�里定义了一个一�l�数�l�a,�q�且数组的元素个数是5,�q�里的a是这五个元素的整体表�C�，也就是通过a我们能找到这五个元素。注意：a是代表数�l�第一个元素的首地址�?amp;a是代表数�l�的地址�Q�虽然它们的值相同�?br />　　指针�Q?int *p = NULL;�q�里p是一个指针，它指向的是计��?br />　　机内一块存储int�c�d��的内存。P = a;��是让p�{�于刚才甌��的数�l�的�W�一个元素的地址。所以通过p我们也能扑ֈ��?个元素所以P[i]跟a[i]的作用一栗��?br />　　注意�Q?br />　　1:int *p = NULL; p的大��在32位机器是4,即��p=a;之后p的sizeof�Q�p�Q�仍然等�?.
　　2:在声明之后，数组必须分配内存�q�行初始化。而指针一般是动态分配其指向的内存�?br />　　3:不要��h��指针和数�l�，指针��是指针�Q�数�l�就是数�l�，只是数组在一定条件下可以转换成指针。不要将指针和数�l��؜淆。（例如�Q�指针有++,--操作�Q�数�l�则不可以）�?br />　　一�l�指针的动态内存分配：
　　int *p = NULL;
　　p = new int[N];
　　千万别忘了delete
　　delete [] p;
　　p = NULL;
　　二维数组的内存分�?br />　　int a[2][3]; �q�里分配了一�?X3=6个int大小的数�l�。二�l�数�l�的�W�二个维�?不能省略�?br />　　二维数组的内存在计算机内也是�q�箋的一片地址�Q�只不过�?个元素构成一个一�l�数�l�a[i],�q�里的a[i]代表�l�度�?的数�l�的�W�一个元素的地址。所以a[i][j]的访问跟a[i]的访问也��清楚了。这里的a[i]其实是一个一�l�数�l�的�W�一个元素的地址�?br />　　对于二维数组做实参，我们通常用一�l�指针处理，例如�Q?br />　　1 #include
　　2 void test�Q�int *p�Q?br />　　3 {
　　4 for �Q�int i = 0;i<3;++i�Q?br />　　5 {
　　6 for�Q�int j = 0;j<3;++j�Q?br />　　7 {
　　8 std::cout�?�Q�p+3*i+j�Q�； //一�l�处�?br />　　9 }
　　10 }
　　11 }
　　12 int main�Q�void�Q?br />　　13 {
　　14 int a[3][3]={1,2,3,4,5,6,7,0,0};
　　15 test�Q�（int*�Q�a�Q�； //��二�l�数�l�当做一�l�处�?br />　　16 system�Q?pause"�Q�；
　　17 return 0;
　　18 }
　　�q�些惛_��书上讲的都非常清楚�?br />　　二维数组的C++动态内存分配�?br />　　二维指针的动态数�l�分配：二维指针�c�M��指针数组的分�?br />　　int **p;
　　1 #include
　　2 int main�Q�void�Q?br />　　3 {
　　4 int **p = NULL; //�q�里甌��一�?x4的二�l�数�l?br />　　5 p = new int *[3]; //分配一�l�指针，分配三个int* �c�d��的一�l�指针�?br />　　6 for �Q�int i = 0;i < 3; ++i�Q?br />　　7 {
　　8 p[i] = new int[4];
　　9 }
　　10 for �Q�int i = 0; i < 3; ++i�Q?br />　　11 {
　　12 for�Q�int j = 0; j < 4 ; ++j�Q?br />　　13 {
　　14 p[i][j] = i*j;
　　15 std::cout<
　　26 return 0;
　　27 }
　　指针数组的动态内存分�?br />　　指针数组的动态内存分配只需要对指针数组的数�l�元素指针分别分配内存即可，比二�l�指针的分配��了一个环节�?br />　　1 #include托福�{�案
　　2 int main�Q�void�Q?br />　　3 {
　　4 int *a[3]; //甌��含有三个int* �c�d��的指针数�l?br />　　5 //跟二�l�指针不同的是，�q�里数组a不用手动甌��内存
　　6 for �Q�int i = 0;i < 3;++i�Q?//甌��一�?x4的空�?br />　　7 {
　　8 a[i] = new int[4];
　　9 }
　　10 for �Q�int i = 0; i<3 ;++i�Q?br />　　11 {
　　12 for �Q�int j = 0; j<4; ++j�Q?br />　　13 {
　　14 a[i][j] = i*j;
　　15 std::cout<
　　25 return 0;
　　26 }
　　数组指针的动态内存分�?br />　　数组指针��是指向数组的指针，说白了就是指向一个数�l�整体，因此分配的时候直接申请一片内存地址卛_��。跟二维数组的静态分配类伹{�?br />　　1 // Karllen
　　2 int main�Q�void�Q?br />　　3 {
　　4 int �Q?a�Q�[4]; //�q�里�?是第二维的维度，a的增量的基数�?个int
　　5 a = new int[3][4];
　　6 delete []a;
　　7 a = NULL;
　　8 return 0;
　　9 }

HAOSOLA 2014-05-28 20:29 发表评论

C/C++混合�~�程--extern “C�?使用�Ҏ��详解

HAOSOLA — Sat, 26 Apr 2014 05:45:00 GMT

　　其实在网上关于这个问题已�l�讨论很多了�Q�但是大多都是重复的�Q�确实讲解的很详�l�，�q�指��Z��怎么用是错误的，本来记忆��׃��怎么��P��所以对于记忆这些错误的用法更是讨厌�Q�还不如记忆一�U�通用的而且比较规范、代码阅读�v来比较舒适的�Ҏ��Q�下面我们开始吧�Q�！�Q?br />　　C、C++密不可分�Q��^时��用更多的是C,但有时候却��不了C++,而且是C、C++��h��Q��؜合编�E�）在一��L��Q�比如，RTP视频传输�Q�live555多媒体播攄��都是C++下的�Q�他需要调用JRTPLIB库，再比如，我那邮�g发送，我也用C++写的�Q�定义了一个Email对象�Q�包含了成员�Q�收发邮件地址�Q�用户名�Q�密码等�Q�以及方法：邮�g头、Base64�~�码和邮件发送这些操作，很好用，所以，很多时候，C++�q�是蛮不错的…但，*.c�?.cpp文�g��h��在一��P��不是那么的简单，.
　　一、extern"C"的作用（最重点�Q?br />　　1. extern "C"的真实目的是实现�c�C和C++的�؜合编�E�。extern "C"是由C++提供的一个连接交换指定符��P��用于告诉C++�q�段代码是C函数。extern "C"后面的函��C��使用的C++的名字修饎ͼ�而是用C.�q�是因�ؓC++�~�译后库中函数名会变得很长，与C生成的不一��_��造成C++不能直接调用C函数托福�{�案
　　2.C++语言支持函数重蝲�Q�C语言不支持函数重载。函数被C++�~�译后在库中的名字与C语言的不同。假设某个函数的原型为：void foo�Q�int x, int y�Q�；该函数被C�~�译器编译后在库中的名字为_foo,而C++�~�译器则会��生像_foo_int_int之类的名字。C++提供了C�q�接交换指定�W�号extern"C"来解军_��字匹配问题�?br />　　3.被extern "C"限定的函数或变量是extern�c�d��的；extern是C/C++语言中表明函数和全局变量作用范围�Q�可见性）的关键字�Q�该关键字告诉编译器�Q�其声明的函数和变量可以在本模块或其它模块中使用。被extern "C"修饰的变量和函数是按照C语言方式�~�译和连接的雅思答�?/font>
　　4.与extern对应的关键字是static,被它修饰的全局变量和函数只能在本模块中使用。因此，一个函数或变量只可能被本模块��用时�Q�其不可能被extern "C"修饰�?br />　　二、extern"C"与__cplusplus
　　#ifdef __cplusplus
　　extern "C" {
　　#endif
　　#ifdef __cplusplus
　　}
　　#endif
　　Cplusplus�Q�C plus plus�Q�即"C++",用于C++文档的头文�g中，上面代码的意思是�Q�如果是C++文�g�Q?.cpp�Q�后�~��Q�则使用extern "C",在C++��目中应用的非常�q�泛。即使用gcc�~�译器编译，函数名�ؓC�c�d��如_foo.个�h认�ؓ�Q�搞懂了�q�两个关键字�Q�尤其是理解extern "C"
　　extern "C" 是�ؓ了C与C++混合�~�程而设立的关键字，假如你已�l�知道了关于extern "C" 的一些��用方法，惛_��快掌握��用策略，下面从两个角度说明：
　　1�Q�在C++�E�序中调用C�E�序�Q�比如在CPP文�g中��用C文�g的某一个函敎ͼ�那么可以肯定的是所使用的函数肯定是按照C语言的编译方式编译，那么仅仅通告CPP文�g按照C语言调用函数的方式调用即可，而且不用再重新编译C函数�Q�在函数所在头文�g中添加extern "C"关键字，��这个头文�g包含到CPP文�g卛_��。也��是如下所�C�：
　　#ifdef __cplusplus
　　extern "C" {
　　#endif
　　/*… 函数声明*/
　　#ifdef __cplusplus
　　}
　　#endif
　　�E�微举例说明一下：
　　?
　　// cheader.h
　　#ifndef _C_HEADER_
　　#define _C_HEADER_
　　#ifdef __cplusplus
　　extern "C" {
　　#endif
　　#include
　　#include
　　int add�Q�int a,int b�Q�；
　　#ifdef __cplusplus
　　}
　　#endif
　　#endif
　　// cfunc.c
　　//#include "header.h"
　　int add�Q�int a,int b�Q?br />　　{
　　return a+b;
　　}
　　//main.cpp
　　#include
　　#include "header.h"
　　using namespace std;
　　int main�Q�）
　　{
　　int a,b=0;
　　b= add�Q?,3�Q�；
　　cout《B《ENDL; pre < } 0; return>

　　�׃��。c文�g中的函数��是按照C语言�~�译方式�q�行�~�译的，所以不包括头文件也是可以的�Q�但是在头文件声明的时候必��进行说明，因�ؓ在CPP文�g中包括的�q�个头文件会按照C语言的方式查扑և�敎ͼ�不然��׃��按照C++的方式查扑և�数add

　　

2�Q�在C�E�序中��用CPP�~�译的函敎ͼ��q�样需要重新编译函数库�Q�在函数声明的头文�g中也是如上声明，然后再函数所在的CPP文�g��d��上述头文�Ӟ��直接�~�译卛_��Q�这个时候虽说在CPP文�g�~�译�Q�但是是安装C语言的方式编译，在C文�g中同��h��加上�q�头文�g卛_��?lt;/STRONG>

　　
�E�微举例说明一下：

　　

　　
// cheader.h头文�?br />　　#ifndef _C_HEADER_
　　#define _C_HEADER_
　　#ifdef __cplusplus
　　extern "C" {
　　#endif
　　#include
　　#include
　　int sub�Q�int a,int b�Q�；
　　#ifdef __cplusplus
　　}
　　#endif
　　#endif
　　//cppsub.cpp
　　#include "header.h"
　　int sub�Q�int a,int b�Q?br />　　{
　　return a-b;
　　}
　　/*但是如果��头文�g的那一行注释掉�Q�也会在�q�接时出错，因�ؓ在头文�g中已�l�说明��用C语言的方式编译，但是不说明这一点，会��用C++�~�译方式�q�行
　　如果不想使用头文�Ӟ��那么可以��int sub�Q�int a,int b�Q?换�ؓ extern "C" int sub�Q�int a,int b�Q?,但是extern "C"在。c文�g时不可以出现*/
　　//cmain.c
　　#include "header.h"
　　int main�Q�）
　　{
　　int a=0,b=0;
　　b = sub�Q?,3�Q�；
　　printf�Q?b is %d\r\n",a,b�Q�；
　　return 0;
　　}
　　

　　但是在��用的时候也是有一定的规范的：

　　//C++头文�?cppExample.h

　　#ifndef CPP_EXAMPLE_H

　　#define CPP_EXAMPLE_H

　　extern "C" int add�Q?int x, int y �Q�；

　　#endif
　　

　　//C++实现文�g cppExample.cpp

　　#include "cppExample.h"

　　int add�Q?int x, int y �Q?lt;BR>
　　{

　　return x + y;

　　}
　　

　　/* C实现文�g cFile.c

　　/* �q�样会编译出错：#include "cExample.h" */

　　extern int add�Q?int x, int y �Q�；

　　int main�Q?int argc, char* argv[] �Q?lt;BR>
　　{

　　add�Q?2, 3 �Q�；

　　return 0;

　　}
　　note: 如果 cppEample.h �Ҏ��Q?br />　　#ifndef CPP_EXAMPLE_H

　　#define CPP_EXAMPLE_H
　　#ifdef __cplusplus
　　extern "C" {
　　#endif
　　

　　int add�Q?int x, int y �Q�；
　　#ifdef __cplusplus
　　}
　　#endif
　　

　　#endif
　　则在 C 文�g�?#include "cExample.h" ��׃��会报错了�?br />　　��M��Q?无论�?c �q�是 c++头文�Ӟ��只要是想以后混合�~�程�Q�就最好加�?br />　　#ifdef __cplusplus
　　extern "C" {
　　#endif
　　/**** some declaration or so *****/
　　#ifdef __cplusplus
　　}
　　#endif /* end of __cplusplus */

　　错误的原因在于在C语言中没有关键字 extern "C"

　　�Q�PS:有的��Z��单独使用extern "C" 来修饰某个函敎ͼ�我觉得不是很好看�Q�特别是在头文�g中不能这么��用，因�ؓ在C文�g中不能出现这��L��关键字，所以最好��用最后介�l�的条�g�~�译在一定条件下才��?extern "C"�Q?lt;BR>
　　

　　

　　

　　

　　

　　

　　

　　

　　

　　

　　

HAOSOLA 2014-04-26 13:45 发表评论

HAOSOLA — Tue, 08 Apr 2014 08:26:00 GMT

　　% - 0 m.n l或h 格式字符
　　下面对组成格式说明的各项加以说明�Q?br />　　①%:表示格式说明的�v始符��P��不可�~�少�?br />　　②-:�?表示左对齐输出，如省略表�C�右寚w��输出�?br />　　③0:�?表示指定�I�Z��?,如省略表�C�指定空位不填�?br />　　④m.n:m指域宽，卛_��应的输出��在输出讑֤�上所占的字符数。N指精度。用于说明输出的实型数的��数位数。对数值型的来��_��未指定n�Ӟ��隐含的精度�ؓn=6位�?br />　　⑤l或h:l�Ҏ��型指long型，对实型指double型。h用于��整型的格式字符修正为short型�?br />　　---------------------------------------
　　格式字符
　　格式字符用以指定输出��的数据�c�d��和输出格式�?br />　　①d格式�Q�用来输出十�q�制整数。有以下几种用法�Q?br />　　%d:按整型数据的实际长度输出�?br />　　%md:m为指定的输出字段的宽度。如果数据的位数��于m,则左端补以空��|��若大于m,则按实际位数输出�?br />　　%ld:输出长整型数据�?br />　　②o格式�Q�以无符号八�q�制形式输出整数。对长整型可以用"%lo"格式输出。同样也可以指定字段宽度�?%mo"格式输出�?br />　　例：
　　main�Q�）
　　{ int a = -1;
　　printf�Q?%d, %o", a, a�Q�；
　　}
　　�q�行�l�果�Q?1,177777
　　�E�序解析�Q?1在内存单元中�Q�以补码形式存放�Q��ؓ�Q?111111111111111�Q?,转换为八�q�制��Cؓ�Q?77777�Q?.
　　③x格式�Q�以无符号十六进制�Ş式输出整数。对长整型可以用"%lx"格式输出。同样也可以指定字段宽度�?%mx"格式输出�?br />　　④u格式�Q�以无符号十�q�制形式输出整数。对长整型可以用"%lu"格式输出。同样也可以指定字段宽度�?%mu"格式输出�?br />　　⑤c格式�Q�输��Z��个字�W��?br />　　⑥s格式�Q�用来输��Z��个串。有几中用法
　　%s:例如�Q�printf�Q?%s", "CHINA"�Q�输�?CHINA"字符�Ԍ��不包括双引号�Q��?br />　　%ms:输出的字�W�串占m列，如字�W�串本��n长度大于m,则突破获m的限�Ӟ��字�W�串全部输出。若串长��于m,则左补空根{�?br />　　%-ms:如果串长��于m,则在m列范围内�Q�字�W�串向左靠，双��I�格�?br />　　%m.ns:输出占m列，但只取字�W�串中左端n个字�W�。这n个字�W�输出在m列的右侧�Q�左补空��|��注意�Q�如果n未指定，默认�?.
　　%-m.ns:其中m、n含义同上�Q�n个字�W�输出在m列范围的左侧�Q�右补空根{��如果n>m,则自动取n��|��即保证n个字�W�正常输出，注意�Q�如果n未指定，默认�?.
　　如果是sprintf�Q�desc, "%m.ns", sour�Q�；如果desc�I�间够的话，会在%m.ns �?的结��自动补null字符�Q�不同于strncpy.
　　例如 :sprintf�Q�desc, "%.3s", "123456"�Q�； desc如果�I�间>=4字节的话�Q�第4个字节将是null字符�?br />　　⑦f格式�Q�用来输出实敎ͼ�包括单、双�_�ֺ��Q�，以小数�Ş式输出。有以下几种用法�Q?br />　　%f:不指定宽度，整数部分全部输出�q�输�?位小数�?br />　　%m.nf:输出共占m列，其中有n位小敎ͼ�如数值宽度小于m左端补空根{�?br />　　%-m.nf:输出共占n列，其中有n位小敎ͼ�如数值宽度小于m右端补空根{�?br />　　⑧e格式�Q�以指数形式输出实数。可用以下�Ş式：
　　%e:数字部分�Q�又�U�尾敎ͼ�输出6位小敎ͼ�指数部分�?位或4位�?br />　　%m.ne�?-m.ne:m、n�?-"字符含义与前相同。此处n指数据的数字部分的小��C��敎ͼ�m表示整个输出数据所占的宽度�?br />　　⑨g格式�Q�自动选f格式或e格式中较短的一�U�输出，且不输出无意义的零�?br />　　---------------------------------------
　　关于printf函数的进一步说明：
　　如果惌��出字�W?%",则应该在"格式控制"字符串中用连�l�两�?表示�Q�如�Q?br />　　printf�Q?%f%%", 1.0/3�Q�；
　　输出0.333333%.
　　---------------------------------------
　　对于单精度数�Q��?f格式�W�输出时�Q�仅�?位是有效数字�Q�小�?位�?br />　　对于双精度数�Q��?lf格式�W�输出时�Q�前16位是有效数字�Q�小�?位�?br />　　------------------------------------------------------------------
　　printf�Q�）函数是格式输出函敎ͼ��h��printf�Q�）打印变量的指令取决与变量的类型。例如，在打印整数是使用%d�W�号�Q�在打印字符�?�?c �W�号。这些符可��U�Cؓ转换说明。因为它们指定了如何不数据�{换成可显�C�的形式。下列列出的是ANSI C标准printf�Q�）提供的各�U��{换说明�?br />　　转换说明及作为结果的打印输出%a ��点数、十六进制数字和p-记数法（C99�Q?br />　　%A ��点数、十六进制数字和p-记法�Q�C99�Q?br />　　%c 一个字�W?br />　　%d 有符号十�q�制整数
　　%e ��点数、e-记数�?br />　　%E ��点数、E-记数�?br />　　%f ��点数、十�q�制记数�?br />　　%g �Ҏ��数��g��同自动选择%f�?e.
　　%G �Ҏ��数��g��同自动选择%f�?e.
　　%i 有符号十�q�制敎ͼ��?d相同�Q?br />　　%o 无符号八�q�制整数
　　%p 指针
　　%s 字符�?br />　　%u 无符号十�q�制整数
　　%x 使用十六�q�制数字0f的无�W�号十六�q�制整数
　　%X 使用十六�q�制数字0f的无�W�号十六�q�制整数
　　%% 打印一个百分号
　　//�q�有一个特�D�的格式%*.* ,�q�两个星��L��值分别由�W�二个和�W�三个参数的值指�?printf�Q?%.*s \n", 8, "abcdefgggggg"�Q�；
　　printf�Q?%*.*f \n", 3,3, 1.25456f�Q�；使用printf �Q�）函数 printf�Q�）的基本�Ş式： printf�Q?格式控制字符�?,变量列表�Q�；#includeint main�Q�）
　　{
　　//for int
　　int i=30122121;
　　long i2=309095024l;
　　short i3=30;
　　unsigned i4=2123453; printf�Q?%d,%o,%x,%X,%ld,%hd,%u\n",i,i,i,i,i2,i3,i4�Q�；//如果是：%l,%h,则输不出�l�果
　　printf�Q?%d,%ld\n",i,i2�Q�；//试验不出%ld�?d之间的差别，因�ؓlong�?bytes www.yztrans.com
　　printf�Q?%hd,%hd\n\n\n",i,i3�Q�；//试验�?hd�?d之间的差别，因�ؓshort�?bytes
　　//for string and char
　　char ch1='d';
　　unsigned char ch2=160;
　　char *str="Hello everyone!";
　　printf�Q?%c,%u,%s\n\n\n",ch1,ch2,str�Q�；//unsigned char��过128的没有字�W�对�?br />　　//for float and double,unsigned and signed can not be used with double and float
　　float fl=2.566545445F;//or 2.566545445f
　　double dl=265.5651445; www.jamo123.com
　　long double dl2=2.5654441454;
　　//%g没有e格式�Q�默�?位包括小数点前面的数�Q?br />　　//%f没有e格式�Q�默�?位仅只小数点后面包含6�?br />　　//%e采用e格式�Q�默�?位�ؓ转化后的��数点后面的6�?br />　　printf�Q?%f,%e,%g,%.7f\n",fl,dl,dl,dl�Q�；
　　printf�Q?%f,%E,%G,%f\n",fl,dl,dl,dl�Q�；//%F is wrong
　　printf�Q?%.8f,%.10e\n",fl,dl�Q�；
　　printf�Q?%.8e,%.10f\n\n\n",fl,dl�Q�；
　　//for point
　　int *iP=&i;
　　char *iP1=new char;
　　void *iP2;//dangerous!
　　printf�Q?%p,%p,%p\n\n\n",iP,iP1,iP2�Q�；
　　//其他知识�Q�负��P��表示左对齐（默认是右寚w��Q�；%6.3,6表示宽度�Q?表示�_�ֺ�
　　char *s="Hello world!";
　　printf�Q?:%s: \n:%10s: \n:%.10s: \n:%-10s: \n:%.15s: \n:%-15s: \n:%15.10s: \n:%-15.10s:\n\n\n",
　　s,s,s,s,s,s,s,s�Q�； double ddd=563.908556444;
　　printf�Q?:%g: \n:%10g: \n:%.10g: \n:%-10g: \n:%.15g: \n:%-15g: \n:%15.10g: \n:%-15.10g:\n\n\n",
　　ddd,ddd,ddd,ddd,ddd,ddd,ddd,ddd�Q�；
　　//�q�有一个特�D�的格式%*.* ,�q�两个星��L��值分别由�W�二个和�W�三个参数的值指�?printf�Q?%.*s \n", 8, "abcdefgggggg"�Q�；
　　printf�Q?%*.*f \n", 3,3, 1.25456f�Q�； return 0;
　　}

HAOSOLA 2014-04-08 16:26 发表评论

亚洲国产欧美一区二区三区同亚洲 ,欧美大片专区,国产在线精品二区

C++���装dll�l�C#�{�其他语�a�使用�Ҏ��

利用C++ RAII技术自动回收堆内存