欧美成人第一页,亚洲图片欧美一区,欧美激情麻豆

Brandon — Wed, 16 Feb 2011 16:04:00 GMT

今天一个新同学来问一个典型的预处理的问题�Q�我当年也碰到这��L��问题�Q�脓出来�Q�让更多的�h能直接搜�?br>

预处理命�?/h1>

预定义变�?/a>

语法:

  __LINE__
            __FILE__
            __DATE__
            __TIME__
            _cplusplus
            __STDC__

下列参数在不同的�~�译器可能会有所不同, 但是一般是可用�?

__LINE__ �?__FILE__ 变量表示正在处理的当前行和当前文�?
__DATE__ 变量表示当前日期,格式�?em>month/day/year(�?�?�q?.
__TIME__ 变量描述当前的时�?格式�?em>hour:minute:second(�?�?�U?.
_cplusplus 变量只在�~�译一个C++�E�序时定�?
__STDC__ 变量在编译一个C�E�序时定�?�~�译C++时也有可能定�?

Brandon 2011-02-17 00:04 发表评论

好吧�Q�我被征服了—�?关于 c++ unsigned char

Brandon — Sun, 13 Feb 2011 08:12:00 GMT

1 unsigned char i;
2 i=-20;
3

上面一�D�很��单的代码�Q�如果输��Z��是什�?呢？
今天��里的新学c++同学问我�Q�unsighed char 和char 有啥区别�Q�上面的输出会有什�?不同
在这里，我先鄙视一下自己，我直观的理解为通常�?首位�W�号位，然后丢下的就是输入无�W�号的。好吧，估计各位看官说我太菜�Q�但��实是输出的�l�果和我想的不大一��P��如果各位没明白我说的是什么问题，可以试一下。然后回来看下面的内宏V�?br>

�?br>

In an unsigned type, all the bits represent the value. If a type is defined for a particular machine to use 8 bits, then the unsigned version of this type could hold the values 0 through 255.

无符号型中，所有的位都表示数倹{��如果在某种机器中，定义一�U�类型��?8 位表�C�，那么�q�种�c�d��? unsigned 型可以取�?0 �?255�?/p>

The C++ standard does not define how signed types are represented at the bit level. Instead, each compiler is free to decide how it will represent signed types. These representations can affect the range of values that a signed type can hold. We are guaranteed that an 8-bit signed type will hold at least the values from 127 through 127; many implementations allow values from 128 through 127.

C++ 标准�q�未定义 signed �c�d��如何用位来表�C�，而是由每个编译器自由军_��如何表示 signed �c�d��。这些表�C�方式会影响 signed �c�d��的取��D��围�? �?signed �c�d��的取��D��定至��是�?-127 �?127�Q�但也有许多实现允许取��g�� -128 �?127�?/p>

Under the most common strategy for representing signed integral types, we can view one of the bits as a sign bit. Whenever the sign bit is 1, the value is negative; when it is 0, the value is either 0 or a positive number. An 8-bit integral signed type represented using a sign-bit can hold values from 128 through 127.

表示 signed 整型�c�d��最常见的策略是用其中一个位作�ؓ�W�号位。符号位�?1�Q�值就��敎ͼ��W�号位�ؓ 0�Q�值就�?0 或正数。一�?signed 整型取值是�?-128 �?127�?/p>

Assignment to Integral Types

整型的赋�?/h5>
The type of an object determines the values that the object can hold. This fact raises the question of what happens when one tries to assign a value outside the allowable range to an object of a given type. The answer depends on whether the type is `signed` or `unsigned`.

对象的类型决定对象的取倹{��这会引起一个疑问：当我们试着把一个超出其取��D��围的��D��l�一个指定类型的对象�Ӟ��l�果会怎样呢？�{�案取决于这�U�类型是 `signed` �q�是 `unsigned` 的�?/p>
For `unsigned` types, the compiler must adjust the out-of-range value so that it will fit. The compiler does so by taking the remainder of the value modulo the number of distinct values the `unsigned` target type can hold. An object that is an 8-bit `unsigned char`, for example, can hold values from 0 through 255 inclusive. If we assign a value outside this range, the compiler actually assigns the remainder of the value modulo 256. For example, we might attempt to assign the value 336 to an 8-bit `signed char`. If we try to store 336 in our 8-bit `unsigned char`, the actual value assigned will be 80, because 80 is equal to 336 modulo 256.

对于 `unsigned` �c�d��来说�Q�编译器必须调整��界��g��其满��求。编译器会将该值对 `unsigned` �c�d��的可能取值数目求模，然后取所得倹{��比�?8 位的 `unsigned char`�Q�其取��D��围从 0 �? 255�Q�包�?255�Q�。如果赋�l�超��个范围的��|��那么�~�译器将会取该值对 256 求模后的倹{��例如，如果试图��?336 存储�?8 位的 `unsigned char` 中，则实际赋��gؓ 80�Q�因�?80 �?336 �?256 求模后的倹{�?/p>
For the `unsigned` types, a negative value is always out of range. An object of `unsigned` type may never hold a negative value. Some languages make it illegal to assign a negative value to an `unsigned` type, but C++ does not.

对于 `unsigned` �c�d��来说�Q�负数��L��出其取��D��围�?tt>unsigned �c�d��的对象可能永�q�不会保存负数。有些语�a�中将负数赋给 `unsigned` �c�d��是非法的�Q�但�?C++ 中这是合法的�?/p>

In C++ it is perfectly legal to assign a negative number to an object with `unsigned` type. The result is the negative value modulo the size of the type. So, if we assign 1 to an 8-bit `unsigned char`, the resulting value will be 255, which is 1 modulo 256.

C++ 中，把负��D��l?`unsigned` 对象是完全合法的�Q�其�l�果是该负数对该�c�d��的取��g��数求模后的倹{��所以，如果�?-1 赋给8位的 `unsigned char`�Q�那么结果是 255�Q�因�?255 �?-1 �?256 求模后的倹{�?/p>

When assigning an out-of-range value to a `signed` type, it is up to the compiler to decide what value to assign. In practice, many compilers treat `signed` types similarly to how they are required to treat `unsigned` types. That is, they do the assignment as the remainder modulo the size of the type. However, we are not guaranteed that the compiler will do so for the `signed` types.

当将��过取��D��围的��D��l?`signed` �c�d��Ӟ��q��译器军_��实际赋的倹{��在实际操作中，很多的编译器处理 `signed` �c�d��的方式和 `unsigned` �c�d��c�M��。也��是��_��赋值时是取该值对该类型取值数目求模后的倹{��然而我们不能保证编译器都会�q�样处理 `signed` �c�d��?/p>

以上摘自 c++ primer,惭愧�Q�还是再�l�细的从头品一�ơ这书吧�?br>

Brandon 2011-02-13 16:12 发表评论

c语言中可变参数函数的设计

Brandon — Thu, 17 Jun 2010 15:52:00 GMT

1�Q�首先，怎么得到参数的倹{��对于一般的函数�Q�我们可以通过参数对应在参数列表里的标识符来得到。但是参数可变函数那些可变的参数是没有参数标识符的，它只�?#8220;…”�Q�所以通过标识�W�来得到是不可能的，我们只有另辟途径�?br>
我们知道函数调用旉��会分配栈�I�间�Q�而函数调用机制中的栈�l�构如下图所�C�：

                       |     ......     |

                       ------------------

                       |     参数2      |

                       ------------------

                       |     参数1      |

                       ------------------

                       |    �q�回地址    |

                       ------------------

                       |调用函数�q�行状态|

                       ------------------

可见�Q�参数是�q�箋存储在栈里面的，那么也就是说�Q�我们只要得到可变参数的前一个参数的地址�Q�就可以通过指针讉K��到那些可变参数。但是怎么样得到可变参数的前一个参数的地址呢？不知道你注意到没有，参数可变函数在可变参��C��前必有一个参数是固定的，�q��用标识符�Q�而且通常被声明�ؓchar*�c�d��Q�printf函数也不例外。这��L��话，我们��可以通过�q�个参数对应的标识符来得到地址�Q�从而访问其他参数变得可能。我们可以写一个测试程序来试一下：

#include

void va_test(char* fmt,...);//参数可变的函数声�?br>

void main()

{

    int a=1,c=55;

       char b='b';

    va_test("",a,b,c);//用四个参数做��试

}

void va_test(char* fmt,...) //参数可变的函数定义，注意�W�一个参��Cؓchar* fmt

{

   char *p=NULL;

      p=(char *)&fmt;//注意不是指向fmt�Q�而是指向&fmt�Q��ƈ且强制�{化�ؓchar *,以便一个一个字节访�?br>
      for(int i = 0;i<16;i++)//16是通过计算的��|��参数个数*4个字节）�Q�只是�ؓ了测试，暂且��就一�?br>
      {

                printf("%.4d ",*p);//输出p指针指向地址的�?br>
        p++;

      }

}

�~�译�q�行的结果�ؓ

0056 0000 0066 0000 | 0001 0000 0000 0000 | 0098 0000 0000 0000 | 0055 0000 0000 0000

��p��行结果可见，通过�q�样方式可以逐一获得可变参数的倹{�?br>
至于��Z��么通常被声明�ؓchar*�c�d��Q�我们慢慢看来�?br>
2�Q�怎样��定参数�c�d��和数�?br>
通过上述的方式，我们首先解决了取得可变参数值的问题�Q�但是对于一个参敎ͼ�值很重要�Q�其�c�d��同样举��轻重�Q�而对于一个函数来讲参��C��C��非常重要�Q�否则就会��生了一�p�d��的麻烦来。通过讉K��存储参数的栈�I�间�Q�我们�ƈ不能得到关于�c�d��的�Q何信息和参数个数的�Q何信息。我想你应该惛_��了——��用char *参数。Printf函数��是�q�样实现的，它把后面的可变参数类型都攑ֈ�了char *指向的字�W�数�l�里�Q��ƈ通过%来标识以便与其它的字�W�相区别�Q�从而确定了参数�c�d��也确定了参数个数。其实，用何�U�方式来到达�q�样的效果取决于函数的实现。比如说�Q�定义一个函敎ͼ�预知它的可变参数�c�d��都是int�Q�那么固定参数完全可以用int�c�d��来替换char*�c�d��Q�因为只要得到参��C��数就可以了�?br>
3�Q�言归正�?br>
   我想��C��q�里�Q�大概的轮廓已经呈现出来了。本来想��此作�Ş的（我的惰性��Ӟ��Q�但是一惛_��如果不具实用性便可能是一堆废物，枉费我打了这么些字，军_��q�是�l�箋下去�?br>
   我是比较抵制用那些不明所以的宏定义的�Q�所以在上面的阐�q�里一炚w��没有涉及定义�?lt;stdarg.h>的va(variable-argument)宏。事实上�Q�当时让我��生极大疑惑和好奇的正是这几个宏定义。但是现在我们不得不要去和这些宏定义打打交道�Q�毕竟我们在讨生计的时候还得用上他们，�q�也是我��C��?#8220;�a�归正�?#8221;的理由�?br>
   好了�Q�我们来看一下那些宏定义�?br>
   打开文�g�Q�找一下va_*的宏定义�Q�发��C��单单只有一�l�，但是在各�l�定义前都会有宏�~�译。宏�~�译指示的是不同��g�q�_��和编译器下用怎样的va宏定义。比较一下，不同之处主要在偏�U�量的计��上。我们还是拿个典型又熟悉的——X86的相兛_��定义�Q?br>
1)typedef char * va_list;

2)#define _INTSIZEOF(n)   ( (sizeof(n) + sizeof(int) - 1) & ~(sizeof(int) - 1) )

3)#define va_start(ap,v) ( ap = (va_list)&v + _INTSIZEOF(v) )

4)#define va_arg(ap,t)    ( *(t *)((ap += _INTSIZEOF(t)) - _INTSIZEOF(t)) )

5)#define va_end(ap)      ( ap = (va_list)0 )

我们逐一看来�Q?br>
�W�一个我想不必说了，�c�d��定义�|�了。第二个是颇有些来头的，我们也不得不搞懂它，因�ؓ后面的两个关键的宏定义都用到了。不知道你够不够�l�心�Q�有没有发现在上面的��试�E�序中，�W�二个可变参数明明是char�c�d��Q�可是在输出�l�果中占�?个byte。难道所有的参数都会�?个byte的空��_��那如果是double�c�d��的参敎ͼ�且不是会丢失数据�Q�如果你不嫌�ȝ��的话�Q�再��d��个测试吧�Q�在上面的测试程序中用一个double�c�d��Q�长度�ؓ8byte�Q�和一个long double�c�d��Q�长度�ؓ10byte�Q�做可变参数。发��C��么？double�c�d��占了8byte,而long double占了12byte。好像都�?的整数倍哦。不得不引出另一个概念了“寚w��Q�alignment�Q?#8221;,所谓对齐，对Intel80x86 机器来说��是要求每个变量的地址都是sizeof(int)的倍数。原来我们搞错了�Q�char�c�d��的参数只占了1byte�Q�但是它后面的参数因为对齐的关系只能跌��3byte存储�Q�而那3byte也就��费掉了。那��Z��么要寚w��Q�因为在寚w��方式下，CPU 的运行效率要快得多（举个例子吧，要说明的是下面的例子是我从网上摘录下来的�Q�不记得出处了�?br>
�C�Z��Q�如下图�Q�当一个long 型数�Q�如图中long1�Q�在内存中的位置正好与内存的字边界对齐时�Q�CPU 存取�q�个数只需讉K��一�ơ内存，而当一个long 型数�Q�如图中的long2�Q�在内存中的位置跨越了字边界�Ӟ��CPU 存取�q�个数就需要多�ơ访问内存，如i960cx 讉K��q�样的数需��d��存三�ơ（一个BYTE、一个SHORT、一个BYTE�Q�由CPU 的微代码执行�Q�对软�g透明�Q�，所以对齐方式下CPU 的运行效率明昑ֿ�多了�?br>
1       8       16      24      32

------- ------- ------- ---------

| long1 | long1 | long1 | long1 |

------- ------- ------- ---------

|        |        |         | long2 |

------- ------- ------- ---------

| long2 | long2 | long2 |        |

------- ------- ------- ---------

| ....)。好像扯得有点远来，但是有助于对_INTSIZEOF(n)的理解。位操作对于我来说是玄的东东。单个位�q�算�q�应付得来，而这样一个表辑ּ�摆在面前��晕了。怎么办？菜鸟自有菜的办法�?待箋)

Trackback: http://tb.blog.csdn.net/TrackBack.aspx?PostId=14721

---------------------------------------------------------------------------------------------------------------------

C语言中的可变参数函数    CSDN Blog推出文章指数概念�Q�文章指数是对Blog文章�l�合评分后推��出的，�l�合评分��分别是该文章的点击量，回复�ơ数�Q�被�|�摘收录数量�Q�文章长度和文章�c�d��Q�满�?00�Q�每月更��C��ơ�?br>
�W�一��?br>
C语言�~�程中有时会遇到一些参��C��数可变的函数,例如printf()函数,其函数原型�ؓ�Q?br>
int printf( const char* format, ...);

它除了有一个参数format固定以外,后面跟的参数的个数和�c�d��是可变的�Q�用三个�?#8220;…”做参数占位符�Q?实际调用时可以有以下的�Ş式：

printf("%d",i);
printf("%s",s);
printf("the number is %d ,string is:%s", i, s);

一个简单的可变参数的C函数

     先看例子�E�序。该函数臛_��有一个整数参�?其后占位�W?#8230;�Q�表�C�后面参数的个数不定。在�q�个例子里，所有的输入参数必须都是整数�Q�函数的功能只是打印所有参数的倹{��函��C��码如下：

//�C�Z��代码1�Q�可变参数函数的使用
#include "stdio.h"
#include "stdarg.h"
void simple_va_fun(int start, ...)
{
    va_list arg_ptr;
    int nArgValue =start;
    int nArgCout="0"; //可变参数的数�?br>    va_start(arg_ptr,start); //以固定参数的地址��v点确定变参的内存起始地址�?br>    do
    {
        ++nArgCout;
        printf("the %d th arg: %d",nArgCout,nArgValue); //输出各参数的�?br>        nArgValue = va_arg(arg_ptr,int); //得到下一个可变参数的�?br>    } while(nArgValue != -1);
    return;
}
int main(int argc, char* argv[])
{
    simple_va_fun(100,-1);
    simple_va_fun(100,200,-1);
    return 0;
}

下面解释一下这些代码。从�q�个函数的实现可以看�?我们使用可变参数应该有以下步骤：

⑴由于在�E�序中将用到以下�q�些�?
void va_start( va_list arg_ptr, prev_param );
type va_arg( va_list arg_ptr, type );
void va_end( va_list arg_ptr );
va在这里是variable-argument(可变参数)的意思�?br>�q�些宏定义在stdarg.h�?所以用到可变参数的�E�序应该包含�q�个头文件�?br>
⑵函数里首先定义一个va_list型的变量,�q�里是arg_ptr,�q�个变量是存储参数地址的指�?因�ؓ得到参数的地址之后�Q�再�l�合参数的类型，才能得到参数的倹{�?br>
⑶然后用va_start宏初始化⑵中定义的变量arg_ptr,�q�个宏的�W�二个参数是可变参数列表的前一个参�?��x��后一个固定参数�?br>
��L��后依�ơ用va_arg宏��arg_ptr�q�回可变参数的地址,得到�q�个地址之后�Q�结合参数的�c�d��Q�就可以得到参数的倹{�?br>
⑸设定结束条�Ӟ��q�里的条件就是判断参数值是否�ؓ-1。注意被调的函数在调用时是不知道可变参数的正��数目的�Q�程序员必须自己在代码中指明�l�束条�g。至于�ؓ什么它不会知道参数的数目，在看完这几个宏的内部实现机制后，自然��׃��明白�?br>
�W�二��?br>
C语言之可变参数问�?br>

C语言中有一�U�长度不��定的参敎ͼ�形如�Q?…"�Q�它主要用在参数个数不确定的函数中，我们最�Ҏ��惛_��的例子是printf函数�?br>
　　原型�Q?br>
　　int printf( const char *format [, argument]... );

　　使用例：

　　printf("Enjoy yourself everyday!\n");

　　printf("The value is %d!\n", value);

　　�q�种可变参数可以说是C语言一个比较难理解的部分，�q�里会由几个问题引发一些对它的分析�?br>
　　注意�Q�在C++中有函数重蝲�Q�overload�Q�可以用来区别不同函数参数的调用�Q�但它还是不能表�C�Z�Q意数量的函数参数�?br>
　　问题�Q�printf的实�?br>
　　请问�Q�如何自己实现printf函数�Q�如何处理其中的可变参数问题�Q?�{�案与分析：

　　在标准C语言中定义了一个头文�g专门用来对付可变参数列表�Q�它包含了一�l�宏�Q�和一个va_list的typedef声明。一个典型实现如下：

　　typedef char* va_list;

　　#define va_start(list) list = (char*)&va_alist

　　#define va_end(list)

　　#define va_arg(list, mode)\

　　((mode*) (list += sizeof(mode)))[-1]

　　自己实现printf�Q?br>
　　#include

　　int printf(char* format, …)

　　{

　　va_list ap;

　　va_start(ap, format);

　　int n = vprintf(format, ap);

　　va_end(ap);

　　return n;

　　}

　　问题�Q�运行时才确定的参数

　　有没有办法写一个函敎ͼ��q�个函数参数的具体�Ş式可以在�q�行时才��定�Q?br>
　　�{�案与分析：

　　目前没有"正规"的解军_��法，不过独门偏方倒是有一个，因�ؓ有一个函数已�l�给我们做出了这斚w��的榜��P��那就是main()�Q�它的原型是:

　　int main(int argc,char *argv[]);
函数的参数是argc和argv�?br>
　　深入想一下，"只能在运行时��定参数形式"�Q�也��是说你没办法从声明中看到所接受的参敎ͼ�也即是参数根本就没有固定的�Ş式。常用的办法是你可以通过定义一个void *�c�d��的参敎ͼ�用它来指向实际的参数区，然后在函��C��Ҏ��Ҏ��需要�Q意解释它们的含义。这��是main函数中argv的含义，而argc�Q�则用来表明实际的参��C��敎ͼ��q��ؓ我们使用提供了进一步的方便�Q�当�Ӟ��q�个参数不是必需的�?br>
　　虽然参数没有固定形式�Q�但我们必然要在函数中解析参数的意义�Q�因此，理所当然会有一个要求，��是调用者和被调者之间要对参数区内容的格式，大小�Q�有效性等所有方面达成一��_��否则南辕北辙各说各话��惨了�?br>
　　问题�Q�可变长参数的传�?br>
　　有时候，需要编写一个函敎ͼ��它的可变长参数直接传递给另外的函敎ͼ�请问�Q�这个要求能否实玎ͼ�

　　�{�案与分析：

　　目前�Q�你��无办法直接做到�q�一点，但是我们可以�q�回前进�Q�首先，我们定义被调用函数的参数为va_list�c�d��Q�同时在调用函数中将可变长参数列表�{换�ؓva_list�Q�这样就可以�q�行变长参数的传递了。看如下所�C�：

　　void subfunc (char *fmt, va_list argp)

　　{

　　...

　　arg = va_arg (fmt, argp); /* 从argp中逐一取出所要的参数 */

　　...

　　}

　　void mainfunc (char *fmt, ...)

　　{

　　va_list argp;

　　va_start (argp, fmt); /* ��可变长参数转换为va_list */

　　subfunc (fmt, argp); /* ��va_list传递给子函�?*/

　　va_end (argp);

　　...

　　}

　　问题�Q�可变长参数中类型�ؓ函数指针

　　我想使用va_arg来提取出可变长参��C��c�d��为函数指针的参数�Q�结果却��L��不正��，��Z��么？

　　�{�案与分析：

　　�q�个与va_arg的实现有兟뀂一个简单的、演�C�版的va_arg实现如下�Q?br>
　　#define va_arg(argp, type) \

　　(*(type *)(((argp) += sizeof(type)) - sizeof(type)))

　　其中�Q�argp的类型是char *�?br>
　　如果你想用va_arg从可变参数列表中提取出函数指针类型的参数�Q�例�?br>
　　int (*)()�Q�则va_arg(argp, int (*)())被扩展�ؓ�Q?br>
　　(*(int (*)() *)(((argp) += sizeof (int (*)())) -sizeof (int (*)())))

　　昄��Q�（int (*)() *�Q�是无意义的�?br>
　　解决�q�个问题的办法是��函数指针用typedef定义成一个独立的数据�c�d��Q�例如：

　　typedef int (*funcptr)()�Q?br>
　　�q�时候再调用va_arg(argp, funcptr)��被扩展为：

　　(* (funcptr *)(((argp) += sizeof (funcptr)) - sizeof (funcptr)))

　　�q�样��可以通过�~�译��查了�?br>
　　问题�Q�可变长参数的获�?br>
　　有这样一个具有可变长参数的函敎ͼ�其中有下列代码用来获取类型�ؓfloat的实参：

　　va_arg (argp, float);

　　�q�样做可以吗�Q?br>
　　�{�案与分析：

　　不可以。在可变长参��C��Q�应用的�?加宽"原则。也��是float�c�d��被扩展成double�Q�char, short被扩展成int。因此，如果你要��d��变长参数列表中原来�ؓfloat�c�d��的参敎ͼ�需要用va_arg(argp, double)。对char和short�c�d��的则用va_arg(argp, int)�?br>
　　问题�Q�定义可变长参数的一个限�?br>
　　��Z��么我的编译器不允许我定义如下的函敎ͼ�也就是可变长参数�Q�但是没有�Q何的固定参数�Q?br>
　　int f (...)

　　{

　　...

　　}

　　�{�案与分析：

　　不可以。这是ANSI C 所要求的，你至��得定义一个固定参数�?br>
　　�q�个参数��被传递给va_start()�Q�然后用va_arg()和va_end()来确定所有实际调用时可变长参数的�c�d��和倹{�?--------------------------------------------------------------------------------------------------------------------
如何判别可变参数函数的参数类型？

函数形式如下�Q?br>void   fun(char*   str,...)
{
      ......
}

若传的参��C��数大�?�Q�如何判别第2个以后传参的参数�c�d��Q�？�Q?br>最好有源码说明�Q?

没办法判断的

如楼上所�?例如printf( "%d%c%s ",   ....)是通过格式串中�?d,   %c,   %s来确定后面参数的�c�d��,其实你也可以参考这�U�方法来判断不定参数的类�?

无法判断。可变参数实��C��要通过三个宏实玎ͼ�va_start,   va_arg,   va_end�?br>

六�?扩展与思�?br>
个数可变参数在声明时只需"..."卛_��Q�但是，我们在接受这些参数时不能"..."。va函数实现的关键就是如何得到参数列表中可选参敎ͼ�包括参数的值和�c�d��。以上的所有实现都是基于来自stdarg.h的va_xxx的宏定义�?<思�?gt;能不能不借助于va_xxx�Q�自己实现VA呢？�Q�我惛_��的方法是汇编。在C中，我们当然��q��C的嵌入汇�~�来实现�Q�这应该是可以做得到的。至于能做到什么程度，�E�_��性和效率怎么��P��主要要看你对内存和指针的控制了�?br>
参考资�?br>
1.IEEE和OpenGroup联合开发的Single Unix specification Ver3�Q�BR>
2.Linux man手册�Q?br>
3.x86汇编�Q�还有一些安全编码方面的资料�?br>
---------------------------------------------------------------------------------------------------------------------
[转帖]对C/C++可变参数表的深层探烦

C/C++语言有一个不同于其它语言的特性，卛_��支持可变参数�Q�典型的函数如printf、scanf�{�可以接受数量不定的参数。如�Q?br>　　printf ( "I love you" );
　　printf ( "%d", a );
　　printf ( "%d,%d", a, b );
　　�W�一、二、三个printf分别接受1�?�?个参敎ͼ�让我们看看printf函数的原型：
　　int printf ( const char *format, ... );
　　从函数原型可以看出，光��了接收一个固定的参数format以外�Q�后面的参数�?…"表示。在C/C++语言中，"…"表示可以接受不定数量的参敎ͼ�理论上来�Ԍ��可以�?�?以上的n个参数�?br>　　本文��对C/C++可变参数表的使用�Ҏ��及C/C++支持可变参数表的深层机理�q�行探烦�?br>
　　一. 可变参数表的用法
　　1、相兛_��
　　标准C/C++包含头文件stdarg.h�Q�该头文件中定义了如下三个宏�Q?br>void va_start ( va_list arg_ptr, prev_param ); /* ANSI version */
type va_arg ( va_list arg_ptr, type );
void va_end ( va_list arg_ptr );
　　在这些宏中，va��是variable argument(可变参数)的意思；arg_ptr是指向可变参数表的指针；prev_param则指可变参数表的前一个固定参敎ͼ�type为可变参数的�c�d��。va_list也是一个宏�Q�其定义为typedef char * va_list�Q�实质上是一 char型指针。char型指针的特点�?+�?-操作对其作用的结果是�?和减1�Q�因为sizeof(char)�?�Q�，与之不同的是int�{�其它类型指针的++�?-操作对其作用的结果是增sizeof(type)或减sizeof(type)�Q�而且sizeof (type)大于1�?br>　　通过va_start宏我们可以取得可变参数表的首指针�Q�这个宏的定义�ؓ�Q?br>#define va_start ( ap, v ) ( ap = (va_list)&v + _INTSIZEOF(v) )
　　显而易见，其含义�ؓ��最后那个固定参数的地址加上可变参数对其的偏�U�d��赋值给ap�Q�这样ap��是可变参数表的首地址。其中的_INTSIZEOF宏定义�ؓ�Q?br>#define _INTSIZEOF(n) ((sizeof ( n ) + sizeof ( int ) - 1 ) & ~( sizeof( int ) - 1 ) )
　　va_arg宏的意思则指取出当前arg_ptr所指的可变参数�q�将ap指针指向下一可变参数�Q�其原型为：
#define va_arg(list, mode) ((mode *)(list =(char *) ((((int)list + (__builtin_alignof(mode)<=4?3:7)) &(__builtin_alignof(mode)<=4?-4:-8))+sizeof(mode))))[-1]
　　对这个宏的具体含义我们将在后面深入讨论�?br>　　而va_end宏被用来�l�束可变参数的获取，其定义�ؓ�Q?br>#define va_end ( list )
　　可以看出�Q�va_end ( list )实际上被定义为空�Q�没有�Q何真实对应的代码�Q�用于代码对�U�ͼ�与va_start对应�Q�另外，它还可能发挥代码�?自注�?作用。所谓代码的"自注�?�Q�指的是代码能自己注释自己�?br>　　下面我们以具体的例子来说明以上三个宏的��用方法�?br>　　2、一个简单的例子
　　#include
　　/*　函数名：max
　　*　功能�Q�返回n个整��C��的最大�?br>　　* 参数�Q�num�Q�整数的个数 ...�Q�num个输入的整数
　　* �q�回��|��求得的最大整�?br>　　*/
　　int max ( int num, ... )
　　{
　　　int m = -0x7FFFFFFF; /* 32�pȝ��中最��的整数 */
　　　va_list ap;
　　　va_start ( ap, num );
　　　for ( int i= 0; i< num; i++ )
　　　{
　　　　int t = va_arg (ap, int);
　　　　if ( t > m )
　　　　{
　　　　　m = t;
　　　　}
　　　}
　　　va_end (ap);
　　　return m;
　　}
　　/* ��d��数调用max */
　　int main ( int argc, char* argv[] )
　　{
　　　int n = max ( 5, 5, 6 ,3 ,8 ,5); /* �?个整��C��的最大�?*/
　　　cout << n;
　　　return 0;
　　}
　　函数max中首先定义了可变参数表指针ap�Q�而后通过va_start ( ap, num )取得了参数表首地址�Q�赋�l�了ap�Q�，其后的for循环则用来遍历可变参数表。这�U�遍历方式与我们在数据结构教材中�l�常看到的遍历方式是�c�M��的�?br>　　函数max看�v来简�z�明了，但是实际上printf的实现却�q�比�q�复杂。max函数之所以看��h��单，是因为：
　　(1) max函数可变参数表的长度是已知的�Q�通过num参数传入�Q?br>　　(2) max函数可变参数表中参数的类型是已知的，都�ؓint型�?br>　　而printf函数则没有这么幸�q�。首先，printf函数可变参数的个��C��能轻易的得到�Q�而可变参数的�c�d��也不是固定的�Q�需由格式字�W�串�q�行识别�Q�由%f�?d�?s�{�确定）�Q�因此则涉及到可变参数表的更复杂应用�?br>　　下面我们以实例来分析可变参数表的高��应用�?br>
　　�? 高��应用
　　下面�q�个�E�序是我们�ؓ某嵌入式�pȝ��Q�该�pȝ��中CPU的字长�ؓ16位）�~�写的在屏幕上显�C�格式字�W�串的函数DrawText�Q�它的用法类��g�� int printf ( const char *format, ... )函数�Q�但其输出的目标为嵌入式�pȝ��的液晶显�C�屏�q�（LED�Q��?br>　　///////////////////////////////////////////////////////////////////////////////
　　// 函数名称: DrawText
　　// 功能说明: 在显�C�屏上绘制文�?br>　　// 参数说明: xPos ---横坐标的位置 [0 .. 30]
　　// yPos ---�U�坐标的位置 [0 .. 64]
　　// ... 可以同数字一��h��C�，需讄��标志(%d�?l�?x�?s)
　　///////////////////////////////////////////////////////////////////////////////
　　extern void DrawText ( BYTE xPos, BYTE yPos, LPBYTE lpStr, ... )
　　{
　　　BYTE lpData[100]; //�~�冲�?br>　　　BYTE byIndex;
　　　BYTE byLen;
　　　DWORD dwTemp;
　　　WORD wTemp;
　　　int i;
　　　va_list lpParam;
　　　memset( lpData, 0, 100);
　　　byLen = strlen( lpStr );
　　　byIndex = 0;
　　　va_start ( lpParam, lpStr );
　　　for ( i = 0; i < byLen; i++ )
　　　{
　　　　if( lpStr[i] != ’%’ ) //不是格式�W�开�?br>　　　　{
　　　　　lpData[byIndex++] = lpStr[i];
　　　　}
　　　　else
　　　　{
　　　　　switch (lpStr[i+1])
　　　　　{
　　　　　　//整型
　　　　　　case ’d’:
　　　　　　case ’D’:
　　　　　　　wTemp = va_arg ( lpParam, int );
　　　　　　　byIndex += IntToStr( lpData+byIndex, (DWORD)wTemp );
　　　　　　　i++;
　　　　　　　break;
　　　　　　//长整�?br>　　　　　　case ’l’:
　　　　　　case ’L’:
　　　　　　　dwTemp = va_arg ( lpParam, long );
　　　　　　　byIndex += IntToStr ( lpData+byIndex, (DWORD)dwTemp );
　　　　　　　i++;
　　　　　　　break;
　　　　　　//16�q�制�Q�长整型�Q?br>　　　　　　case ’x’:
　　　　　　case ’X’:
　　　　　　　dwTemp = va_arg ( lpParam, long );
　　　　　　　byIndex += HexToStr ( lpData+byIndex, (DWORD)dwTemp );
　　　　　　　i++;
　　　　　　　break;
　　　　　　default:
　　　　　　　lpData[byIndex++] = lpStr[i];
　　　　　　　break;
　　　　　}
　　　　}
　　　}
　　　va_end ( lpParam );
　　　lpData[byIndex] = ’#CONTENT#’;
　　　DisplayString ( xPos, yPos, lpData, TRUE);　//在屏�q�上昄��字符串lpData
　　}
　　在这个函��C��Q�需通过对传入的格式字符�Ԍ��首地址为lpStr�Q�进行识别来��L��可变参数个数及各个可变参数的�c�d��Q�具体实��C��现在for循环中。譬如，在识别�ؓ%d后，做的是va_arg ( lpParam, int )�Q�而获知�ؓ%l�?x后则�q�行的是va_arg ( lpParam, long )。格式字�W�串识别完成后，可变参数也就处理完了�?br>　　在项目的最初，我们一直苦于不能找��C��个好的办法来混合输出字符串和数字�Q�我们采用了分别昄��数字和字�W�串的方法，�q�分别指定坐标，�E�序条理被破坏。而且�Q�在混合昄��的时候，要给各类数据分别人工计算坐标�Q�我们感觉头��g��巌Ӏ�以前的函数为：
　　//昄��字符�?br>　　showString ( BYTE xPos, BYTE yPos, LPBYTE lpStr )
　　//昄��数字
　　showNum ( BYTE xPos, BYTE yPos, int num )
　　//�?6�q�制方式昄��数字
　　showHexNum ( BYTE xPos, BYTE yPos, int num )
　　最�l�，我们用DrawText ( BYTE xPos, BYTE yPos, LPBYTE lpStr, ... )函数代替了原先所有的输出函数�Q�程序得��C��化。就�q�样�Q�兄弟们用得爽翻了�?br>
　　�? �q�行机制探烦
　　通过�W?节我们学会了可变参数表的使用�Ҏ��Q�相信喜�Ƣ抛栚w��底的读者还不甘心，必然想知道如下问题：
　　�Q?�Q��ؓ什么按照第2节的做法��可以获得可变参数�ƈ对其�q�行操作�Q?br>　　�Q?�Q�C/C++在底层究竟是依靠什么来对这一语法�q�行支持的，��Z��么其它语�a��׃��能提供可变参数表呢？
　　我们带着�q�些疑问来一步步�q�行摸烦�?br>　　3.1 调用机制反汇�~?br>　　反汇�~�是研究语法深层�Ҏ��的�l�极良策�Q�先来看�?.2节例子中��d��数进行max ( 5, 5, 6 ,3 ,8 ,5)调用时的反汇�~�：
　　1. 004010C8 push 5
　　2. 004010CA push 8
　　3. 004010CC push 3
　　4. 004010CE push 6
　　5. 004010D0 push 5
　　6. 004010D2 push 5
　　7. 004010D4 call @ILT+5(max) (0040100a)
　　从上�q�反汇编代码中我们可以看出，C/C++函数调用的过�E�中�Q?br>　　�W�一步：��参��C��叛_��左入栈（�W?�?行）�Q?br>　　�W�二步：调用call指��o�q�行跌��{�Q�第7行）�?br>　　�q�两步包含了深刻的含义，它说明C/C++默认的调用方式�ؓ��p��用者管理参数入栈的操作�Q�且入栈的顺序�ؓ从右臛_��Q�这�U�调用方式称为_cdecl调用。x86�pȝ��的入栈方向�ؓ从高地址��C��地址�Q�故�W?至n个参数被攑֜�了地址递增的堆栈内。在被调用函数内部，��d��q�些堆栈的内容就可获得各个参数的��|��让我们反汇编到max函数的内部：
　　int max ( int num, ...)
　　{
　　1. 00401020 push ebp
　　2. 00401021 mov ebp,esp
　　3. 00401023 sub esp,50h
　　4. 00401026 push ebx
　　5. 00401027 push esi
　　6. 00401028 push edi
　　7. 00401029 lea edi,[ebp-50h]
　　8. 0040102C mov ecx,14h
　　9. 00401031 mov eax,0CCCCCCCCh
　　10. 00401036 rep stos dword ptr [edi]
　　va_list ap;
　　int m = -0x7FFFFFFF; /* 32�pȝ��中最��的整数 */
　　11. 00401038 mov dword ptr [ebp-8],80000001h
　　va_start ( ap, num );
　　12. 0040103F lea eax,[ebp+0Ch]
　　13. 00401042 mov dword ptr [ebp-4],eax
　　for ( int i= 0; i< num; i++ )
　　14. 00401045 mov dword ptr [ebp-0Ch],0
　　15. 0040104C jmp max+37h (00401057)
　　16. 0040104E mov ecx,dword ptr [ebp-0Ch]
　　17. 00401051 add ecx,1
　　18. 00401054 mov dword ptr [ebp-0Ch],ecx
　　19. 00401057 mov edx,dword ptr [ebp-0Ch]
　　20. 0040105A cmp edx,dword ptr [ebp+8]
　　21. 0040105D jge max+61h (00401081)
　　{
　　　int t= va_arg (ap, int);
　　　22. 0040105F mov eax,dword ptr [ebp-4]
　　　23. 00401062 add eax,4
　　　24. 00401065 mov dword ptr [ebp-4],eax
　　　25. 00401068 mov ecx,dword ptr [ebp-4]
　　　26. 0040106B mov edx,dword ptr [ecx-4]
　　　27. 0040106E mov dword ptr [t],edx
　　　if ( t > m )
　　　　28. 00401071 mov eax,dword ptr [t]
　　　　29. 00401074 cmp eax,dword ptr [ebp-8]
　　　　30. 00401077 jle max+5Fh (0040107f)
　　　　m = t;
　　　　31. 00401079 mov ecx,dword ptr [t]
　　　　32. 0040107C mov dword ptr [ebp-8],ecx
　　　}
　　　33. 0040107F jmp max+2Eh (0040104e)
　　　va_end (ap);
　　　34. 00401081 mov dword ptr [ebp-4],0
　　　return m;
　　　35. 00401088 mov eax,dword ptr [ebp-8]
　　}
　　36. 0040108B pop edi
　　37. 0040108C pop esi
　　38. 0040108D pop ebx
　　39. 0040108E mov esp,ebp
　　40. 00401090 pop ebp
　　41. 00401091 ret
　　分析上述反汇�~�代码，对于一个真正的�E�序员而言�Q�将是一�U�很大的享受�Q�而对于初学者，也将使其受益良多。所以请一定要赖着头皮认真研究�Q�千万不要被吓倒！
　　�?�?0�q�行执行函数内代码的准备工作�Q�保存现场。第2行对堆栈�q�行�U�d��Q�第3行则意味着max函数为其内部局部变量准备的堆栈�I�间�?0h字节�Q�第11行表�C�把变量n的内存空间安排在了函数内部局部栈底减8的位�|�（占用4个字节）�?br>　　�W?2�?3行非常关键，对应着va_start ( ap, num )�Q�这两行��第一个可变参数的地址赋值给了指针ap。另外，从第12行可以看出num的地址为ebp+0Ch�Q�从�W?3行可以看出ap被分配在函数内部局部栈底减4的位�|�上�Q�占�?个字节）�?br>　　�W?2�?7行最为关键，对应着va_arg (ap, int)。其中，22~24行的作用为将ap指向下一可变参数�Q�可变参数的地址间隔�?个字节，从add eax,4可以看出�Q�；25~27行则取当前可变参数的��D��l�变量t。这�D�反汇编很奇怪，它先�U�d��可变参数指针�Q�再在赋值指令里面回�q�头来取先前的参数��D��l�t�Q�从mov edx,dword ptr [ecx-4]语句可以看出�Q�。Visual C++同学玩得有意思，不知道碰见同��L��情况Visual Basic�{�其它同学怎么玩？
　　�W?6�?1行恢复现场和堆栈地址�Q�执行函数返回操作�?br>　　痛苦的反汇编之旅差不多结束了�Q�看了这�D�反汇编我们�ȝ��弄明白了可变参数的存放位�|�以及它们被��d��的方式，��觉全省��L��Q?br>　　2、特�D�的调用�U�定
　　除此之外�Q�我们需要了解C/C++函数调用对参数占用空间的一些特�D�约定，因�ؓ在_cdecl调用协议中，有些变量�c�d��是按照其它变量的��寸入栈的�?br>　　例如�Q�字�W�型变量��被自动扩展��Z��个字的空��_��因�ؓ入栈操作针对的是一个字�?br>　　参数n实际占用的空间�ؓ( ( sizeof(n) + sizeof(int) - 1 ) & ~( sizeof(int) - 1 ) )�Q�这��是�W?.1节_INTSIZEOF(v)宏的来历�Q?br>　　既然如此�Q�前面给出的va_arg ( list, mode )宏�ؓ什么玩�q�么大的飞机��很清楚了。这个问题就留个读者您来分�?

http://wp1314.ycool.com/post.3001515.html

Brandon 2010-06-17 23:52 发表评论

Brandon — Sun, 31 May 2009 04:38:00 GMT

�q�是我上�ơ从�q�里看到的把它给保存了下来，希望对你有用�?#160;
1. c++中string到int的�{�?#160;
1) 在C标准库里面，使用atoi�Q?#160;

#include
#include

std::string text = "152";
int number = std::atoi( text.c_str() );
if (errno == ERANGE) //可能是std::errno
{
//number可能�׃��q�大或过��而不能完全存�?#160;
}
else if (errno == ????)
//可能是EINVAL
{
//不能转换成一个数�?#160;
}

2) 在C++标准库里面，使用stringstream�Q?stringstream 可以用于各种数据�c�d��之间的�{�?

#include
#include

std::string text = "152";
int number;
std::stringstream ss;

ss < < text;//可以是其他数据类�?#160;
ss >> number; //string -> int
if (! ss.good())
{
//错误发生
}

ss < < number;// int->string
string str = ss.str();
if (! ss.good())
{
//错误发生
}

3) 在Boost库里面，使用lexical_cast�Q?#160;

#include
#include

try
{
std::string text = "152";
int number = boost::lexical_cast < int >( text );
}
catch( const boost::bad_lexical_cast & )
{
//转换��p�|
}

2.string �?CString
CString.format(”%s”, string.c_str());
用c_str()��实比data()要好�Q?#160;

3.char �?CString
CString.format(”%s”, char*);

4.char �?string
string s(char *);
只能初始化，在不是初始化的地�Ҏ��好还是用assign().

5.string �?char *
char *p = string.c_str();

6.CString �?string
string s(CString.GetBuffer());
GetBuffer()后一定要ReleaseBuffer(),否则��没有释攄��冲区所占的�I�间.

7.字符串的内容转换为字�W�数�l�和C—string
(1) data(),�q�回没有”\0“的字�W�串数组
(2) c_str()�Q�返回有”\0“的字�W�串数组
(3) copy()

8.CString与int、char*、char[100]之间的�{�?#160;

(1) CString互�{int

��字�W��{换�ؓ整数�Q�可以��用atoi、_atoi64或atol。而将数字转换为CString变量�Q�可以��用CString的Format函数。如
CString s;
int i = 64;
s.Format(”%d”, i)
Format函数的功能很强，值得你研�I�一下�?#160;

void CStrDlg::OnButton1()
{
CString
ss=”1212.12″;
int temp=atoi(ss);
CString aa;
aa.Format(”%d”,temp);
AfxMessageBox(”var is ” + aa);
}

(2) CString互�{char*

///char * TO cstring
CString strtest;
char * charpoint;
charpoint=”give string a value”; //?
strtest=charpoint;

///cstring TO char *
charpoint=strtest.GetBuffer(strtest.GetLength());

(3) 标准C里没有string,char *==char []==string, 可以用CString.Format(”%s”,char *)�q�个�Ҏ��来将char *转成CString�?#160;
要把CString转成char *�Q�用操作�W�（LPCSTR�Q�CString��可以了�?#160;
CString转换 char[100]
char a[100];
CString str(”aaaaaa”);
strncpy(a,(LPCTSTR)str,sizeof(a));

Brandon 2009-05-31 12:38 发表评论

泛型��法

Brandon — Fri, 10 Apr 2009 04:27:00 GMT

拯��Q?br>

copy�Q�）
reverse_copy()
rotate_copy()
remove_copy() 拯��不等于某值的元素到另一个序列�?br>remove_copy_if() 拯��W�合条�g的到另一个序列�?/p>

填充和生成：
fill()
fill_n() 填充序列中的n个元素�?br>generate�Q�）为序列中的每个元素调用gen�Q�）函数�?/p>

排列�Q?br>next_permuttion() 后一个排列�?br>prev_permutation()

partition() 划分�Q�将满��条�g的元素移动到序列的前面�?br>stable_partition()

查找和替换：
find�Q�）
binary_search() 在一个已�l�有��序的序列上查找�?br>find_if()
search() ��查第二个序列是否在第一个序列中出现�Q�且��序相同�?/p>

删除�Q�注意必��调用erase�Q�）来真正删�?br>remove�Q�）
unique�Q�）删除盔R��重复元素�Q�最好现排序�?/p>

合�ƈ序列�Q?br>merge�Q�）

数值算法：
accumulate�Q�）对序列的每个元素�q�行�q�算后求和�?br>transform�Q�）也可以对每个元素�q�行�q�算�?br>计数�Q?br>size�Q�）��M��数�?br>count�Q�）�{�于某值的元素个数�?/p>

adjacent_difference 序列中的后一个减前与他相�ȝ��前一个得到新的序列�?/p>

adiacent_find

accumlate �Q?/span> iterator �Ҏ��志的序列中的元素之和�Q�加��C��个由 init 指定的初始��g��。重载的版本不再做加法，而是传进来的二元操作�W�被应用到元素上�?/span>

adjacent_different �Q�创��Z��个新序列�Q�该序列的每个新值都代表了当前元素与上一个元素的差。重载版本用指定的二元操作计��相��d��素的差�?/font>
adjacent_find �Q�在 iterator �Ҏ��志的元素范围内，查找一对相�ȝ��重复元素�Q�如果找到返回一�?/span> ForwardIterator �Q�指向这对元素的�W�一个元素。否则返�?/span> last 。重载版本��用输入的二元操作�W�代替相�{�的判断�?/span>
binary_search �Q�在有序序列中查�?/span> value �Q�如果找到返�?/span> true 。重载的版本使用指定的比较函数对象或者函数指针来判断相等�?/span>
copy �Q�复制序列�?/font>
copy_backward �Q�除了元素以相反的顺序被拯��外，别的�?/span> copy 相同�?/span>
count �Q�利用等于操作符�Q�把标志范围�cȝ��元素与输入的��D��行比较，�q�返回相�{�元素的个数�?/font>
count_if �Q�对于标志范围类的元素，应用输入的操作符�Q��ƈ�q�回�l�果�?/span> true 的次数�?/span>
equal �Q�如果两个序列在范围内的元素都相�{�，�?/span> equal �q�回 true 。重载版本��用输入的操作�W�代替了默认的等于操作符�?/span>
equal_range �Q�返回一�?/span> iterator �Q�第一�?/span> iterator 表示�?/span> lower_bound �q�回�?/span> iterator �Q�第二个表示�?/span> upper_bound �q�回�?/span> iterator倹{�?/span>
fill �Q�将输入的值的拯��赋给范围内的每个元素�?/font>
fill_n �Q�将输入的��D��值给 first �?/span> frist+n 范围内的元素�?/span>
find �Q�利用底层元素的�{�于操作�W�，对范围内的元素与输入的��D��行比较。当匚w��Ӟ��l�束搜烦�Q�返回该元素的一�?/span> InputIterator �?/span>
find_if �Q��用输入的函数替代了等于操作符执行�?/span> find �?/span>
find_end �Q�在范围内查�?#8220;��p��入的另外一�?/span> iterator �Ҏ��志的�W�二个序�?#8221;的最后一�ơ出现。重载版本中使用了用戯��入的操作�W�替代等于操作�?/span>
find_first_of �Q�在范围内查�?#8220;��p��入的另外一�?/span> iterator �Ҏ��志的�W�二个序�?#8221;中的��L��一个元素的�W�一�ơ出现。重载版本中使用了用戯��定义的操作符�?/span>
for_each �Q�依�ơ对范围内的所有元素执行输入的函数�?/font>
generate �Q�通过对输入的函数 gen 的连�l�调用来填充指定的范围�?/span>
generate_n �Q�填�?/span> n 个元素�?/span>
includes �Q�判�?/span> [first1, last1) 的一个元素是否被包含在另外一个序列中。��用底层元素的 <= 操作�W�，重蝲版本使用用户输入的函数�?/span>
inner_product �Q�对两个序列做内�U?/span> ( 对应的元素相乘，再求�?/span> ) �Q��ƈ��内�U�加��C��个输入的的初始��g��。重载版本��用了用户定义的操作�?/span>
inner_merge �Q�合�q�两个排�q�序的连�l�序列，�l�果序列覆盖了两端范��_��重蝲版本使用输入的操作进行排序�?/font>
iter_swap �Q�交换两�?/span> ForwardIterator 的倹{�?/span>
lexicographical_compare �Q�比较两个序列。重载版本��用了用户自定义的比较操作�?/font>
lower_bound �Q�返回一�?/span> iterator �Q�它指向在范围内的有序序列中可以插入指定��D��不破坏容器��序的第一个位�|�。重载函��C��用了自定义的比较操作�?/span>
max �Q�返回两个元素中的较大的一个，重蝲版本使用了自定义的比较操作�?/font>
max_element �Q�返回一�?/span> iterator �Q�指出序列中最大的元素。重载版本��用自定义的比较操作�?/span>
min �Q�两个元素中的较��者。重载版本��用自定义的比较操作�?/font>
min_element �Q�类��g�� max_element �Q�不�q�返回最��的元素�?/span>
merge �Q�合�q�两个有序序列，�q�存攑ֈ�另外一个序列中。重载版本��用自定义的比较�?/font>
mismatch �Q��ƈ行的比较两个序列�Q�指出第一个不匚w��的位�|�，它返回一�?/span> iterator �Q�标志第一个不匚w��的元素位�|�。如果都匚w��Q�返回每个容器的 last 。重载版本��用自定义的比较操作�?/span>
next_permutation �Q�取出当前范围内的排列，�q�将光��新排序�ؓ下一个排列。重载版本��用自定义的比较操作�?/font>
nth_element �Q�将范围内的序列重新排序�Q��所有小于第 n 个元素的元素都出现在它前面，而大于它的都出现在后面，重蝲版本使用了自定义的比较操作�?/span>
partial_sort �Q�对整个序列做部分排序，被排序元素的个数正好可以被放到范围内。重载版本��用自定义的比较操作�?/font>
partial_sort_copy �Q�与 partial_sort 相同�Q�除了将�l�过排序的序列复制到另外一个容器�?/span>
partial_sum �Q�创��Z��个新的元素序列，其中每个元素的��g��表了范围内该位置之前所有元素之和。重载版本��用了自定义操作替代加法�?/font>
partition �Q�对范围内元素重新排序，使用输入的函敎ͼ�把计��结果�ؓ true 的元素都攑֜��l�果�?/span> false 的元素之前�?/span>
prev_permutation �Q�取��围内的序列�ƈ��它重新排序��Z��一个序列。如果不存在上一个序列则�q�回 false 。重载版本��用自定义的比较操作�?/span>
random_shuffle �Q�对范围内的元素随机调整�ơ序。重载版本输入一个随机数产生操作�?/font>
remove �Q�删除在范围内的所有等于指定的元素�Q�注意，该函数�ƈ不真正删除元素。内�|�数�l�不适合使用 remove �?/span> remove_if 函数�?/span>
remove_copy �Q�将所有不匚w��的元素都复制��C��个指定容器，�q�回�?/span> OutputIterator 指向被拷贝的末元素的下一个位�|��?/span>
remove_if �Q�删除所有范围内输入操作�l�果�?/span> true 的元素�?/span>
remove_copy_if �Q�将所有不匚w��的元素拷贝到一个指定容器�?/font>
replace �Q�将范围内的所有等�?/span> old_value 的元素都�?/span> new_value 替代�?/span>
replace_copy �Q�与 replace �c�M��Q�不�q�将�l�果写入另外一个容器�?/span>
replace_if �Q�将范围内的所有操作结果�ؓ true 的元素用新值替代�?/span>
replace_copy_if �Q�类��g�� replace_if �Q�不�q�将�l�果写入另外一个容器�?/span>
reverse �Q�将范围内元素重新按反序排列�?/font>
reverse_copy �Q�类��g�� reverse �Q�不�q�将�l�果写入另外一个容器�?/span>
rotate �Q�将范围内的元素�U�d��容器末尾�Q�由 middle 指向的元素成为容器第一个元素�?/span>
rotate_copy �Q�类��g�� rotate �Q�不�q�将�l�果写入另外一个容器�?/span>
search �Q�给��Z��两个范围�Q�返回一�?/span> iterator �Q�指向在范围内第一�ơ出现子序列的位�|�。重载版本��用自定义的比较操作�?/span>
search_n �Q�在范围内查�?/span> value 出现 n �ơ的子序列。重载版本��用自定义的比较操作�?/span>
set_difference �Q�构造一个排�q�序的序列，其中的元素出现在�W�一个序列中�Q�但是不包含在第二个序列中。重载版本��用自定义的比较操作�?/font>
set_intersection �Q�构造一个排�q�序的序列，其中的元素在两个序列中都存在。重载版本��用自定义的比较操作�?/font>
set_symmetric_difference �Q�构造一个排�q�序的序列，其中的元素在�W�一个序列中出现�Q�但是不出现在第二个序列中。重载版本��用自定义的比较操作�?/font>
set_union �Q�构造一个排�q�序的序列，它包含两个序列中的所有的不重复元素。重载版本��用自定义的比较操作�?/font>
sort �Q�以升序重新排列范围内的元素�Q�重载版本��用了自定义的比较操作�?/font>
stable_partition �Q�与 partition �c�M��Q�不�q�它不保证保留容器中的相寚w��序�?/span>
stable_sort �Q�类��g�� sort �Q�不�q�保留相�{�元素之间的��序关系�?/span>
swap �Q�交换存储在两个对象中的倹{�?/font>
swap_range �Q�将在范围内的元素与另外一个序列的元素��D��行交换�?/font>
transform �Q�将输入的操作作用在范围内的每个元素上，�q��生一个新的序列。重载版本将操作作用在一对元素上�Q�另外一个元素来自输入的另外一个序列。结果输出到指定的容器�?/font>
unique �Q�清除序列中重复的元素，�?/span> remove �c�M��Q�它也不能真正的删除元素。重载版本��用了自定义的操作�?/span>
unique_copy �Q�类��g�� unique �Q�不�q�它把结果输出到另外一个容器�?/span>
upper_bound �Q�返回一�?/span> iterator �Q�它指向在范围内的有序序列中插入 value 而不破坏容器��序的最后一个位�|�，该位�|�标志了一个大�?/span> value 的倹{��重载版本��用了输入的比较操作�?/span>
堆算法： C++ 标准库提供的�?/span> max-heap 。一��q��以下 4 个泛型堆��法�?/span>
make_heap �Q�把范围内的元素生成一个堆。重载版本��用自定义的比较操作�?/font>
pop_heap �Q��ƈ不是真正的把最大元素从堆中弹出�Q�而是重新排序堆。它�?/span> first �?/span> last-1 交换�Q�然后重新做成一个堆。可以��用容器的 back 来访问被“弹出“的元素或者��?/span> pop_back 来真正的删除。重载版本��用自定义的比较操作�?/span>
push_heap �Q�假�?/span> first �?/span> last-1 是一个有效的堆，要被加入堆的元素在位�|?/span> last-1 �Q�重新生成堆。在指向该函数前�Q�必��d��把元素插入容器后。重载版本��用指定的比较�?/span>
sort_heap �Q�对范围内的序列重新排序�Q�它假设该序列是个有序的堆。重载版本��用自定义的比较操作�?/font>

Brandon 2009-04-10 12:27 发表评论

Brandon — Fri, 10 Apr 2009 01:20:00 GMT

摘要: typedef 的用�?#160;--摘自一位cnblog的一位大�?#160;用途一�Q?#160;定义一�U�类型的别名�Q�而不只是��单的宏替换。可以用作同时声明指针型的多个对象。比如： char* pa, pb; // �q�多��C��W�合我们的意图，它只声明了一个指向字�W�变量的指针�Q?#160;// 和一个字�W�变量；以下则可行： t... 阅读全文

Brandon 2009-04-10 09:20 发表评论

�c�d��转换

Brandon — Fri, 03 Apr 2009 03:10:00 GMT

昑ּ��c�d��转换又被�U�C��?强制�c�d��转换�?#160;
C 风格�Q?(type-id)
C++风格�Q?static_cast、dynamic_cast、reinterpret_cast、和const_cast
C风格的强制类型�{换是最好不要用的，最好是使用标准的C++风格的�{换符�?#160;

static_cast
用法�Q?/strong>static_cast < type-id > ( expression )
说明�Q?/strong>该运��符把expression转换为type-id�c�d��Q�但没有�q�行时类型检查来保证转换的安全性�?#160;
主要用法�Q?/strong>
用于�c�d��ơ结构中基类和子�c�M��间指针或引用的�{换。进行上行�{换（把子�cȝ��指针或引用�{换成基类表示�Q�是安全的；�q�行下行转换�Q�把基类指针或引用�{换成子类指针或引用）�Ӟ��׃��没有动态类型检查，所以是不安全的�?#160;
用于基本数据�c�d��之间的�{换，如把int转换成char�Q�把int转换成enum。这�U��{换的安全性也要开发�h员来保证�?#160;
把void指针转换成目标类型的指针(不安�?!)
把�Q何类型的表达式�{换成void�c�d��?#160;
注意�Q�static_cast不能转换掉expression的const、volitale、或者__unaligned属性�?#160;

dynamic_cast
用法�Q?/strong>dynamic_cast < type-id > ( expression )
说明�Q?/strong>该运��符把expression转换成type-id�c�d��的对象。Type-id必须是类的指针、类的引用或者void *�Q�如果type-id是类指针�c�d��Q�那么expression也必��L��一个指针，如果type-id是一个引用，那么expression也必��L��一个引用�?#160;
dynamic_cast主要用于�c�d��ơ间的上行�{换和下行转换�Q�还可以用于�c�M��间的交叉转换�?#160;
在类层次间进行上行�{换时�Q�dynamic_cast和static_cast的效果是一��L��Q?#160;
在进行下行�{换时�Q�dynamic_cast��h��c�d��查的功能�Q�比static_cast更安全�?#160;

reinterpret_cast
用法�Q?/strong>reinterpret_cast (expression)
说明�Q?/strong>type-id必须是一个指针、引用、算术类型、函数指针或者成员指针�?#160;
它可以把一个指针�{换成一个整敎ͼ�也可以把一个整数�{换成一个指针（先把一个指针�{换成一个整敎ͼ�
在把该整数�{换成原类型的指针�Q�还可以得到原先的指针��|��?#160;
该运��符的用法比较多�?#160;

const_cast
用法�Q?/strong>const_cast (expression)
说明�Q?/strong>该运��符用来修改�c�d��的const或volatile属性。除了const 或volatile修饰之外�Q?type_id和expression的类型是一��L��?#160;
帔R��指针被�{化成非常量指针，�q�且仍然指向原来的对象；
帔R��引用被�{换成非常量引用，�q�且仍然指向原来的对象；帔R��对象被�{换成非常量对象�?br>

Brandon 2009-04-03 11:10 发表评论

Brandon — Sun, 08 Feb 2009 02:42:00 GMT

class String
{
public:
    String(const char *str = NULL); // 普通构造函�?#160;
    String(const String &other); // 拯��构造函�?#160;
    ~ String(void); // 析构函数
    String & operate =(const String &other); // 赋值函�?#160;
private:
    char *m_data; // 用于保存字符�?#160;
};

// String 的析构函�?#160;
String::~String(void)
{
    delete [] m_data;// �׃��m_data 是内部数据类�?也可以写成delete m_data;
}

// String 的普通构造函�?#160;
String::String(const char *str)
{
    if(str==NULL)
    {
        m_data = new char[1]; // 若能加NULL 判断则更�?#160;
        *m_data = '\0';
    }
    else
    {
        int length = strlen(str);
        m_data = new char[length+1]; // 若能加NULL 判断则更�?#160;
        strcpy(m_data, str);
    }
}

// 拯��构造函�?#160;
String::String(const String &other)
{
    int length = strlen(other.m_data);
    m_data = new char[length+1]; // 若能加NULL 判断则更�?#160;
    strcpy(m_data, other.m_data);
}

// 赋值函�?#160;
String & String::operate =(const String &other)
{
    // (1) ��查自赋�?#160;
    if(this == &other)
        return *this;
    // (2) 释放原有的内存资�?#160;
    delete [] m_data;
    // (3)分配新的内存资源,�q�复制内�?#160;
    int length = strlen(other.m_data);
    m_data = new char[length+1]; // 若能加NULL 判断则更�?#160;
    strcpy(m_data, other.m_data);
    // (4)�q�回本对象的引用
    return *this;
}

Brandon 2009-02-08 10:42 发表评论

Brandon — Sat, 07 Feb 2009 17:00:00 GMT
保持�l�一的接口，而具体行��Z��照对象而定�Q�不同的对象有不同的行�ؓ�Q�这个就是对多态的��单解�?�?br>

具体在C++语言中，多态通过指针和引用来表现�?br>��x��口��用父�cȝ��指针或引用来表明抽象的统一的接口，而行为根据父�c�L��针或引用所指向具体子类对象�Q�不同的对象表现��Z��同的行�ؓ�Q�此乃C++实现多态的风格�Q�具体来说我们在�~�程的时候需要��用指向父�cȝ��指针或者引用，然后在子�c�M��改写父类中的虚函敎ͼ�最后再把子�c�d��象赋值到父类指针或引用上�?br>
C++的虚函数实际上采用散列表的数据结构实�?.

Brandon 2009-02-08 01:00 发表评论

欧美成人第一页,亚洲图片欧美一区,欧美激情麻豆

预处理命�?/h1>

#,##

#line

预定义变�?/a>

好吧�Q�我被征服了—�?关于 c++ unsigned char

Assignment to Integral Types

c语言中可变参数函数的设计

泛型��法

�c�d��转换

欧美成人第一页,亚洲图片欧美一区,欧美激情麻豆

预处理命�?/h1>

#,##

#line

预定义变�?/a>

好吧�Q�我被征服了—�?关于 c++ unsigned char

Assignment to Integral Types

c语言中可变参数函数的设计

泛型���法

�c�d��转换

泛型��法