C++数据类型

一、       文字常量

1、  文字常量：称之为“文字”，是因为我们只能以它的值的形式指代它，称之为“常量”，是因为它的值不能够改变。每个文字都有相应的类型。文字常量是不可寻址的，尽管它的值也存储在机器内存的某个地方，但是我们没有办法访问它们的地址。

2、  字符型char，通常用来表示单个字符和小整数，它可以用一个机器字节来表示。整型int、短整型short、长整型long，它们分别代表不同长度的整数值。浮点型float、双精度double和长双精度long double。

3、  整值类型（int、char、short、long）可以有符号也可以无符号。最左边符号位为1代表负数，为0代表正数，一个8位有符号的char可以代表从-128到127的数值，无符号的则表示从0到255范围内的数值。

4、  在缺省条件下，整型文字常量常被当作是一个int类型的有符号值。我们可以在文字常量后加一个L,将其指定为long类型。加U指定为无符号的数，浮点型文字常量在缺省条件下被认为是double类型，单精度后加F,注意F、L后缀只能用在十进制形式中。单词true和false是bool类型的文字常量。可打印的文字常量可以写成用单引号括起来的形式，例如’2’、’a’、’ ’等。一部分不可打印的字符、单引号、双引号、反斜杠可以用如下的转义序列（以\开头）表示：

换行符：\n   水平制表键：\t    垂直制表键：\v  退格键：\b  回车键：\r  进纸键：\f  响铃符：\a  反斜杠键：\\  问号：\?  单引号：\’  双引号：\”

5、  字符文字前面可以加“L”，称为宽字符文字，类型为wchar-t.宽字符常量用来支持某些语言的字符集合，如汉语、日语，这些语言中某些字符不能一个单个字符表示。

6、  字符串常量由0个或多个用双引号括起来的字符组成，如需换行则在一行的最后加上\，表明字符串文字在下一行继续。字符串文字的类型是常量字符数组，它由字符串文字本身以及编译器加上的表示结束的空（null）字符构成，例如：

‘A’:表单个字符‘A’

“A”：表单个字符A后跟一个空字符

空字符是C和C++用来标记字符串结束的符号.

7、  存在宽字符文字，也存在宽字符串文字，也以L开头，类型为常量宽字符的数组。有一个宽空字符做为结束标志。

8、  如果有两个字符串或宽字符串在程序中相邻，C++就会把他们连接到一起，最后并加一个空字符，例如：

“two”“some”它的输出结果是“twosome”.

二、       变量

1、 变量为我们提供了一个有名字的内存存储区，可以通过程序对其进行读、写和处理。变量是可寻址的，对于每一个变量都有两个值与其相关联：

数据值：存储在某个内存地址中。也被称为变量的右值，可以认为是被读取的值，文字常量和变量都可以被用做右值。

地址值：存储数据值的那块地址。也被称为变量的左值，文字常量不能被用做左值。

2、 变量的声明：由关键字+变量类型+变量名字构成。声明不是定义，不会引起内存分配。

3、 变量名：由字母、数字、以及下划线组成，不能以数字开头。关键字标识符不能作为程序的标识符使用。

4、 对象（变量）的定义：一个简单的对象定义由一个类型指示符+一个名字，以分号结束，当同类型的多个标识符被定义时，中间用逗号隔开，最后以分号结束，可以跨行。如果变量在全局中定义，都会被初始化为0，如果变量是在局部域内定义，或是通过new表达式分配的，则系统不会向它提供初始值0，这些对象是未初始化的。未初始化的对象不是没有值，而是它的值是未定义的。因为使用未初始化的对象是个常见错误而且很难发现，所以一般建议为所定义的对象提供一个初始值。

类机制通过所谓的缺省构造函数提供了类对象的自动初始化。例如：

Int main (){

//未初始化的局部对象

Int ival;

       //通过string的缺省构造函数进行初始化

String project;

}

5、 C++支持2种形式的初始化，int ival=1024；int ival（1024）；

string project=“hello”；string project （“hello“）；对象可以用任意复杂的表达式来初始化，包括函数的返回值。

三、            指针类型

1、 每个指针都有一个相关的类型，不同数据类型的指针之间的区别不是在指针的表示上，也不在指针所持有的值（地址）上，对所有类型的指针这两方面的指针都是相同的，不同在于指针所指的对象类型上。指针的类型可以指示编译器怎样解释特定地址上内存的内容，以及该内存区域应该跨越多少内存单元。

