久久亚洲2019中文字幕,91精品国产综合久久四虎久久无码一级,国产精品久久久久久久久鸭

C语言中char变量详解

oliver — Sun, 07 Nov 2010 05:22:00 GMT

char是C/C++整型数据中比较古怪的一个，其它的如int/long/short�{�不指定signed/unsigned旉��默认是signed。虽然char在标准中是unsigned�Q�因为char�c�d��提出的初��h��用来表示ascii码，ascii码的范围�?~127�Q�，但实际情况中�I�竟是signed�q�是unsigned取决于编译器�?br>可通过下面�E�序判断�~�译器的默认char�c�d��Q?br>

1void char_type()
2{
3  char c=0xFF;
4  if(c==-1)
5    printf("signed");
6  elseif(c==255)
7    printf("unsigned");
8  else
9    printf("error!");
10}

当你不确定编译器的默认char�c�d��Ӟ��q��昄��声明�Q�signed char和unsigned char�Q?br>
在C/C++语言中，char变量��Z��个字节，8位，signed char表示的范��_��-128~127�?128在内存中的二�q�制表示�?000 0000�Q?27在内存中的表�C�Zؓ0111 1111】；unsign char表示的范��_��0000 0000~1111 1111�Q�即0~255�Q?br>
注意�Q�整数在内存中是以补码存取的�Q�正数的补码�Q�等于自己，负数的补码：取反�?�Q�例如：127在内存中表示�?111 1111�Q?-127在内存中表示为~(0111 1111)+1=1000 0001�Q?假定某内存单元p的内�Ҏ��1111 1111�Q�那么它一定是255吗？实际上取决于你的代码是要把它看成有符可��是无�W�号敎ͼ�如果是无�W�号则表�C?55�Q�如果是有符号则表示-1【对于有�W�号敎ͼ�最高位为符号位�Q?表示负，0表示正】：
signed char c=*p; //c=-1
unsigned char c=*p;//c=255
�q�也解释了上面这�D�代码能判断�~�译器默认char�c�d��?br>

oliver 2010-11-07 13:22 发表评论

库函数memcpy()与memmove()实现

oliver — Fri, 29 Oct 2010 12:06:00 GMT

�Ҏ��MSDN文档�Q�当源区域与目标区域存在重叠�Ӟ��memcpy()函数报错�Q�而memmove()函数可以处理重叠情况�Q?br>

1/*
2 * 函数�? memcpy
3 * �?nbsp; �? 从源source中拷贝n个字节到目标destin�?nbsp;
4 * �?nbsp; �? void *memcpy(void* destin, const void* source, size_t n);
5 * �?nbsp; �? 内存拯��
6*/
7
8#include <stdio.h>
9#include <conio.h>   //getch头文�?/span>
10#include <assert.h>  //assert头文�?/span>
11
12typedef unsigned char byte;
13//typedef unsigned int size_t;
14
15
16/*
17memcpy函数�Q�如果内存重叠则报错
18*/
19//src要保�?/span>
20void* memcpy(void* dst,const void* src,size_t count)
21{
22    byte* pbTo = (byte*)dst;
23    byte* pbFrom = (byte*)src;
24    assert(dst!= NULL && src != NULL);//不能存在�I�指�?/span>
25    assert(pbTo >= pbFrom+count || pbFrom >= pbTo + count);//防止内存重叠(overlap)
26    while (count-- > 0)
27    {
28        *pbTo++ = *pbFrom++;
29    }
30    return dst;
31}
32
33/*
34memmove函数�Q�考虑了内存重叠的情况
35*/
36//src可以不保�?/span>
37void* memmove(void* dst,const void* src,size_t count)
38{
39    byte* pbTo = (byte*)dst;
40    byte* pbFrom = (byte*)src;
41    assert(dst != NULL && src != NULL);//不能存在�I�指�?/span>
42    if (dst <= src || pbTo >= pbFrom + count)//
43    {
44        while (count-- > 0)
45        {
46            *pbTo++ = *pbFrom++; //按递增拯��
47        }
48    }
49    else  //
50    {
51        pbTo = pbTo + count -1;//overlap的情况，从高位地址向低位拷�?nbsp;
52        pbFrom = pbFrom + count -1;
53        while (count-- > 0)
54        {
55            *pbTo-- = *pbFrom--; //按递减拯��
56        }
57    }
58    return dst;
59}
60
61
62

oliver 2010-10-29 20:06 发表评论

C++著名�E�序库介�l?STL.Boost.GUI.XML.�|�络.�U�程.�U�学计算�{?

oliver — Thu, 28 Oct 2010 02:20:00 GMT

1、C++各大有名库的介绍——C++标准库STL
2、C++各大有名库的介绍——准标准库Boost
3、C++各大有名库的介绍——GUI
4、C++各大有名库的介绍——网�l�通信
5、C++各大有名库的介绍——XML
6、C++各大有名库的介绍——科学计��?br>7、C++各大有名库的介绍——游戏开�?br>8、C++各大有名库的介绍——线�E?br>9、C++各大有名库的介绍——序列化
10、C++各大有名库的介绍——字�W�串
11、C++各大有名库的介绍——综�?br>12、C++各大有名库的介绍——其他库
13、C++名�h的网�?br>14、C++开源跨�q�_��c�d��及在VC++.net中应用的配置
15、C++资源之不完全导引

在C++中，库的��C��是非帔R��的。C++之父 Bjarne Stroustrup先生多次表示了设计库来扩充功能要好过设计更多的语法的�a�论。现实中�Q�C++的库门类�J�多�Q�解决的问题也是极其�q�泛�Q�库从轻量��到重量��的都有。不��都是让人眼界大开�Q�亦或是望而生叹的思维��C��。由于库的数量非常庞大，而且限于�W�者水�q�I��其中很多�q�不了解。所以文中所提的一些库都是比较著名的大型库�?/p>

详细库介�l�请参考网址�Q?a >http://blog.csdn.net/dbafans/archive/2010/06/16/5673114.aspx

oliver 2010-10-28 10:20 发表评论

oliver — Sun, 24 Oct 2010 06:11:00 GMT

�q�是本小��Z��。原名是《using stl》，不知道是谁写的。不�q�我倒觉得很有趣�Q�所以化了两个晚上把它翻译出来。我没有对翻译出来的内容校验�q�。如果你没法在三十分钟内觉得有所收获�Q�那么赶紧扔了它。文中我省略了很多东�ѝ��心疼那�Q�浪�Ҏ��两个晚上�?
译者：kary

contact:karymay@163.net

STL概述
STL的一个重要特�Ҏ��数据�l�构和算法的分离。尽��这是个��单的概念�Q�但�q�种分离��实使得STL变得非常通用。例如，�׃��STL的sort()函数是完全通用的，你可以用它来操作几乎��M��数据集合�Q�包括链表，容器和数�l��?/p>

要点
STL��法作�ؓ模板函数提供。�ؓ了和其他�l��g相区别，在本书中STL��法以后接一对圆括弧的方式表�C�，例如sort()�?/p>

STL另一个重要特性是它不是面向对象的。�ؓ了具有��够通用性，STL主要依赖于模板而不是封装，�l�承和虚函数�Q�多态性）——OOP的三个要素。你在STL中找不到��M��明显的类�l�承关系。这好像是一�U�倒退�Q�但�q�正好是使得STL的组件具有广泛通用性的底层特征。另外，�׃��STL是基于模板，内联函数的��用��得生成的代码短小高效�?/p>

提示

��保在编译��用了STL的程序中臛_��要��?O优化来保证内联扩展。STL提供了大量的模板�c�d��函数�Q�可以在OOP和常规编�E�中使用。所有的STL的大�U?0个算法都是完全通用的，而且不依赖于��M��特定的数据类型。下面的��节说明了三个基本的STL�l��g�Q?/p>

1�Q?nbsp; �q�代器提供了讉K��容器中对象的�Ҏ��。例如，可以使用一对�P代器指定list或vector中的一定范围的对象。�P代器��如同一个指针。事实上�Q�C++的指针也是一�U��P代器。但是，�q�代器也可以是那些定义了operator*()以及其他�c�M��于指针的操作�W�地�Ҏ��的类对象�?/p>

2�Q?nbsp; 容器是一�U�数据结构，如list�Q�vector�Q�和deques �Q�以模板�cȝ��Ҏ��提供。�ؓ了访问容器中的数据，可以使用由容器类输出的�P代器�?/p>

3�Q?nbsp; ��法是用来操作容器中的数据的模板函数。例如，STL用sort()来对一个vector中的数据�q�行排序�Q�用find()来搜索一个list中的对象。函数本�w�与他们操作的数据的�l�构和类型无养I��因此他们可以在从��单数�l�到高度复杂容器的�Q何数据结构上使用�?/p>

头文�?br>��Z��避免和其他头文�g冲突�Q?STL的头文�g不再使用常规�?h扩展。�ؓ了包含标准的string�c�，�q�代器和��法�Q�用下面的指�C�符�Q?/p>

#include

如果你查看STL的头文�g�Q�你可以看到象iterator.h和stl_iterator.h�q�样的头文�g。由于这些名字在各种STL实现之间都可能不同，你应该避免��用这些名字来引用�q�些头文件。�ؓ了确保可�U�L��性，使用相应的没�?h后缀的文件名。表1列出了最�怋�用的各种容器�cȝ��头文件。该表�ƈ不完��_��对于其他头文�Ӟ��我将在本章和后面的两章中介绍�?/p>

�?1. STL头文件和容器�c?/p>

#include
Container Class

deque

list

map, multimap

queue, priority_queue

set, multiset

stack

vector, vector

名字�I�间
你的�~�译器可能不能识别名字空间。名字空间就好像一个信��，��标志符��装在另一个名字中。标志符只在名字�I�间中存在，因而避免了和其他标志符冲突。例如，可能有其他库和程序模块定义了sort()函数�Q��ؓ了避免和STL地sort()��法冲突�Q�STL的sort()以及其他标志�W�都��装在名字空间std中。STL的sort()��法�~�译为std::sort()�Q�从而避免了名字冲突�?/p>

��管你的�~�译器可能没有实现名字空��_��你仍然可以��用他们。�ؓ了��用STL�Q�可以将下面的指�C�符插入��C��的源代码文�g中，典型地是在所有的#include指示�W�的后面�Q?/p>

using namespace std;

�q�代�?br>�q�代器提供对一个容器中的对象的讉K��Ҏ��Q��ƈ且定义了容器中对象的范围。�P代器��如同一个指针。事实上�Q�C++的指针也是一�U��P代器。但是，�q�代器不仅仅是指针，因此你不能认��Z��们一定具有地址倹{��例如，一个数�l�烦引，也可以认为是一�U��P代器�?/p>

�q�代器有各种不同的创建方法。程序可能把�q�代器作��Z��个变量创建。一个STL容器�c�d��能�ؓ了��用一个特定类型的数据而创��Z��个�P代器。作为指针，必须能够使用*操作�W�类获取数据。你�q�可以��用其他数学操作符�?+。典型的�Q?+操作�W�用来递增�q�代器，以访问容器中的下一个对象。如果�P代器到达了容器中的最后一个元素的后面�Q�则�q�代器变成past-the-end倹{��用一个past-the-end值得指针来访问对象是非法的，��好像��用NULL或�ؓ初始化的指针一栗��?/p>

提示

STL不保证可以从另一个�P代器来抵达一个�P代器。例如，当对一个集合中的对象排序时�Q�如果你在不同的�l�构中指定了两个�q�代器，�W�二个�P代器无法从第一个�P代器抵达�Q�此时程序注定要��p�|。这是STL灉|��性的一个代仗��STL不保证检��毫无道理的错误�?/p>

�q�代器的�c�d��
对于STL数据�l�构和算法，你可以��用五�U��P代器。下面简要说明了�q�五�U�类型：

· Input iterators 提供�Ҏ��据的只读讉K��?/p>

· Output iterators 提供�Ҏ��据的只写讉K��

· Forward iterators 提供��d��操作�Q��ƈ能向前推�q��P代器�?/p>

· Bidirectional iterators提供��d��操作�Q��ƈ能向前和向后操作�?/p>

· Random access iterators提供��d��操作�Q��ƈ能在数据中随机移动�?/p>

��管各种不同的STL实现�l�节斚w��有所不同�Q�还是可以将上面的�P代器惌��Z��U�类�l�承关系。从�q�个意义上说�Q�下面的�q�代器��承自上面的�P代器。由于这�U��承关�p�，你可以将一个Forward�q�代器作��Z��个output或input�q�代器��用。同��P��如果一个算法要求是一个bidirectional �q�代器，那么只能使用该种�c�d��和随��问�P代器�?

指针�q�代�?br>正如下面的小�E�序昄��的，一个指针也是一�U��P代器。该�E�序同样昄��了STL的一个主要特性——它不只是能够用于它自己的类�c�d��Q�而且也能用于��M��C或C++�c�d��。Listing 1, iterdemo.cpp, 昄��了如何把指针作�ؓ�q�代器用于STL的find()��法来搜索普通的数组�?/p>

�?1. iterdemo.cpp

#include
#include

using namespace std;

#define SIZE 100
int iarray[SIZE];

int main()
{
iarray[20] = 50;
int* ip = find(iarray, iarray + SIZE, 50);
if (ip == iarray + SIZE)
cout << "50 not found in array" << endl;
else
cout << *ip << " found in array" << endl;
return 0;
}
在引用了I/O��库和STL��法头文�Ӟ��注意没有.h后缀�Q�，该程序告诉编译器使用std名字�I�间。��用std名字�I�间的这行是可选的�Q�因为可以删除该行对于这么一个小�E�序来说不会��D��名字冲突�?/p>

�E�序中定义了��寸为SIZE的全局数组。由于是全局变量�Q�所以运行时数组自动初始化�ؓ零。下面的语句��在索引20位置处地元素讄��?0,�q��用find()��法来搜索�?0:

iarray[20] = 50;
int* ip = find(iarray, iarray + SIZE, 50);
find()函数接受三个参数。头两个定义了搜索的范围。由于C和C++数组�{�同于指针，表达式iarray指向数组的第一个元素。而第二个参数iarray + SIZE�{�同于past-the-end ��|��也就是数�l�中最后一个元素的后面位置。第三个参数是待定位的��|��也就�?0。find()函数�q�回和前两个参数相同�c�d��的�P代器�Q�这儿是一个指向整数的指针ip�?

提示

必须��C��STL使用模板。因此，STL函数自动�Ҏ��它们使用的数据类型来构造�?/p>

��Z��判断find()是否成功�Q�例子中��试ip�?past-the-end 值是否相�{�：

if (ip == iarray + SIZE) ...
如果表达式�ؓ真，则表�C�在搜烦的范围内没有指定的倹{��否则就是指向一个合法对象的指针�Q�这时可以用下面的语句显�C�：:

cout << *ip << " found in array" << endl;
��试函数�q�回值和NULL是否相等是不正确的。不要象下面�q�样使用�Q?/p>

int* ip = find(iarray, iarray + SIZE, 50);
if (ip != NULL) ... // ??? incorrect
当��用STL函数�Ӟ��只能��试ip是否和past-the-end 值是否相�{�。尽��在本例中ip是一个C++指针,其用法也必须�W�合STL�q�代器的规则�?/p>

容器�q�代�?br>��管C++指针也是�q�代器，但用的更多的是容器�P代器。容器�P代器用法和iterdemo.cpp一��P��但和��P代器��x��为指针变量不同的是，你可以��用容器类�Ҏ��来获取�P代器对象。两个典型的容器�c�L��法是begin()和end()。它们在大多数容器中表示整个容器范围。其他一些容器还使用rbegin()和rend()�Ҏ��提供反向�q�代器，以按反向��序指定对象范围�?/p>

下面的程序创��Z��一个矢量容器（STL的和数组�{��h的对象）�Q��ƈ使用�q�代器在其中搜烦。该�E�序和前一章中的程序相同�?/p>

Listing 2. vectdemo.cpp

#include
#include
#include

using namespace std;

vector intVector(100);

void main()
{
intVector[20] = 50;
vector::iterator intIter =
    find(intVector.begin(), intVector.end(), 50);
if (intIter != intVector.end())
    cout << "Vector contains value " << *intIter << endl;
else
    cout << "Vector does not contain 50" << endl;
}

注意用下面的�Ҏ��昄��搜烦到的数据�Q?/p>

cout << "Vector contains value " << *intIter << endl;
帔R��q�代�?br>和指针一��P��你可以给一个�P代器赋倹{��例如，首先��x��一个�P代器�Q?/p>

vector::iterator first;
该语句创��Z��一个vector�cȝ��q�代器。下面的语句��该�q�代器设�|�到intVector的第一个对象，�q�将它指向的对象��D��|��ؓ123�Q?

first = intVector.begin();
*first = 123;
�q�种赋值对于大多数容器�c�都是允许的�Q�除了只��d��量。�ؓ了防止错误赋��|��可以��x��q�代器�ؓ�Q?/p>

const vector::iterator result;
result = find(intVector.begin(), intVector.end(), value);
if (result != intVector.end())
*result = 123; // ???
警告

另一�U�防止数据被改变得方法是��容器申明�ؓconst�c�d��?/p>

『呀�Q�在VC中测试出�?正确的含义是result成�ؓ帔R��而不是它指向的对象不允许改变�Q�如同int *const p;看来�q�作者自�׃��不懂�?

使用�q�代器编�E?br>你已�l�见��C��q�代器的一些例子，现在我们��关注每�U�特定的�q�代器如何��用。由于��用�P代器需要关于STL容器�c�d��法的知识，在阅��M��后面的两章后你可能需要重新复习一下本章内宏V�?/p>

输入�q�代�?br>输入�q�代器是最普通的�c�d��。输入�P代器臛_��能够使用==�?=��试是否相等�Q��?来访问数据；使用++操作来递推�q�代器到下一个元素或到达past-the-end 倹{�?/p>

��Z��理解�q�代器和STL函数是如何��用它们的�Q�现在来看一下find()模板函数的定义：

template
InputIterator find(
InputIterator first, InputIterator last, const T& value) {
while (first != last && *first != value) ++first;
return first;
}

注意

在find()��法中，注意如果first和last指向不同的容器，该算法可能陷入死循环�?/p>

输出�q�代�?br>输出�q�代器缺省只写，通常用于��数据从一个位�|�拷贝到另一个位�|�。由于输��P代器无法��d��对象�Q�因此你不会在�Q何搜索和其他��法中��用它。要惌��取一个拷贝的��|��必须使用另一个输入�P代器�Q�或它的�l�承�q�代器）�?/p>

Listing 3. outiter.cpp

#include
#include    // Need copy()
#include       // Need vector

using namespace std;

double darray[10] =
{1.0, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 1.7, 1.8, 1.9};

vector vdouble(10);

int main()
{
vector::iterator outputIterator = vdouble.begin();
copy(darray, darray + 10, outputIterator);
while (outputIterator != vdouble.end()) {
    cout << *outputIterator << endl;
    outputIterator++;
}
return 0;
}
注意

当��用copy()��法的时候，你必��ȝ��保目标容器有��_��大的�I�间�Q�或者容器本�w�是自动扩展的�?/p>

前推�q�代�?br>前推�q�代器能够读写数据��|��q�能够向前推�q�到下一个倹{��但是没法递减。replace()��法昄��了前推�P代器的��用方法�?

template
void replace (ForwardIterator first,
              ForwardIterator last,
              const T& old_value,
              const T& new_value);
使用replace()��[first,last]范围内的所有��gؓold_value的对象替换�ؓnew_value�?

replace(vdouble.begin(), vdouble.end(), 1.5, 3.14159);
双向�q�代�?br>双向�q�代器要求能够增减。如reverse()��法要求两个双向�q�代器作为参�?

template
void reverse (BidirectionalIterator first,
BidirectionalIterator last);
使用reverse()函数来对容器�q�行逆向排序:

reverse(vdouble.begin(), vdouble.end());
随机讉K��q�代�?br>随机讉K��q�代器能够以��L��序讉K��数据�Q��ƈ能用于读写数据（不是const的C++指针也是随机讉K��q�代器）。STL的排序和搜烦函数使用随机讉K��q�代器。随��问�P代器可以使用关系操作�W�作比较�?/p>

random_shuffle() 函数随机打�ؕ原先的顺序。申明�ؓ�Q?/p>

template
void random_shuffle (RandomAccessIterator first,
RandomAccessIterator last);
使用�Ҏ��Q?/p>

random_shuffle(vdouble.begin(), vdouble.end());
�q�代器技�?br>要学会��用�P代器和容器以及算法，需要学习下面的新技术�?/p>

��和�q�代�?br>本书的很多例子程序��用I/O��语句来��d��数据。例如：

int value;
cout << "Enter value: ";
cin >> value;
cout << "You entered " << value << endl;
对于�q�代器，有另一�U�方法��用流和标准函数。理解的要点是将输入/输出��作为容器看待。因此，��M��接受�q�代器参数的��法都可以和��一起工作�?

Listing 4. outstrm.cpp

#include
#include     // Need random(), srandom()
#include       // Need time()
#include    // Need sort(), copy()
#include       // Need vector

using namespace std;

void Display(vector& v, const char* s);

int main()
{
// Seed the random number generator
srandom( time(NULL) );

// Construct vector and fill with random integer values
vector collection(10);
for (int i = 0; i < 10; i++)
    collection[i] = random() % 10000;;

// Display, sort, and redisplay
Display(collection, "Before sorting");
sort(collection.begin(), collection.end());
Display(collection, "After sorting");
return 0;
}

// Display label s and contents of integer vector v
void Display(vector& v, const char* s)
{
cout << endl << s << endl;
copy(v.begin(), v.end(),
    ostream_iterator(cout, "\t"));
cout << endl;
}
函数Display()昄��了如何��用一个输出流�q�代器。下面的语句��容器中的��g��输到cout输出��对象中:

copy(v.begin(), v.end(),
ostream_iterator(cout, "\t"));
�W�三个参数实例化了ostream_iterator�c�d��Q��ƈ��它作�ؓcopy()函数的输出目标�P代器对象�?#8220;\t”字符串是作�ؓ分隔�W�。运行结果：

$ g++ outstrm.cpp
$ ./a.out
Before sorting
677 722 686 238 964 397 251 118 11 312
After sorting
11 118 238 251 312 397 677 686 722 964
�q�是STL��奇的一面『确实神奇』。�ؓ定义输出��P代器�Q�STL提供了模板类ostream_iterator。这个类的构造函数有两个参数�Q�一个ostream对象和一个string倹{��因此可以象下面一��L��单地创徏一个�P代器对象�Q?/p>

ostream_iterator(cout, "\n")
该�P代�v可以和�Q何接受一个输��P代器的函��C��起��用�?/p>

插入�q�代�?br>插入�q�代器用于将值插入到容器中。它们也叫做适配器，因�ؓ它们��容器适配或�{化�ؓ一个�P代器�Q��ƈ用于copy()�q�样的算法中。例如，一个程序定义了一个链表和一个矢量容�?

list dList;
vector dVector;
通过使用front_inserter�q�代器对象，可以只用单个copy()语句��完成将矢量中的对象插入到链表前端的操作�Q?/p>

copy(dVector.begin(), dVector.end(), front_inserter(dList));
三种插入�q�代器如下：

· 普通插入器 ��对象插入到容器��M��对象的前面�?/p>

· Front inserters ��对象插入到数据集的前面——例如，链表表头�?/p>

· Back inserters ��对象插入到集合的尾部——例如，矢量的尾部，��D��矢量容器扩展�?/p>

使用插入�q�代器可能导致容器中的其他对象移动位�|�，因而��得现存的�q�代器非法。例如，��一个对象插入到矢量容器��导致其他值移动位�|�以腑և��I�间。一般来��_��插入到象链表�q�样的结构中更�ؓ有效�Q�因为它们不会导致其他对象移动�?/p>

Listing 5. insert.cpp

#include
#include
#include

using namespace std;

int iArray[5] = { 1, 2, 3, 4, 5 };

void Display(list& v, const char* s);

int main()
{
list iList;

// Copy iArray backwards into iList
copy(iArray, iArray + 5, front_inserter(iList));
Display(iList, "Before find and copy");

// Locate value 3 in iList
list::iterator p =
find(iList.begin(), iList.end(), 3);

// Copy first two iArray values to iList ahead of p
copy(iArray, iArray + 2, inserter(iList, p));
Display(iList, "After find and copy");

return 0;
}

void Display(list& a, const char* s)
{
cout << s << endl;
copy(a.begin(), a.end(),
ostream_iterator(cout, " "));
cout << endl;
}
�q�行�l�果如下�Q?/p>

$ g++ insert.cpp
$ ./a.out
Before find and copy
5 4 3 2 1
After find and copy
5 4 1 2 3 2 1
可以��front_inserter替换为back_inserter试试�?/p>

如果用find()��L��扑֜�列表中不存在的��|��例如99。由于这时将p讄��为past-the-end 倹{��最后的copy()函数��iArray的值附加到链表的后部�?/p>

混合�q�代器函�?br>在涉及到容器和算法的操作中，�q�有两个�q�代器函数非常有用：

· advance() 按指定的数目增减�q�代器�?/p>

· distance() �q�回到达一个�P代器所需�Q�递增�Q�操作的数目�?/p>

例如�Q?/p>

list iList;
list::iterator p =
find(iList.begin(), iList.end(), 2);
cout << "before: p == " << *p << endl;
advance(p, 2); // same as p = p + 2;
cout << "after : p == " << *p << endl;

int k = 0;
distance(p, iList.end(), k);
cout << "k == " << k << endl;

advance()函数接受两个参数。第二个参数是向前推�q�的数目。对于前推�P代器�Q�该值必��Mؓ正，而对于双向�P代器和随��问�P代器�Q�该值可以�ؓ负�?/p>

使用 distance()函数来返回到辑֏�一个�P代器所需要的步骤�?br>注意

distance()函数是�P代的�Q�也��是��_��它递增�W�三个参数。因此，你必��d��始化该参数。未初始化该参数几乎注定要失败�?/p>

函数和函数对�?br>STL中，函数被称为算法，也就是说它们和标准C库函数相比，它们更�ؓ通用。STL��法通过重蝲operator()函数实现为模板类或模板函数。这些类用于创徏函数对象�Q�对容器中的数据�q�行各种各样的操作。下面的几节解释如何使用函数和函数对象�?/p>

函数和断�a�
�l�常需要对容器中的数据�q�行用户自定义的操作。例如，你可能希望遍历一个容器中所有对象的STL��法能够回调自己的函数。例�?/p>

#include
#include      // Need random(), srandom()
#include        // Need time()
#include        // Need vector
#include     // Need for_each()

#define VSIZE 24        // Size of vector
vector v(VSIZE); // Vector object

// Function prototypes
void initialize(long &ri);
void show(const long &ri);
bool isMinus(const long &ri); // Predicate function

int main()
{
srandom( time(NULL) ); // Seed random generator

for_each(v.begin(), v.end(), initialize);//调用普通函�?br> cout << "Vector of signed long integers" << endl;
for_each(v.begin(), v.end(), show);
cout << endl;

// Use predicate function to count negative values
//
int count = 0;
vector::iterator p;
p = find_if(v.begin(), v.end(), isMinus);//调用断言函数
while (p != v.end()) {
    count++;
    p = find_if(p + 1, v.end(), isMinus);
}
cout << "Number of values: " << VSIZE << endl;
cout << "Negative values : " << count << endl;

return 0;
}

// Set ri to a signed integer value
void initialize(long &ri)
{
ri = ( random() - (RAND_MAX / 2) );
// ri = random();
}

// Display value of ri
void show(const long &ri)
{
cout << ri << " ";
}

// Returns true if ri is less than 0
bool isMinus(const long &ri)
{
return (ri < 0);
}

所谓断�a�函数�Q�就是返回bool值的函数�?/p>

函数对象
除了�l�STL��法传递一个回调函敎ͼ�你还可能需要传递一个类对象以便执行更复杂的操作。这��L��一个对象就叫做函数对象。实际上函数对象��是一个类�Q�但它和回调函数一样可以被回调。例如，在函数对象每�ơ被for_each()或find_if()函数调用时可以保留统计信息。函数对象是通过重蝲operator()()实现的。如果TanyClass定义了opeator()(),那么��可以这么��用：

TAnyClass object; // Construct object
object(); // Calls TAnyClass::operator()() function
for_each(v.begin(), v.end(), object);
STL定义了几个函数对象。由于它们是模板�Q�所以能够用于�Q何类型，包括C/C++固有的数据类型，如long。有些函数对象从名字中就可以看出它的用途，如plus()和multiplies()。类似的greater()和less-equal()用于比较两个倹{�?

注意

有些版本的ANSI C++定义了times()函数对象�Q�而GNU C++把它命名为multiplies()。��用时必须包含头文�?lt;functional>�?/p>

一个有用的函数对象的应用是accumulate() ��法。该函数计算容器中所有值的��d��。记住这��L��g��一定是��单的�c�d��Q�通过重蝲operator+()�Q�也可以是类对象�?/p>

Listing 8. accum.cpp

#include
#include       // Need accumulate()
#include        // Need vector
#include    // Need multiplies() (or times())

#define MAX 10
vector v(MAX);    // Vector object

int main()
{
// Fill vector using conventional loop
//
for (int i = 0; i < MAX; i++)
    v[i] = i + 1;

// Accumulate the sum of contained values
//
long sum =
    accumulate(v.begin(), v.end(), 0);
cout << "Sum of values == " << sum << endl;

// Accumulate the product of contained values
//
long product =
    accumulate(v.begin(), v.end(), 1, multiplies());//注意�q�行
cout << "Product of values == " << product << endl;

return 0;
}
�~�译输出如下�Q?/p>

$ g++ accum.cpp
$ ./a.out
Sum of values == 55
Product of values == 3628800
『注意��用了函数对象的accumulate()的用法。accumulate() 在内部将每个容器中的对象和第三个参数作�ؓmultiplies函数对象的参�?multiplies(1,v)计算乘积。VC中的�q�些模板的源代码如下�Q?/p>

// TEMPLATE FUNCTION accumulate

template inline

_Ty accumulate(_II _F, _II _L, _Ty _V)

{for (; _F != _L; ++_F)

_V = _V + *_F;

return (_V); }

// TEMPLATE FUNCTION accumulate WITH BINOP

template inline

_Ty accumulate(_II _F, _II _L, _Ty _V, _Bop _B)

{for (; _F != _L; ++_F)

_V = _B(_V, *_F);

return (_V); }

// TEMPLATE STRUCT binary_function

template

struct binary_function {

typedef _A1 first_argument_type;

typedef _A2 second_argument_type;

typedef _R result_type;

};

// TEMPLATE STRUCT multiplies

template

struct multiplies : binary_function<_Ty, _Ty, _Ty> {

_Ty operator()(const _Ty& _X, const _Ty& _Y) const

{return (_X * _Y); }

};

引言�Q�如果你��x��入了解STL到底是怎么实现的，最好的办法是写个简单的�E�序�Q�将�E�序中涉及到的模板源码给copy下来�Q�稍作整理，��p��看懂了。所以没有必要去��C��么《STL源码剖析》之�cȝ��书籍�Q�那些书可能反而浪�Ҏ��间。�?/p>

发生器函数对�?br>有一�c�L��用的函数对象�?#8220;发生�?#8221;(generator)。这�c�d��数有自己的内存，也就是说它能够从先前的调用中��C��一个倹{��例如随机数发生器函数�?/p>

普通的C�E�序员��用静态或全局变量 “记忆”上次调用的结果。但�q�样做的�~�点是该函数无法和它的数据相分离『还有个�~�点是要用TLS才能�U�程安全』。显�Ӟ��使用�c�L��装一块：“内存”更安全可靠。先看一下例子：

Listing 9. randfunc.cpp

#include
#include     // Need random(), srandom()
#include       // Need time()
#include    // Need random_shuffle()
#include       // Need vector
#include // Need ptr_fun()

using namespace std;

// Data to randomize
int iarray[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
vector v(iarray, iarray + 10);

// Function prototypes
void Display(vector& vr, const char *s);
unsigned int RandInt(const unsigned int n);

int main()
{
srandom( time(NULL) ); // Seed random generator
Display(v, "Before shuffle:");

pointer_to_unary_function
    ptr_RandInt = ptr_fun(RandInt); // Pointer to RandInt()//注意�q�行
random_shuffle(v.begin(), v.end(), ptr_RandInt);

Display(v, "After shuffle:");
return 0;
}

// Display contents of vector vr
void Display(vector& vr, const char *s)
{
cout << endl << s << endl;
copy(vr.begin(), vr.end(), ostream_iterator(cout, " "));
cout << endl;
}

// Return next random value in sequence modulo n
unsigned int RandInt(const unsigned int n)
{
return random() % n;
}
�~�译�q�行�l�果如下�Q?/p>

$ g++ randfunc.cpp
$ ./a.out
Before shuffle:
1 2 3 4 5 6 7 8 9 10
After shuffle:
6 7 2 8 3 5 10 1 9 4
首先用下面的语句��x��一个对象：

pointer_to_unary_function
ptr_RandInt = ptr_fun(RandInt);
�q�儿使用STL的单目函数模板定义了一个变量ptr_RandInt�Q��ƈ��地址初始化到我们的函数RandInt()。单目函数接受一个参敎ͼ��q�返回一个倹{��现在random_shuffle()可以如下调用�Q?/p>

random_shuffle(v.begin(), v.end(), ptr_RandInt);
在本例子中，发生器只是简单的调用rand()函数�?br>
关于帔R��引用的一点小�ȝ��Q�不��译了，VC下将例子中的const��L��Q?

发生器函数类对象
下面的例子说明发生器函数�c�d��象的使用�?/p>

Listing 10. fiborand.cpp

#include
#include    // Need random_shuffle()
#include       // Need vector
#include // Need unary_function

using namespace std;

// Data to randomize
int iarray[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
vector v(iarray, iarray + 10);

// Function prototype
void Display(vector& vr, const char *s);

// The FiboRand template function-object class
template
class FiboRand : public unary_function {
int i, j;
Arg sequence[18];
public:
FiboRand();
Arg operator()(const Arg& arg);
};

void main()
{
FiboRand fibogen; // Construct generator object
cout << "Fibonacci random number generator" << endl;
cout << "using random_shuffle and a function object" << endl;
Display(v, "Before shuffle:");
random_shuffle(v.begin(), v.end(), fibogen);
Display(v, "After shuffle:");
}

// Display contents of vector vr
void Display(vector& vr, const char *s)
{
cout << endl << s << endl;
copy(vr.begin(), vr.end(),
    ostream_iterator(cout, " "));
cout << endl;
}

// FiboRand class constructor
template
FiboRand::FiboRand()
{
sequence[17] = 1;
sequence[16] = 2;
for (int n = 15; n > 0; n�?
    sequence[n] = sequence[n + 1] + sequence[n + 2];
i = 17;
j = 5;
}

// FiboRand class function operator
template
Arg FiboRand::operator()(const Arg& arg)
{
Arg k = sequence[i] + sequence[j];
sequence[i] = k;
i--;
j--;
if (i == 0) i = 17;
if (j == 0) j = 17;
return k % arg;
}
�~�译�q�行输出如下:

$ g++ fiborand.cpp
$ ./a.out
Fibonacci random number generator
using random_shuffle and a function object
Before shuffle:
1 2 3 4 5 6 7 8 9 10
After shuffle:
6 8 5 4 3 7 10 1 9
该程序用完全不通的�Ҏ��使用使用rand_shuffle。Fibonacci 发生器封装在一个类中，该类能从先前�?#8220;使用”中记忆运行结果。在本例中，�c�FiboRand �l�护了一个数�l�和两个索引变量I和j�?/p>

FiboRand�cȝ��承自unary_function() 模板:

template
class FiboRand : public unary_function {...
Arg是用戯��定义数据�c�d��。该�c�还定以了两个成员函敎ͼ�一个是构造函敎ͼ�另一个是operator()�Q�）函数�Q�该操作�W�允许random_shuffle()��法象一个函��C��?#8220;调用”一个FiboRand对象�?

�l�定器函数对�?br>一个绑定器使用另一个函数对象f()和参数值V创徏一个函数对象。被�l�定函数对象必须为双目函敎ͼ�也就是说有两个参�?A和B。STL 中的帮定器有�Q?/p>

· bind1st() 创徏一个函数对象，该函数对象将值V作�ؓ�W�一个参数A�?/p>

· bind2nd()创徏一个函数对象，该函数对象将值V作�ؓ�W�二个参数B�?/p>

举例如下�Q?/p>

Listing 11. binder.cpp

#include
#include
#include
#include

using namespace std;

// Data
int iarray[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
list aList(iarray, iarray + 10);

int main()
{
int k = 0;
count_if(aList.begin(), aList.end(),
bind1st(greater(), 8), k);
cout << "Number elements < 8 == " << k << endl;
return 0;
}
Algorithm count_if()计算满��特定条�g的元素的数目�?�q�是通过��一个函数对象和一个参数捆�l�到��Z��个对象，�q�将该对象作为算法的�W�三个参数实现的�?注意�q�个表达�?

bind1st(greater(), 8)
该表辑ּ��greater()和一个参数�?捆绑��Z��个函数对象。由于��用了bind1st()�Q�所以该函数相当于计��下�q�表辑ּ��Q?

8 > q
表达式中的q是容器中的对象。因此，完整的表辑ּ�

count_if(aList.begin(), aList.end(),
bind1st(greater(), 8), k);
计算所有小于或�{�于8的对象的数目�?

否定函数对象
所谓否�?negator)函数对象�Q�就是它从另一个函数对象创��来�Q�如果原先的函数�q�回真，则否定函数对象返回假。有两个否定函数对象�Q�not1()和not2()。not1()接受单目函数对象�Q�not2()接受双目函数对象。否定函数对象通常和帮定器一起��用。例如，上节中用bind1nd来搜索q<=8的��|��

count_if(aList.begin(), aList.end(),
bind1st(greater(), 8), k);
如果要搜索q>8的对象，则用bind2st。而现在可以这样写�Q?/p>

start = find_if(aList.begin(), aList.end(),
not1(bind1nd(greater(), 6)));
你必��M��用not1�Q�因为bind1nd�q�回单目函数�?

�ȝ��Q��用标准模板库 (STL)
��管很多�E�序员仍然在使用标准C函数�Q�但是这��好像骑着毛驴��L��Mercedes一栗��你当然最�l�也会到辄��标，但是你浪费了很多旉��?/p>

��管有时候��用标准C函数��实方便(如��用sprintf()�q�行格式化输�?。但是C函数不��用异常机制来报告错误�Q�也不适合处理新的数据�c�d��。而且标准C函数�l�常使用内存分配技术，没有�l�验的程序员很容易写出bug来�?

C++标准库则提供了更为安全，更�ؓ灉|��的数据集处理方式。STL最初由HP实验室的Alexander Stepanov和Meng Lee开发。最�q�，C++标准委员会采�U�了STL�Q�尽��在不同的实��C��间仍有细节差别�?/p>

STL的最主要的两个特点：数据�l�构和算法的分离�Q�非面向对象本质。访问对象是通过象指针一��L��q�代器实现的�Q�容器是象链表，矢量之类的数据结构，�q�按模板方式提供�Q�算法是函数模板�Q�用于操作容器中的数据。由于STL以模板�ؓ基础�Q�所以能用于��M��数据�c�d��和结构�?/p>

oliver 2010-10-24 14:11 发表评论

oliver — Fri, 22 Oct 2010 13:02:00 GMT

1.C++注释妙用�Q?br>从前曄��看过一�U�代码开�?/p>

//*�Q�最前面�?是开养I��L��后下面这�D�代码就被注释了�Q�）

codeSegement1;

//*/

后来�Q�在我的实践中，我又发现了可以在两段代码间切换的�Ҏ��Q?/p>

//*�Q�最前面�?是开养I��L��后第1�D�被注释�Q�第2�D�|��效）

codeSegement1;

/*/

codeSegement2;

//*/

2.NULL定义
#ifndef NULL
#ifdef __cplusplus
#define NULL    0
#else
#define NULL    ((void *)0)
#endif
#endif

3. 标准头文件中都有如下�l�构�Q�比如stdio.h文�g�Q�：
#ifndef _INC_STDIO
#define _INC_STDIO
#ifdef __cplusplus
extern "C" {
#endif
/*...
.....
*/
#ifdef __cplusplus
}
#endif
#endif /* _INC_STDIO*/

oliver 2010-10-22 21:02 发表评论