完整的进修C++的念书蹊径图(5)

副标题#e#

printf（）函数参数名目详解

printf的名目节制的完整名目：

% – 0 m.n l或h 名目字符

下面临构成名目说明的各项加以说明：

①%：暗示名目说明的起始标记，不行缺少。

②-：有-暗示左对齐输出，如省略暗示右对齐输出。

③0：有0暗示指定空位填0，如省略暗示指定空位不填。

④m.n：m指域宽，即对应的输出项在输出设备上所占的字符数。N指精度。用于说明输出的实型数的小数位数。为指定n时，隐含的精度为n=6位。

⑤l或h：l对整型指long型，对实型指double型。h用于将整型的名目字符批改为short型。

——————————————————————————————————————－

名目字符

名目字符用以指定输出项的数据范例和输格外式。

①d名目：用来输出十进制整数。有以下几种用法：

%d：按整型数据的实际长度输出。

%md：m为指定的输出字段的宽度。假如数据的位数小于m，则左端补以空格，若大于m，则按实际位数输出。

%ld：输出长整型数据。

②o名目：以无标记八进制形式输出整数。对长整型可以用"%lo"名目输出。同样也可以指定字段宽度用“%mo”名目输出。

例：

main（）

{ int a = -1；

printf（"%d， %o"， a， a）；

}

运行功效：-1，177777

措施理会：-1在内存单位中（以补码形式存放）为（1111111111111111）2，转换为八进制数为（177777）8.

③x名目：以无标记十六进制形式输出整数。对长整型可以用"%lx"名目输出。同样也可以指定字段宽度用"%mx"名目输出。

④u名目：以无标记十进制形式输出整数。对长整型可以用"%lu"名目输出。同样也可以指定字段宽度用“%mu”名目输出。

⑤c名目：输出一个字符。

⑥s名目：用来输出一个串。有几顶用法

%s：譬喻：printf（"%s"， "CHINA"）输出"CHINA"字符串（不包罗双引号）。

%ms：输出的字符串占m列，如字符串自己长度大于m，则打破获m的限制，将字符串全部输出。若串长小于m，则左补空格。

%-ms：假如串长小于m，则在m列范畴内，字符串向左靠，右补空格。

%m.ns：输出占m列，但只取字符串中左端n个字符。这n个字符输出在m列的右侧，左补空格。

%-m.ns：个中m、n寄义同上，n个字符输出在m列范畴的左侧，右补空格。假如n>m，则自动取n值，即担保n个字符正常输出。

⑦f名目：用来输出实数（包罗单、双精度），以小数形式输出。有以下几种用法：

%f：不指定宽度，整数部门全部输出并输出6位小数。

%m.nf：输出共占m列，个中有n位小数，如数值宽度小于m左端补空格。

%-m.nf：输出共占n列，个中有n位小数，如数值宽度小于m右端补空格。

#p#副标题#e#

⑧e名目：以指数形式输出实数。可用以下形式：

%e：数字部门（又称尾数）输出6位小数，指数部门占5位或4位。

%m.ne和%-m.ne：m、n和“-”字符寄义与前沟通。此处n指数据的数字部门的小数位数，m暗示整个输出数据所占的宽度。

⑨g名目：自动选f名目或e名目中较短的一种输出，且不输出无意义的零。

——————————————————————————————————————－

关于printf函数的进一步说明：

假如想输出字符"%"，则应该在“名目节制”字符串顶用持续两个%暗示，如：

printf（"%f%%"， 1.0/3）；

输出0.333333%.

——————————————————————————————————————－

对付单精度数，利用%f名目符输出时，仅前7位是有效数字，小数6位。

对付双精度数，利用%lf名目符输出时，前16位是有效数字，小数6位。

STL中map用法详解

Map是STL的一个关联容器，它提供一对一（个中第一个可以称为要害字，每个要害字只能在map中呈现一次，第二个大概称为该要害字的值）的数据处理惩罚本领，由于这个特性，它完成有大概在我们处理惩罚一对一数据的时候，在编程上提供快速通道。这里说下map内部数据的组织，map内部自建一颗红黑树（一种非严格意义上的均衡二叉树），这颗树具有对数据自动排序的成果，所以在map内部所有的数据都是有序的，后边我们接见识到有序的长处。

#p#分页标题#e#

下面举例说明什么是一对一的数据映射。好比一个班级中，每个学生的学号跟他的姓名就存在着一一映射的干系，这个模子用map大概等闲描写，很明明学号用int描写，姓名用字符串描写（本篇文章中不消char *来描写字符串，而是回收STL中string来描写），下面给出map描写代码：