2、 通过在标识符前加一个解引用操作符*来定义指针，在标识符列表中，每个指针前面都必须加上此操作符。

3、 当指针持有值为0时，表明它没有指向任何对象，或持有一个同类型的数据对象的地址。例如：

Int ival =1024；

Int*pi=0；

Int *pi2=&ival;        //pi2被初始化为ival的地址

Pi=pi2;              //pi和pi2都指向ival

Pi2=0;              //现在pi2没有指向任何对象

Pi=ival;             //错误：指针不能持有非地址值

指针不能被初始化或赋值为其他类型对象的地址值。例如：

Double dval;

Double *pd=&dval;

以下两句都会引起编译时刻错误：

Pi=pd;            

Pi=&dval;

不是说pi在物理上不能持有与dval先关联的地址：它能够，但是不允许。因为虽然pi和pd能够持有相同的地址值，但对那块内存的存储布局和内容解释完全不同。

C++提供一种特殊的指针类型来支持这种需求：空类型指针（*void），他可以被任何数据指针类型的地址值赋值（函数指针不能赋值给他）。

Void *pv=pi;

Pv=pd;

Void*标明相关的值是个地址，但该地址的对象类型不知道，我们不能够操作空类型指针所指向的对象，只能传送该地址值或将它与其他地址值相比较.

4、指针的算术运算：指针可以让她的地址值增加或减少一个整数值。指针加2意味着给指针持有的地址增加了该类型两个对象的长度。例如，假设一个char是一个字节，一个int是四个字节，double是8个字节，那么指针加2就是给持有的地址值增加2、8、16，完全取决于指针的类型。实际上，只有指针指向数组元素时，我们才能保证较好的运用指针的算术运算，在前面的例子中，我们不能保证3个整数变量连续存储在内存中。因此ip+2可能，也可能不产生一个有效地址，这取决于该位置上实际储存的是什么。

四、字符串类型

       1、C风格字符串：起源于C语言，并在C++中得到支持。字符串被存储在一个字符数组中，一般通过一个char*类型的指针来操纵它。标准c为操纵C风格的字符串提供了一组函数。Int stringlen(const char*)       //返回字符串的长度

                     Int stringcmp (constchar*,const char*)  //比较2个字符串是否相等

         Char*strcpy (char*,const char*)        //把第二个字符串拷贝到第一个字符串中

       为使用这些函数，我们必须包含相关的头文件，#include <cstring>

      2、字符串类型：标准C++提供了支持这些操作的string类，要使用此类，必须先包含相关的头文件：#include<string>

               String st(“hello word\n”)  //st的长度由size()操作返回，不包含终止空字符

3、string构造函数的第二种形式是定义一个空字符串。例如：string st2;

有2种方法测试它是否为空，第一，测试size（）是否为0：if （!st.size（））

第二，if（st.empty()）如果字符串不含字符，返回布尔常量true，否则返回false。

4、 第三种形式，用一个string对象来初始化另一个string对象。例如：string st3(st);

如何让验证呢，就相当于比较两个字符串是否一样，如果相等则返回true。

If （st=st3）;

5、 拷贝一个字符串，最简单的方法是赋值操作符，例如：st2=st3;//把st3 拷贝到st2中，首先将与st2相关联的字符存储区释放掉，然后再分配足够存储与st3相关联的字符存储区，最后将与st3相关联的字符拷贝到该存储区。

6、 将2个字符连接起来形成第三个字符：给出两个字符string s1(“hello,”);

string s2(“world\n”);

string s3=s1+s2;

直接将s2附加在s1后面：s1+=s2;

S1和s2的初始化包含一个空格、一个逗号、一个换行，他们的存在限制了对这些string对象的重用，一种比较好的方法就是混合使用C风格的字符串与string对象，如下所示：const char *pc=”,”;

  string s1(“hello”);

string s2(“world”);

string s3=s1+pc+s2+”\n”;

这种方法能够生效是由于string类型能自动将C风格的字符串转换成string对象,例如，可以将一个C风格的字符串赋给一个string对象：

         String s1;

         Const char *pc=”hello”;

         S1=pc;

但反向的转换不能自动执行。为了实现这种转换，必须显式调用名为c-str()的操作：

Const  char *str=s1.c-str();

7、 string类型支持通过下标操作符访问单个字符。例如在下列代码中，字符串中所有句号被下划线替代。

String str (“nidhu.ndihsi.ds”);

Int size =str.size();

For (int ix=0;ix<size;++ix);

   If (str[ix]==’.’)

   Str[ix]=’_’;

五、   const 限定修饰符

1、 const定义一个对象为常量，定义后就不能被修改，它是只读的，所以它必须被初始化。未初始化的常量定义将导致编译错误，一旦一个常量被定义了，我们就不能改变与const对象相关联的值。

2、 一个非const对象的指针指向一个常量对象，会引起编译错误。但我们能间接的指向一个const对象，只需声明一个指向常量的指针来做这件事。例如：

Const double *cptr;

Cptr是一个指向double类型的、被定义成const的对象的指针。此中微妙在于cptr本身不是常量。我们可以重新赋值cptr，使其指向不同的对象，但不能修改cptr指向的对象。例如：

Const double *pc=0;

Const doubleminwage=9.60;

//不能通过pc修改minwage

Pc=&minwage;     //const对象的地址只能赋值给指向const对象的指针

//不能通过pc修改dval，虽然dval本身不是一个常量

Pc=&dval；       //指向const对象的指针可以被赋值以一个非const对象的地址

Dval=3.14159；

*pc=3.14159;    //错误，虽然dval不是常量，但试图通过pc修改它的值，仍会导致编译错误（因为在运行程序的任一点上，编译器不能确定指针所指的实际对象）

     3、在实际的程序中，指向const的指针常被用作函数的形式参数。它作为一个约定来保证：被传递给函数的实际对象在函数中不会被修改。例如：

        Int strcmp(const char *str1,const char*str2);

        我们可以定义一个const指针指向一个const或一个非const对象，例如：

        Int errnumb =0;

        Int *const curerr=&errnumb;

        Curerr 是一个指向非const对象的const指针（curerr是一个指向int类型对象的const指针），这意味着不能赋给curerr其他的地址值，但可以修改curerr指向的值。

        指向const对象的const指针的定义就是将前面两种定义结合起来。例如：

        Const double pi=3.14159;

        Const double *const pi_ptr =&pi;

        在这种情况下，pi_ptr所指向的对象以及它的地址本身都不能被改变。

六、   引用类型

1、 通过引用我们可以间接地操纵对象，使用方式类似于指针，但是不需要指针的语法。在实际的程序中，引用主要被用作函数的形式参数——通常是将类对象传递给一个函数。

2、 引用类型由类型标识符和一个取地址操作符来定义，引用必须初始化。例如：

Int ival=1024；

Int&refval=ival;     //refval是一个指向ival的引用

Int &refval2；      //错误，引用必须被初始化为指向一个对象

3、 虽然引用也被作为一种指针，但是如同指针的情形那样，用一个对象的地址来初始化引用是错误的。我们可以定义一个指针引用，例如：

Int ival=1024；

Int &refval=&ival；  //错误：refval是int类型，不是int*

Int *pi=&ival;

Int &refval=pi;       //正确，reval是一个指向指针的引用

4、 一旦引用被定义，它就不能再指向其他的对象。引用的所有操作实际上都是应用在他所指的对象上，包括取地址操作符。例如：

Refval+=2；     //将refval指向的对象ival加2.

5、 每个引用的定义都必须以取地址操作符开始。定义一个引用：int &rval=ival;

6、 Const引用可以用不同类型的对象初始化（只要能从一种类型转换到另一种类型即可），也可以是不可寻址的，如文字常量。例如：

Double dval=3.14159；

Const int &ir=1024；

Const int &int2=dval；

Const double &dr=dval +1.0;注意：同样的初始化对非const引用是不合法的

用一个const引用来初始化一个引用：

Const int ival=1024；

Const int *const&pi_ref=&ival;

7、 指针和引用有两个区别：引用必须指向一个对象，如果用一个引用给另一个引用赋值，那么改变的是被引用的对象，而不是引用本身。

8、 实际的C++程序很少使用指向独立对象的引用类型。引用类型主要被用作函数的形式参数，例如：

Bool get_next_value(int &next_value);  //返回访问状态，将值放入参数

Matrix operator +(constmatrix&,const matrix&);  //重载加法操作符

七、         布尔类型

1、 布尔对象可以被赋予文字值true或false。但是当表达式需要一个算数值时，布尔对象和布尔文字都被隐式的提升成int：false变为0，true变为1.例如：