Map<int， string> mapStudent；

1. map的结构函数

map共提供了6个结构函数，这块涉及到内存分派器这些对象，略过不表，在下面我们将打仗到一些map的结构要领，这里要说下的就是，我们凡是用如下要领结构一个map：

Map<int， string> mapStudent；

#p#副标题#e#

2. 数据的插入

在结构map容器后，我们就可以往内里插入数据了。这里讲三种插入数据的要领：

第一种：用insert函数插入pair数据，下面举例说明（以下代码固然是随手写的，应该可以在VC和GCC下编译通过，各人可以运行下看什么结果，在VC下请插手这条语句，屏蔽4786告诫＃pragma warning （disable：4786））

#include <map>

#include <string>

#include <iostream>

Using namespace std;

Int main()

{

Map<int, string> mapStudent;

mapStudent.insert(pair<int, string>(1, “student_one”));

mapStudent.insert(pair<int, string>(2, “student_two”));

mapStudent.insert(pair<int, string>(3, “student_three”));

map<int, string>::iterator iter;

for(iter = mapStudent.begin(); iter != mapStudent.end(); iter++)

{

Cout<<iter->first<<” ”<<iter->second<<end;

}

第二种：用insert函数插入value_type数据，下面举例说明

#include <map>

#include <string>

#include <iostream>

Using namespace std;

Int main()

{

Map<int, string> mapStudent;

mapStudent.insert(map<int, string>::value_type (1, “student_one”));

mapStudent.insert(map<int, string>::value_type (2, “student_two”));

mapStudent.insert(map<int, string>::value_type (3, “student_three”));

map<int, string>::iterator iter;

for(iter = mapStudent.begin(); iter != mapStudent.end(); iter++)

{

Cout<<iter->first<<” ”<<iter->second<<end;

}

#p#副标题#e#

第三种：用数组方法插入数据，下面举例说明

#include <map>

#include <string>

#include <iostream>

Using namespace std;

Int main()

{

Map<int, string> mapStudent;

mapStudent[1] = “student_one”;

mapStudent[2] = “student_two”;

mapStudent[3] = “student_three”;

map<int, string>::iterator iter;

for(iter = mapStudent.begin(); iter != mapStudent.end(); iter++)

{

Cout<<iter->first<<” ”<<iter->second<<end;

}

以上三种用法，固然都可以实现数据的插入，可是它们是有区此外，虽然了第一种和第二种在结果上是完成一样的，用insert函数插入数据，在数据的插入上涉及到荟萃的独一性这个观念，即当map中有这个要害字时，insert操纵是插入数据不了的，可是用数组方法就差异了，它可以包围以前该要害字对应的值，用措施说明

mapStudent.insert（map<int， string>：：value_type （1， “student_one”））；

mapStudent.insert（map<int， string>：：value_type （1， “student_two”））；

上面这两条语句执行后，map中1这个要害字对应的值是“student_one”，第二条语句并没有生效，那么这就涉及到我们怎么知道insert语句是否插入乐成的问题了，可以用pair来得到是否插入乐成，措施如下

Pair<map<int， string>：：iterator， bool> Insert_Pair；

Insert_Pair = mapStudent.insert（map<int， string>：：value_type （1， “student_one”））；

我们通过pair的第二个变量来知道是否插入乐成，它的第一个变量返回的是一个map的迭代器，假如插入乐成的话Insert_Pair.second应该是true的，不然为false.

下面给出完成代码，演示插入乐成与否问题

#p#分页标题#e#

#include <map>

#include <string>

#include <iostream>

Using namespace std;

Int main()

{

Map<int, string> mapStudent;

Pair<map<int, string>::iterator, bool> Insert_Pair;

Insert_Pair ＝ mapStudent.insert(pair<int, string>(1, “student_one”));

If(Insert_Pair.second == true)

{

Cout<<”Insert Successfully”<<endl;

}

Else

{

Cout<<”Insert Failure”<<endl;

}

Insert_Pair ＝ mapStudent.insert(pair<int, string>(1, “student_two”));

If(Insert_Pair.second == true)

{

Cout<<”Insert Successfully”<<endl;

}

Else

{

Cout<<”Insert Failure”<<endl;

}

map<int, string>::iterator iter;

for(iter = mapStudent.begin(); iter != mapStudent.end(); iter++)

{

Cout<<iter->first<<” ”<<iter->second<<end;

}

#p#副标题#e#

各人可以用如下措施，看下用数组插入在数据包围上的结果

#include <map>

#include <string>

#include <iostream>

Using namespace std;

Int main()

{

Map<int, string> mapStudent;

mapStudent[1] = “student_one”;

mapStudent[1] = “student_two”;

mapStudent[2] = “student_three”;

map<int, string>::iterator iter;

for(iter = mapStudent.begin(); iter != mapStudent.end(); iter++)

{

Cout<<iter->first<<” ”<<iter->second<<end;

}

3. map的巨细

在往map内里插入了数据，我们怎么知道当前已经插入了几多数据呢，可以用size函数，用法如下：

Int nSize = mapStudent.size（）；

4. 数据的遍历

这里也提供三种要领，对map举办遍历

第一种：应用前向迭代器，上面举例措施中处处都是了，略过不表

第二种：应用反相迭代器，下面举例说明，要体会结果，请自个动手运行措施

#include <map>

#include <string>

#include <iostream>

Using namespace std;

Int main()

{

Map<int, string> mapStudent;

mapStudent.insert(pair<int, string>(1, “student_one”));

mapStudent.insert(pair<int, string>(2, “student_two”));

mapStudent.insert(pair<int, string>(3, “student_three”));

map<int, string>::reverse_iterator iter;

for(iter = mapStudent.rbegin(); iter != mapStudent.rend(); iter++)

{

Cout<<iter->first<<” ”<<iter->second<<end;

}

#p#副标题#e#

第三种：用数组方法，措施说明如下

#include <map>

#include <string>

#include <iostream>

Using namespace std;

Int main()

{

Map<int, string> mapStudent;

mapStudent.insert(pair<int, string>(1, “student_one”));

mapStudent.insert(pair<int, string>(2, “student_two”));

mapStudent.insert(pair<int, string>(3, “student_three”));

int nSize = mapStudent.size()

//此处有误，应该是 for(int nIndex = 1; nIndex <= nSize; nIndex++)

//by rainfish

for(int nIndex = 0; nIndex < nSize; nIndex++)

{

Cout<<mapStudent[nIndex]<<end;

}

5. 数据的查找（包罗鉴定这个要害字是否在map中呈现）

在这里我们将体会，map在数据插入时担保有序的长处。

要鉴定一个数据（要害字）是否在map中呈现的要领较量多，这里标题固然是数据的查找，在这里将穿插着大量的map根基用法。

这里给出三种数据查找要领

第一种：用count函数来鉴定要害字是否呈现，其缺点是无法定位数据呈现位置，由于map的特性，一对一的映射干系，就抉择了count函数的返回值只有两个，要么是0，要么是1，呈现的环境，虽然是返回1了

#p#分页标题#e#

第二种：用find函数来定位数据呈现位置，它返回的一个迭代器，当数据呈现时，它返回数据地址位置的迭代器，假如map中没有要查找的数据，它返回的迭代器便是end函数返回的迭代器，措施说明

#include <map>

#include <string>

#include <iostream>

Using namespace std;

Int main()

{

Map<int, string> mapStudent;

mapStudent.insert(pair<int, string>(1, “student_one”));

mapStudent.insert(pair<int, string>(2, “student_two”));

mapStudent.insert(pair<int, string>(3, “student_three”));
map<int, string>::iterator iter;

iter = mapStudent.find(1);

if(iter != mapStudent.end())

{

Cout<<”Find, the value is ”<<iter->second<<endl;

}

Else

{

Cout<<”Do not Find”<<endl;

}

#p#副标题#e#

第三种：这个要领用来鉴定命据是否呈现，是显得笨了点，可是，我规划在这里讲授

Lower_bound函数用法，这个函数用来返回要查找要害字的下界（是一个迭代器）

Upper_bound函数用法，这个函数用来返回要查找要害字的上界（是一个迭代器）

譬喻：map中已经插入了1，2，3，4的话，假如lower_bound（2）的话，返回的2，而upper-bound（2）的话，返回的就是3

Equal_range函数返回一个pair，pair内里第一个变量是Lower_bound返回的迭代器，pair内里第二个迭代器是Upper_bound返回的迭代器，假如这两个迭代器相等的话，则说明map中不呈现这个要害字，措施说明

#include <map>

#include <string>

#include <iostream>

Using namespace std;

Int main()

{

Map<int, string> mapStudent;

mapStudent[1] = “student_one”;

mapStudent[3] = “student_three”;

mapStudent[5] = “student_five”;

map<int, string>::iterator iter;

iter = mapStudent.lower_bound(2);

{

//返回的是下界3的迭代器

Cout<<iter->second<<endl;

}

iter = mapStudent.lower_bound(3);

{

//返回的是下界3的迭代器

Cout<<iter->second<<endl;

}

iter = mapStudent.upper_bound(2);

{

//返回的是上界3的迭代器

Cout<<iter->second<<endl;

}

iter = mapStudent.upper_bound(3);

{

//返回的是上界5的迭代器

Cout<<iter->second<<endl;

}

Pair<map<int, string>::iterator, map<int, string>::iterator> mapPair;

mapPair = mapStudent.equal_range(2);

if(mapPair.first == mapPair.second)
{

cout<<”Do not Find”<<endl;

}

Else

{

Cout<<”Find”<<endl;
}

mapPair = mapStudent.equal_range(3);

if(mapPair.first == mapPair.second)
{

cout<<”Do not Find”<<endl;

}

Else

{

Cout<<”Find”<<endl;
}

}

#p#副标题#e#

6. 数据的清空与判空

清空map中的数据可以用clear（）函数，鉴定map中是否有数据可以用empty（）函数，它返回true则说明是空map

7. 数据的删除

这里要用到erase函数，它有三个重载了的函数，下面在例子中具体说明它们的用法

#include <map>

#include <string>

#include <iostream>

Using namespace std;

Int main()

{

Map<int, string> mapStudent;

mapStudent.insert(pair<int, string>(1, “student_one”));

mapStudent.insert(pair<int, string>(2, “student_two”));

mapStudent.insert(pair<int, string>(3, “student_three”));

//假如你要演示输出结果，请选择以下的一种，你看到的结果会较量好

//假如要删除1,用迭代器删除

map<int, string>::iterator iter;

iter = mapStudent.find(1);

mapStudent.erase(iter);

//假如要删除1，用要害字删除

Int n = mapStudent.erase(1);//假如删除了会返回1，不然返回0

//用迭代器，成片的删除

//一下代码把整个map清空

mapStudent.earse(mapStudent.begin(), mapStudent.end());

//成片删除要留意的是，也是STL的特性，删除区间是一个前闭后开的荟萃

//自个加上遍历代码，打印输出吧

}

8. 其他一些函数用法

这里有swap，key_comp，value_comp，get_allocator等函数，感受到这些函数在编程用的不是许多，略过不表，有乐趣的话可以自个研究

#p#副标题#e#

9. 排序

#p#分页标题#e#

这里要讲的是一点较量高妙的用法了，排序问题，STL中默认是回收小于号来排序的，以上代码在排序上是不存在任何问题的，因为上面的要害字是int型，它自己支持小于号运算，在一些非凡环境，好比要害字是一个布局体，涉及到排序就会呈现问题，因为它没有小于号操纵，insert等函数在编译的时候过不去，下面给出两个要领办理这个问题

第一种：小于号重载，措施举例 #include <map>

#include <string>

Using namespace std;

Typedef struct tagStudentInfo

{

Int nID;

String strName;

}StudentInfo, *PStudentInfo; //学生信息

Int main()

{

int nSize;

//用学生信息映射分数

map<StudentInfo, int>mapStudent;

map<StudentInfo, int>::iterator iter;
StudentInfo studentInfo;

studentInfo.nID = 1;

studentInfo.strName = “student_one”;

mapStudent.insert(pair<StudentInfo, int>(studentInfo, 90));

studentInfo.nID = 2;

studentInfo.strName = “student_two”;

mapStudent.insert(pair<StudentInfo, int>(studentInfo, 80));

for (iter=mapStudent.begin(); iter!=mapStudent.end(); iter++)

cout<<iter->first.nID<<endl<<iter->first.strName<<endl<<iter->second<<endl;

}

以上措施是无法编译通过的，只要重载小于号，就OK了，如下：

Typedef struct tagStudentInfo

{

Int nID;

String strName;

Bool operator < (tagStudentInfo const& _A) const

{

//这个函数指定排序计策，按nID排序，假如nID相等的话，按strName排序

If(nID < _A.nID) return true;

If(nID == _A.nID) return strName.compare(_A.strName) < 0;

Return false;

}

}StudentInfo, *PStudentInfo; //学生信息

第二种：仿函数的应用，这个时候布局体中没有直接的小于号重载，措施说明

#include <map>

#include <string>

Using namespace std;

Typedef struct tagStudentInfo

{

Int nID;

String strName;

}StudentInfo, *PStudentInfo; //学生信息

Classs sort

{

Public:

Bool operator() (StudentInfo const &_A, StudentInfo const &_B) const

{

If(_A.nID < _B.nID) return true;

If(_A.nID == _B.nID) return _A.strName.compare(_B.strName) < 0;

Return false;

}

};

Int main()

{

//用学生信息映射分数

Map<StudentInfo, int, sort>mapStudent;

StudentInfo studentInfo;

studentInfo.nID = 1;

studentInfo.strName = “student_one”;

mapStudent.insert(pair<StudentInfo, int>(studentInfo, 90));

studentInfo.nID = 2;

studentInfo.strName = “student_two”;

mapStudent.insert(pair<StudentInfo, int>(studentInfo, 80));

}

#p#副标题#e#

10. 别的

由于STL是一个统一的整体，map的许多用法都和STL中其它的对象团结在一起，好比在排序上，这里默认用的是小于号，即less<>，假如要从大到小排序呢，这里涉及到的对象许多，在此无法一一加以说明。

还要说明的是，map中由于它内部有序，由红黑树担保，因此许多函数执行的时间巨大度都是log2N的，假如用map函数可以实现的成果，而STL Algorithm也可以完成该成果，发起用map自带函数，效率高一些。

#p#分页标题#e#

下面说下，map在空间上的特性，不然，预计你用起来会有时候表示的较量郁闷，由于map的每个数据对应红黑树上的一个节点，这个节点在不生存你的数据时，是占用16个字节的，一个父节点指针，阁下孩子指针，尚有一个列举值（标示红黑的，相当于均衡二叉树中的均衡因子），我想各人应该知道，这些处所很费内存了吧，不说了……

/*深入领略sizeof

最近在论坛里总有人问关于sizeof的问题，而且本人对这个问题也一直没有获得很好的办理，索性本日对它来个较为具体的总结，同时团结strlen举办较量，假如能对各人有点点辅佐，这是我最大的欣慰了。

一、好首先看看sizeof和strlen在MSDN上的界说：

首先看一MSDN上如何对sizeof举办界说的：

sizeof Operator sizeof expression The sizeof keyword gives the amount of storage, in bytes, associated with a variable or a type (including aggregate types). This keyword returns a value of type size_t. The expression is either an identifier or a type-cast expression (a type specifier enclosed in parentheses). When applied to a structure type or variable, sizeof returns the actual size, which may include padding bytes inserted for alignment. When applied to a statically dimensioned array, sizeof returns the size of the entire array. The sizeof operator cannot return the size of dynamically allocated arrays or external arrays. 然后再看一下对strlen是如何界说的：

strlen
Get the length of a string.
Routine Required Header：
strlen <string.h>
size_t strlen( const char *string );
Parameter
string：Null-terminated string
Libraries
All versions of the C run-time libraries.
Return Value
Each of these functions returns the number of characters in string, excluding the terminal
NULL. No return value is reserved to indicate an error.
Remarks
Each of these functions returns the number of characters in string, not including the
terminating null character. wcslen is a wide-character version of strlen; the argument of
wcslen is a wide-character string. wcslen and strlen behave identically otherwise.

#p#副标题#e#

二、由几个例子说开去。

第一个例子：

char* ss = "0123456789"; sizeof（ss）功效 4 ＝＝＝》ss是指向字符串常量的字符指针

sizeof（*ss）功效 1 ＝＝＝》*ss是第一个字符

char ss[] = "0123456789"；

sizeof（ss）功效 11 ＝＝＝》ss是数组，计较到\\\\\\\\0位置，因此是10＋1

sizeof（*ss）功效 1 ＝＝＝》*ss是第一个字符

char ss[100] = "0123456789"；

sizeof（ss）功效是100 ＝＝＝》ss暗示在内存中的巨细 100×1

strlen（ss）功效是10 ＝＝＝》strlen是个函数内部实现是用一个轮回计较到\\\\\\\\0为止之前

int ss[100] = "0123456789"；

sizeof（ss）功效 400 ＝＝＝》ss暗示再内存中的巨细 100×4

strlen（ss）错误＝＝＝》strlen的参数只能是char* 且必需是以\\\\\\\'\\\\\\\'末了的

char q[]="abc"；

char p[]="a\\\\\\\\n"；

sizeof（q），sizeof（p），strlen（q），strlen（p）；

功效是 4 3 3 2

第二个例子：

class X { int i; int j; char k; }; X x; cout<<sizeof(X)<<endl; 功效 12 ＝＝＝》内存补齐 cout<<sizeof(x)<<endl; 功效 12 同上

第三个例子：

char szPath[MAX_PATH]

假如在函数内这样界说，那么sizeof（szPath）将会是MAX_PATH，可是将szPath作为虚参声明时（void fun（char szPath[MAX_PATH]）），sizeof（szPath）却会是4（指针巨细）

三、sizeof深入领略。

1.sizeof操纵符的功效范例是size_t，它在头文件中typedef为unsigned　int范例。该范例担保能容纳实现所成立的最大工具的字节巨细。

2.sizeof是算符，strlen是函数。

3.sizeof可以用范例做参数，strlen只能用char*做参数，且必需是以\\\\\\\’\\\\\\\’\\\\\\\\0\\\\\\\’\\\\\\\’末了的。sizeof还可以用函数做参数，好比：

short f（）；

printf（"%d\\\\\\\\n"， sizeof（f（）））；

输出的功效是sizeof（short），即2.

#p#副标题#e#

4.数组做sizeof的参数不退化，通报给strlen就退化为指针了。

5.大部门编译措施在编译的时候就把sizeof计较过了是范例或是变量的长度这就是sizeof（x）可以用来界说数组维数的原因

char str[20]="0123456789"；

int a=strlen（str）； //a=10；

int b=sizeof（str）； //而b=20；

6.strlen的功效要在运行的时候才气计较出来，时用来计较字符串的长度，不是范例占内存的巨细。

7.sizeof后假如是范例必需加括弧，假如是变量名可以不加括弧。这是因为sizeof是个操纵符不是个函数。

#p#分页标题#e#

8.当合用了于一个布局范例时或变量， sizeof 返回实际的巨细，当合用一静态地空间数组， sizeof 偿还全部数组的尺寸。 sizeof 操纵符不能返回动态地被分配了的数组或外部的数组的尺寸

9.数组作为参数传给函数时传的是指针而不是数组，通报的是数组的首地点，如：

fun（char [8]）

fun（char []）

都等价于 fun（char *）在C++里通报数组永远都是通报指向数组首元素的指针，编译器不知道数组的巨细假如想在函数内知道数组的巨细，需要这样做：进入函数后用memcpy拷贝出来，长度由另一个形参传进去

fun（unsiged char *p1， int len）

{

unsigned char* buf = new unsigned char[len+1]

memcpy（buf， p1， len）；

}

有关内容见： C++ PRIMER？

10.计较布局变量的巨细就必需接头数据对齐问题。为了CPU存取的速度最快（这同CPU取数操纵有关，具体的先容可以参考一些计较机道理方面的书），C++在处理惩罚数据时常常把布局变量中的成员的巨细凭据4或8的倍数计较，这就叫数据对齐（data alignment）。这样做大概会挥霍一些内存，但理论上速度快了。虽然这样的配置会在读写一些此外应用措施生成的数据文件或互换数据时带来未便。MS VC++中的对齐设定，有时候sizeof获得的与实际不等。一般在VC++中加上#pragma pack（n）的设定即可。可能假如要按字节存储，而不举办数据对齐，可以在Options对话框中修改Advanced compiler页中的Data alignment为按字节对齐。

11.sizeof操纵符不能用于函数范例，不完全范例或位字段。不完全范例指具有未知存储巨细的数据范例，如未知存储巨细的数组范例、未知内容的布局或连系范例、void范例等。如sizeof（max）若此时变量max界说为int　max（），sizeof（char_v）　若此时char_v界说为char　char_v　[MAX]且MAX未知，sizeof（void）都不是正确形式

四、竣事语

sizeof利用场所。

1.sizeof操纵符的一个主要用途是与存储分派和I/O系统那样的例程举办通信。譬喻：

void　*malloc（size_t　size），

size_t　fread（void　*　ptr，size_t　size，size_t　nmemb，FILE　*　stream）。

2.用它可以看看一范例的工具在内存中所占的单位字节。

void　*　memset（void　*　s，int　c，sizeof（s））

3.在动态分派一工具时，可以让系统知道要分派几多内存。

4.便于一些范例的扩充，在windows中就有许多布局内型就有一个专用的字段是用来放该范例的字节巨细。

5.由于操纵数的字节数在实现时大概呈现变革，发起在涉及到操纵数字节巨细时用sizeof来取代常量计较。

6.假如操纵数是函数中的数组形参或函数范例的形参，sizeof给出其指针的巨细。

当前位置：以往代写 > C/C++ 教程 >完整的进修C++的念书蹊径图(5)