Bool found =false；

Int occurrence_count=0;

While (条件省去)

{found=look_for(省去)

Occurrence_count+=found;  // found的值被提升为0或1

}

2、 算数值和指针值也能隐式的被转换成布尔类型的值。0或空指针被转换成false，其他所有的值被转换成true。

八、   枚举类型

1、 枚举类型用关键字enum，加上一个自选的枚举类型名来定义，类型名后面跟一个用花括号括起来的枚举成员列表，枚举成员之间用都好分开。在缺省条件下，第一个枚举成员被赋值0，后面的成员依次比前面的大1.

2、 我们可以定义枚举类型的对象，它可以参与表达式运算，也可以被作为参数传递给函数。枚举类型的对象能够被初始化，但是只是被一个相同枚举类型的对象或枚举成员集中的某个值初始化或赋值。例如：

Enum points{point2d=2,point2w,point3d=3,point3w};

虽然3是与points相关联的合法值，但是它不能显式的赋给points类型的对象：

Void number(){

Points pt3d=point3d;       //pt3d=3

Points pt2w=3;            //错误：pt2w被初始化一个int整数

Pt2w=polygon;            //错误：polygon不是points的枚举成员

Pt2w=pt3d;              // 可以，因为他们都是points枚举类型

}

但是，在必要时，枚举类型会自动被提升为算数类型。例如：

Const  int array_size=1024;

Intchunk_size=array_size*pt2w;   //pt2w被提升为int类型 

九、   数组类型

1、 数组是一个单一数据类型对象的集合，每个对象并没有被命名，我们可以通过它在数组中的位置访问ta，这种访问形式被称为索引访问或下标访问。

2、 数组定义由类型名、标识符和维数组成。维数必须是常量表达式---即在编译时刻计算出它的值，非const的变量不能用来指定数组的维数。

3、 数组可以被显式的用一组数来初始化，这组数用逗号分开，放在大括号中。例如：const int array_size=3;

Int ia [array_size]={0,1,2};

4、 被显式初始化的数组不需要指定维数值，编译器会根据列出来的元素的个数来确定数组的维数：int ia[]={0,1,2};

5、 如果指定了维数，那么初始化列表的元素个数不能超过这个值。如果指定的维数大于给出的元素的个数，那么没有被显式初始化的元素将被置0.

6、 字符数组初始化有两种形式，但他们不是等价的：

Const char c1[]={‘c’,’+’,’+’};    //维数为3

Const char c2[]=”c++”;        //维数为4

7、 一个数组不能被另外一个数组初始化，也不能赋值给另外一个数组，而且c++不允许声明一个引用数组（即由引用组成的数组）：

Const int array_size=3;

Int ix,jx,kx;

Int*iap[]={&ix,&jx,&kx};      //可以：类型为int*的指针的数组

Int &iar[]={ix,jx,kx};          //错误：不允许引用数组

Int ia2[]=ia;                //错误：不能用一个数组来初始化一个数组

Int main()

{

int ia3 [array_size];

Ia3=ia;                //错误：不能把一个数组赋值给另一个数组

Return 0

}

8、 要把一个数组拷贝到另一个数组中去，必须按顺序拷贝每个元素，例如;

Const int array_size=7;

Intia1[]={0,1,2,3,4,5,6};

Int main ()

{

Int ia2[array_size];

For (int ix=0;ix<array_size;++ix)

   Ia2[ix]=ia1[ix];

Return 0;

}

9、 任意结果为整数值得表达式都可以用来索引数组。例如：

Int someval，get_index();

Ia2[get_index()]=someval;

C++没有提供编译时刻或运行时刻对数组下标的检查，除了程序员自己检查和测试外，没有别的办法可以防止数组越界。

10、   多维数组：int ia [4][3];第一维被称为行维，第二维称为列维，ia是一个二维数组，4行3列，多维数组也可以被初始化：

Int ia [4][3]={

 {0,1,2},

{3,4,5},

{6,7,8},

{9,10,11}

};用来表示行的花括号是可选的，下面的初始化与前面的初始化是一样的，只是有点不清楚：int ia[4][3]={0,1,2,3,4,5,6,7,8,9,10,11};

int ia[4][3]={{0},{3},{6},{9}};   //初始化了每行的第一个元素，其余元素为0

   Int ia [4][3]={0,3,6,9};    //初始化了第一行的3个元素和第二行的第一个元素

11、   虽然表达式ia[1,2]是合法的，但它等价于ia[2],程序员希望的可能是ia【1】【2】，但在c++中，多维数组的索引访问要求每个索引都有一对方括号。

12、   数组标识符代表数组中第一个元素的地址，它的类型是数组元素类型的指针。已知下面的数组定义：int ia[]={0,1,2,3,4,5,6,7,8,};

返回数组的第一个元素的地址：ia;或&ia[0];

访问相应的值：*ia;或ia[0]; //两者都得到第一个元素的值

用下标操作符来访问第二个元素的地址：&ia[1];或ia+1;

*ia+1:解引用ia将返回数组的第一个元素的值，然后对其加1

*（ia+1）：ia先加1然后解引用新的地址值。对ia加1将指向数组的下一个元素

       13、数组元素的遍历;可以通过下标操作符来实现，也可以通过直接操作指针来实现数组元素的遍历。例如：

           #include <iostream>

           Int main ()

{    int ia[9]={0,1,2,3,4,5,6,7,8};

                Int *pbegin=ia;   //pbegin被初始化指向数组的第一个元素

                Int *pend=ia+9;  //pend被初始化指向数组的最后一个元素

 

While (pbegin!=pend){

Cout<<P*begin<<’’;

++pbegin;

}}如果把这一对指向数组头和最末元素下一位置的指针，抽取到一个独立的函数，就有了一个能够迭代整个数组的工具，却无需知道数组的实际大小（当然调用函数的程序员必须知道）。例如：

#include <iostream>

Void ia_print(int*pbegin,int*pend)

{    while(pbegin!=pend)  {

          Cout<<*pbegin<<’’;

          ++pbegin;

}}

Int main()

{    int ia [9]={0,1,2,3,4,5,6,7,8,};

     Ia_print(ia,ia+9);

}

当然这是有限制的，它只指向整型数组的指针。我们可以吧ia_print()转换成模板函数来消除此限制。例如：

#include <iostream>

Template<class elemtype>

Void ia_print (elemtype *pbegin, elemtype*pend)

{    while(pbegin!=pend)  {

          Cout<<*pbegin<<’’;

          ++pbegin;

}}

现在我们可以给通用的函数print（）传递一对指向任意数组的指针，只要该类型的输出操作符已经被定义即可，例如：

Int main ()

{ int ia [9]={0,1,1,3,4,5,6,7,8};

 Double da[4]={3.14,6.28,12.34,25.12};

String sa[3]={“hello”,”you”,”me”};

Print(ia,ia+9);

Print(da,da+4);

Print(sa,sa+3);

这种程序设计形式被称为泛型程序设计，标准库提供了一组泛型算法，他们通过一对标记元素的开始/结束指针来遍历其中的元素。

十、         vector容器类型

1、 vector类为内置数组提供一种替代表示，与string类一样，vector类是标准c++引入的标准库的一部分，为了使用vector，我们必须包含相关的头文件。#include<vector>

2、 使用c++有两种不同的形式：数组习惯和STL（标准模板库）习惯。在数组习惯用法中，我们模仿内置数组的用法，定义一个已知长度的vector：vector<int>ivec(10);与访问内置数组的方式一样，我们可以用下标操作符访问vector的元素，用size（）查询vector大小，用empty（）测试它是否为空。

3、 Vector的元素被初始化为与其类型相关的缺省值，算术和指针类型的缺省值为0，对于class类型，缺省值可通过调用该类的缺省构造函数获得，我们还可以为每个元素提供一个显式的初始值来完成初始化。例如：vector <int>ivec(10,-1);定义了ivec，包含10个int类型的元素，每个元素都被初始化为-1 。不能用显式的方法把vector的元素初始化一组常量值，但可以将vector初始化为一个已有数组的全部或一部分，只需指定用来初始化vector的数组的开始地址以及数组最末元素的下一位置来实现。例如：

Int ia[6]={1,2,3,4,5,6};

Vector <int>ivec(ia,ia+6);   //把ia中的6个元素拷贝到ivec中

Vector <int>ivec(&ia[2],&ia[5]); //拷贝3个元素：ia[2],ia[3],ia[4]

注意：被传递给ivec的2个指针标记了用来初始化对象的值得范围，第二个指针总是指向要拷贝的末元素的下一位置。

4、 与内置数组不同，vector可以被另一个数组初始化，或被赋值给另一个vector。例如：vector<string>svec;

     Void init_and_assign()

{     vector<string>user_names(svec);  //用一个vector初始化另一个vector

      Svec=user_names;            //把一个vector拷贝给另一个vector

}

5、 在STL中对vector的习惯用法完全不同，我们不是定义一个已知大小的vector，而是定义一个空vector：vector<string>text;

我们向vector中插入元素，而不再是索引元素，以及向元素赋值。例如，push_back()就是在vector的后面插入一个元素。下面的while循环从标准输入读入一个字符串序列，并每次将一个字符串插入到vector中：

String word；

While （cin）>>word）{

Text.push_back(word);

]

我们仍然可以用下标操作符来迭代访问元素:

Cout<<”words readare:\n”;

For(int ix=0;ix<text.size();++ix)

Cout<<text[ix]<<’’<<endl;

          但是更经典的做法是使用vector操作集中的begin（）和end()所返回的迭代器（iterator）对：

Cout<<”words readare:\n”;

For(vector<string>::iteratorit =text.begin();it!=text.end();++it)

Cout<<*it<<’’<<endl;

6、 itrater是标准库中的类，它具有指针功能。*it：对迭代器解引用，并访问其指向的实际对象。++it：向前移动迭代器it，使其指向下一个元素。

十一、复数类型

1、 复数类是标准库的一部分，为了能够使用它，我们必须包含其相关的头文件：#include<complex>复数对象的定义一般可以使用如下的形式：

Complex<double>purei(0,7);//纯虚数：0+7i

Complex<float>real_num(3);//虚数部分缺省为0:3+0i

Complex<longdouble>zero; // 实部和虚部均缺省为0

Complex<double>purei2(purei);//用一个复数对象来初始化另外一个复数对象

2、 可以声明复数对象的数组:

complex<double>conjugate[2]={complex<double>(2,3),complex<double>(2,-3)};

}

3、 可以声明指针和引用;complex<double>*ptr=&conjugate;  complex<double>&ref=ptr;

4、 复数支持加减乘除和相等比较。

十二、typedef名字

1、 typedef定义以关键字typedef开始，后面是数据类型和标识符，这里的标识符即typedef名字，他并没有引入一种新的类型，而只是为现有类型引入了一个助记符号。Typedef名字可以出现在任何类型名能出现的地方，可以被用做程序文档的辅助说明，能够降低声明的复杂度。已知：

typedef char *cstring;

exturn const cstringcstr; //这个定义声明了cstr是一个指向字符的const指针，const修饰cstr的类型，cstr是一个指针

十三、volatile限定修饰符

1、 当一个对象的值可能会在编译器的控制或监测外被改变时，例如一个被系统时钟更新的变量，那么该对象应该声明成volatile。因此，编译器执行的某些例行优化行为不能应用到已指定为volatile的对象上。

2、 Volatile限定修饰符的用法同const非常相似，都是作为类型的附加修饰符，例如：volatile int display_register;//        display_register是一个int型的volatile对象volatile task *curr_task;   //  curr_task是一个指向volatile的task类对象的指针volatile int ixa[max_size];  //  iax是一个volatile的整型数组，数组的每个元素都认为是volatile的

Volatile screenbitmap_buf;// bitmap_buf是一个volatile的screen类对象，它的每个数据成员都被视为volatile的

Volatile修饰符的主要目的是提示编译器，该对象的值可能在编译器未监测到的情况下被改变。因此编译器不能武断的对引用这些对象的代码作优化处理。

十四、pair类型

1、 pair类也是标准库的一部分，它使得我们在单个对象内部把相同类型或不同类型的两个值关联起来，为了使用pair类，我们必须包含下面的头文件：#include<utility>例如：

pair<string,string>author(”james”,”joyce”);

创建一个pair对象author，它包含2个字符串，分别被初始化为”james”和”joyce”，我们可以用成员访问符号（first和second）访问pair中的单个元素。

Stringfirst book;

If(author.first==”james”&&author.second==”joyce”)

Firstbook=”Stephenhero

如果我们希望定义大量相同pair类型的对象，那么最方便的做法就是用typedef，如下所示：typedefpair<string,string>authors;

Authorsproust(“a”.”proust”);

Authorsd(“c”,”d”);

Authorsf(“e”,”f”);