C语言编程要点---指针和内存分配上-Read
C语言编程要点---指针和内存分配上-Read
C语言编程要点---第7章指针和内存分配（上）
指针和内存分配
指针为C语言编程提供了强大的支持——如果你能正确而灵活地利用指针，你就可以直接切入问题的核心，或者将程序分割成一个个片断。一个很好地利用了指针的程序会非常高效、简洁和精致。
利用指针你可以将数据写入内存中的任意位置，但是，一旦你的程序中有一个野指针("wild”pointer)，即指向一个错误位置的指针，你的数据就危险了——存放在堆中的数据可能会被破坏，用来管理堆的数据结构也可能会被破坏，甚至操作系统的数据也可能会被修改，有时，上述三种破坏情况会同时发生。
此后可能发生的事情取决于这样两点：第一，内存中的数据被破坏的程度有多大；第二，内存中的被破坏的部分还要被使用多少次。在有些情况下，一些函数(可能是内存分配函数、自定义函数或标准库函数)将立即(也可能稍晚一点)无法正常工作。在另外一些情况下，程序可能会终止运行并报告一条出错消息；或者程序可能会挂起；或者程序可能会陷入死循环；或者程序可能会产生错误的结果；或者程序看上去仍在正常运行，因为程序没有遭到本质的破坏。
值得注意的是，即使程序中已经发生了根本性的错误，程序有可能还会运行很长一段时间，然后才有明显的失常表现；或者，在调试时，程序的运行完全正常，只有在用户使用时，它才会失常。
在C语言程序中，任何野指针或越界的数组下标(out-of-bounds array subscript)都可能使系统崩溃。两次释放内存的操作也会导致这种结果。你可能见过一些C程序员编写的程序中有严重的错误，现在你能知道其中的部分原因了。
有些内存分配工具能帮助你发现内存分配中存在的问题，例如漏洞(leak，见7．21)，两次释放一个指针，野指针，越界下标，等等。但这些工具都是不通用的，它们只能在特定的操作系统中使用，甚至只能在特定版本的编译程序中使用。如果你找到了这样一种工具，最好试试看能不能用，因为它能为你节省许多时间，并能提高你的软件的质量。
指针的算术运算是C语言(以及它的衍生体，例如C++)独有的功能。汇编语言允许你对地址进行运算，但这种运算不涉及数据类型。大多数高级语言根本就不允许你对指针进行任何操作，你只能看一看指针指向哪里。
C指针的算术运算类似于街道地址的运算。假设你生活在一个城市中，那里的每一个街区的所有街道都有地址。街道的一侧用连续的偶数作为地址，另一侧用连续的奇数作为地址。如果你想知道River Rd．街道158号北边第5家的地址，你不会把158和5相加，去找163号；你会先将5(你要往前数5家)乘以2(每家之间的地址间距)，再和158相加，去找River Rd．街道的168号。同样，如果一个指针指向地址158(十进制数)中的一个两字节短整型值，将该指针加3=5，结
果将是一个指向地址168(十进制数)中的短整型值的指针(见7．7和7．8中对指针加减运算的详细描述)。街道地址的运算只能在一个特定的街区中进行，同样，指针的算术运算也只能在一个特定的数组中进行。实际上，这并不是一种限制，因为指针的算术运算只有在一个特定的数组中进行才有意义。对指针的算术运算来说，一个数组并不必须是一个数组变量，例如函数malloc()或calloc()的返回值是一个指针，它指向一个在堆中申请到的数组。
指针的说明看起来有些使人感到费解，请看下例：
char *p；
上例中的说明表示，p是一个字符。符号“*”是指针运算符，也称间接引用运算符。当程序间接引用一个指针时，实际上是引用指针所指向的数据。
在大多数计算机中，指针只有一种，但在有些计算机中，指向数据和指向函数的指针可以是不同的，或者指向字节(如char。指针和void *指针)和指向字的指针可以是不同的。这一点对sizeof运算符没有什么影响。但是，有些C程序或程序员认为任何指针都会被存为一个int型的值，或者至少会被存为一个long 型的值，这就无法保证了，尤其是在IBM PC兼容机上。
注意：以下讨论与Macintosh或UNIX程序员无关；
最初的IBM PC兼容机使用的处理器无法有效地处理超过16位的指针(人们对这种结论仍有争议。16位指针是偏移量，见9．3中对基地址和偏移量的讨论)。尽管最初的IBM PC机最终也能使用20位指针，但颇费周折。因此，从一开始，基于IBM兼容机的各种各样的软件就试图冲破这种限制。
为了使20位指针能指向数据，你需要指示编译程序使用正确的存储模式，例如紧缩存储模式。在中存储模式下，你可以用20位指针指向函数。在大和巨存储模式下，用20位指针既可以指向数据，也可以指向函数。在任何一种存储模式下，你都可能需要用到far指针(见7．18和7．19)。
基于286的系统可以冲破20位指针的限制，但实现起来有些困难。从386开始，IBM兼容机就可以使用真正的32位地址了，例如象MS-Windows和OS／2这样一些操作系统就实现了这一点，但MS—DOS 仍未实现。
如果你的MS—DOS程序用完了基本内存，你可能需要从扩充内存或扩展内存中分配更多的内存。许多版本的编译程序和函数库都提供了这种技术，但彼此之间有所差别。这些技术基本上是不通用的，有些能在绝大多数MS-DOS和MS-WindowsC编译程序中使用，有些只能在少数特定的编译程序中使用，还有一些只能在特定的附加函数库的支持下使用。如果你手头有能提供这种技术的软件，你最好看一下它的文档，以了解更详细的信息.
7.1. 什么是间接引用(indirection)?
对已说明的变量来说，变量名就是对变量值的直接引用。对指向变量或内存中的任何对象的指针来说，指针就是对对象值的间接引用。如果p是一个指针，p的值就是其对象的地址；*p表示“使间接引用运算符作用于p”，*p的值就是p所指向的对象的值。
*p是一个左值，和变量一样，只要在*p的右边加上赋值运算符，就可改变*p的值。如果p是一个指向常量的指针，*p就是一个不能修改的左值，即它不能被放到赋值运算符的左边，请看下例：
例7.1 一个间接引用的例子
#include
int
main()
{
int i;
int * p ;
i = 5;
p = & i; / * now * p = = i * /
/ * %Pis described in FAQ VII. 28 * /
printf("i=%d, p=%P, * p= %d\n" , i, P, *p);
* p = 6; / * same as i = 6 * /
printf("i=%d, p=%P, * p= %d\n" , i, P, *P);
return 0; / * see FAQ XVI. 4 * / }
}
上例说明，如果p是一个指向变量i的指针，那么在i能出现的任何一个地方，你都可以用*p代替i。在上例中，使p指向i(p＝&i)后，打印i或*p的结果是相同的；你甚至可以给*p赋值，其结果就象你给i赋值一样。
请参见：
7．4 什么是指针常量?
7.2. 最多可以使用几层指针?
对这个问题的回答与“指针的层数”所指的意思有关。如果你是指“在说明一个指针时最多可以包含几层间接引用”，答案是“至少可以有12层”。请看下例：
int i = 0;
int * ip0l = &d;
int ** ip02 = &ip01;
int ***ip03 = &ip02;
int **** ip04 = &dp03;
int ***** ip05 = &ip04;
int ****** ip06 = &ip05;
int ******* ip07 = &ip06;
int ******** ip08 = &ip07;
int ********* ip09 = &ip08;
int **********ip10 = &ip09;
int ***********ipll = &ip10;
int ************ ip12 = &ipll;
************ ip12 = 1; / * i = 1 * /
注意：ANSIC标准要求所有的编译程序都必须能处理至少12层间接引用，而你所使用的编译程序可能支持更多的层数。
如果你是指“最多可以使用多少层指针而不会使程序变得难读”，答案是这与你的习惯有关，但显然层数不会太多。一个包含两层间接引用的指针(即指向指针的指针)是很常见的，但超过两层后程序读起来就不那么容易了，因此，除非需要，不要使用两层以上的指针。
如果你是指“程序运行时最多可以有几层指针”，答案是无限层。这一点对循环链表来说是非常重要的，因为循环链表的每一个结点都指向下一个结点，而程序能一直跟住这些指针。请看下例：
例7．2一个有无限层间接引用的循环链表
/ * Would run forever if you didn't limit it to MAX * /
# include
struct circ_list
{
char value[ 3 ]; /* e.g.,"st" (incl '\0') */
struct circ_list * next;
};
struct circ_list suffixes[ ] = {
"th" , &.suffixes[ 1 ], / * Oth * /
"st" , &.suffixes[ 2 ], / * 1st * /
"nd" , & suffixes[ 3 ], / * 2nd * /
"rd" , & suffixes[ 4 ], / * 3rd * /
"th", &.suffixes[ 5 ], / * 4th * /
"th" , &.suffixes[ 6 ], / * 5th * /
"th" , & suffixes[ 7 ], / * 6th * /
"th" , & suffixes[ 8 ], / * 7th * /
"th", & suffixes[ 9 ], / * 8th * /
"th" , & suffixes[ 0 ], / * 9th * /
};
# define MAX 20
main()
{
int i = 0;
struct circ_list *p = suffixes;
while (i <=MAX) {
printf("%ds%\n", i, p->value);
+ +i;
p = p->next;
}
}
在上例中，结构体数组suffixes的每一个元素都包含一个表示词尾的字符串(两个字符加上末尾的NULL 字符)和一个指向下一个元素的指针，因此它有点象一个循环链表；next是一个指针，它指向另一个circ_list 结构体，而这个结构体中的next成员又指向另一个circ_list结构体，如此可以一直进行下去。
上例实际上相当呆板，因为结构体数组suffixes中的元素个数是固定的，你完全可以用类似的数组去代替它，并在while循环语句中指定打印数组中的第(i％10)个元素。循环链表中的元素一般是可以随意增减的，在这一点上，它比上例中的结构体数组suffixes要有趣一些。
请参见：
7．1 什么是间接引用(indirection)?
7.3. 什么是空指针?
有时，在程序中需要使用这样一种指针，它并不指向任何对象，这种指针被称为空指针。空指针的值是NULL，NULL是在
指针的值不能是整型值，但空指针是个例外，即空指针的值可以是一个纯粹的零(空指针的值并不必须是一个纯粹的零，但这个值是唯一有用的值。在编译时产生的任意一个表达式，只要它是零，就可以作为空指针的值。在程序运行时，最好不要出现一个为零的整型变量)。
注意：空指针并不一定会被存为零，见7．10。
警告：绝对不能间接引用一个空指针，否则，你的程序可能会得到毫无意义的结果，或者得到一个全部是零的值，或者会突然停止运行。
请参见：
7．4 什么时候使用空指针?
7．10 NULL总是等于0吗?
7．24 为什么不能给空指针赋值? 什么是总线错误、内存错误和内存信息转储
7.4. 什么时候使用空指针?
空指针有以下三种用法：
(1)用空指针终止对递归数据结构的间接引用。
递归是指一个事物由这个事物本身来定义。请看下例：
/*Dumb implementation；should use a loop */
unsigned factorial(unsinged i)
{
if(i＝0 || i＝＝1)
{
return 1；
}
else
{
return i * factorial(i-1)；
}
}
在上例中，阶乘函数factoriai()调用了它本身，因此，它是递归的。
一个递归数据结构同样由它本身来定义。最简单和最常见的递归数据结构是(单向)链表，
链表中的每一个元素都包含一个值和一个指向链表中下一个元素的指针。请看下例：
struct string_list
{
char *str；/* string(inthiscase)*/
struct string_list *next；
}；
此外还有双向链表(每个元素还包含一个指向链表中前一个元素的指针)、键树和哈希表等许多整洁的数据结构，一本较好的介绍数据结构的书中都会介绍这些内容。
你可以通过指向链表中第一个元素的指针开始引用一个链表，并通过每一个元素中指向下一个元素的指针不断地引用下一个元素；在链表的最后一个元素中，指向下一个元素的指针被赋值为NULL，当你遇到该空指针时，就可以终止对链表的引用了。请看下例：
while(p!=NULL)
{
/*dO something with p->str*/
p＝p->next；
}
请注意，即使p一开始就是一个空指针，上例仍然能正常工作。
(2)用空指针作函数调用失败时的返回值。
许多C库函数的返回值是一个指针，在函数调用成功时，函数返回一个指向某一对象的指针；反之，则返回一个空指针。请看下例：
if(setlocale(cat，loc_p)==NULL)
{
/* setlocale()failed；do something*/
/* ...*/
}
返回值为一指针的函数在调用成功时几乎总是返回一个有效指针(其值不等于零)，在调用失败时则总是返回一个空指针(其值等于零)；而返回值为一整型值的函数在调用成功时几乎总是返回一个零值，在调用失败时则总是返回一个非零值。请看下例：
if(raise(sig)!＝0){
/* raise()failed；do something*/
/* ．．．*/
}
对上述两类函数来说，调用成功或失败时的返回值含义都是不同的。另外一些函数在调用成功时可能会返回一个正值，在调用失败时可能会返回一个零值或负值。因此，当你使用一个函数之前，应该先看一下它的返回值是哪种类型，这样你才能判断函数返回值的含义。
(3)用空指针作警戒值
警戒值是标志事物结尾的一个特定值。例如，main()函数的预定义参数argv是一个指针数组，它的最后一个元素(argv[argc])永远是一个空指针，因此，你可以用下述方法快速地引用argv中的每一个元素：
/*
A simple program that prints all its arguments.
It doesn't use argc ("argument count"); instread.
it takes advantage of the fact that the last
value in argv ("argument vector") is a null pointer.
*/
# include
# include
int
main ( int argc, char * * argv)
{
int i;
printf ("program name = \"%s\"\n", argv[0]);
for (i=l; argv !=NULL; ++i)
printf ("argv[%d] = \"%s\"\n", i, argv[f]);
assert (i = = argc) ; / * see FAQ XI. 5 * /
return 0; / * see FAQ XVI. 4 * /
}
请参见：
7．3 什么是空指针?
7．10 NULL总是等于0吗?
20．2 程序总是可以使用命令行参数吗?
7.5. 什么是void指针?
void指针一般被称为通用指针或泛指针，它是C关于“纯粹地址(raw address)”的一种约定。void指针指向某个对象，但该对象不属于任何类型。请看下例：
int *ip;
void *p;
在上例中，ip指向一个整型值，而p指向的对象不属于任何类型。
在C中，任何时候你都可以用其它类型的指针来代替void指针(在C++中同样可以)，或者用void指针来代替其它类型的指针(在C++中需要进行强制转换)，并且不需要进行强制转换。例如，你可以把char *类型的指针传递给需要void指针的函数。
请参见：
7．6 什么时候使用void指针?
7．27 可以对void指针进行算术运算吗?
15．2 C++和C有什么区别?
7.6. 什么时候使用void指针?
当进行纯粹的内存操作时，或者传递一个指向未定类型的指针时，可以使用void指针。void指针也常常用作函数指针。
有些C代码只进行纯粹的内存操作。在较早版本的C中，这一点是通过字符指针(char *)实现的，但是这容易产生混淆，因为人们不容易判断一个字符指针究竟是指向一个字符串，还是指向一个字符数组，或者仅仅是指向内存中的某个地址。
例如，strcpy()函数将一个字符串拷贝到另一个字符串中，strncpy()函数将一个字符串中的部分内容拷贝到另一个字符串中：
char *strepy(char'strl，const char *str2)；
char *strncpy(char *strl，const char *str2，size_t n)；
memcpy()函数将内存中的数据从一个位置拷贝到另一个位置：
void *memcpy(void *addrl，void *addr2，size_t n)；
memcpy()函数使用了void指针，以说明该函数只进行纯粹的内存拷贝，包括NULL字符(零字节)在内的任何内容都将被拷贝。请看下例：
#include "thingie.h" /* defines struct thingie */
struct thingie *p_src，*p_dest；
/* ... */
memcpy(p_dest，p_src，sizeof(struct thingie) * numThingies)；
在上例中，memcpy()函数要拷贝的是存放在structthingie结构体中的某种对象op_dest和p_src都是指向structthingie结构体的指针，memcpy()函数将把从p_src指向的位置开始的sizeof(stuctthingie) *numThingies 个字节的内容拷贝到从p_dest指向的位置开始的一块内存区域中。对memcpy()函数来说，p_dest和p_src 都仅仅是指向内存中的某个地址的指针。
请参见：
7．5 什么是void指针?
7．14 什么时候使用指向函数的指针?
7.7. 两个指针可以相减吗?为什么?
如果两个指针向同一个数组，它们就可以相减，其为结果为两个指针之间的元素数目。仍以本章开头介绍的街道地址的比喻为例，假设我住在第五大街118号，我的邻居住在第五大街124号，每家之间的地址间距是2(在我这一侧用连续的偶数作为街道地址)，那么我的邻居家就是我家往前第(124-118)/2(或3)家(我和我的邻居家之间相隔两家，即120号和122号)。指针之间的减法运算和上述方法是相同的。
在折半查找的过程中，同样会用到上述减法运算。假设p和q指向的元素分别位于你要找的元素的前面和后面，那么(q-p)/2+p指向一个位于p和q之间的元素。如果(q-p)/2+p位于你要找的元素之前，下一步你就可以在(q-p)/2+p和q之间查找要找的元素；反之，你可以停止查找了。
如果两个指针不是指向一个数组，它们相减就没有意义。假设有人住在梅恩大街110号，我就不能将第五大街118号减去梅恩大街110号(并除以2)，并以为这个人住在我家往回第4家中。
如果每个街区的街道地址都从一个100的倍数开始计算，并且同一条街的不同街区的地址起址各不相同，那么，你甚至不能将第五大街204号和第五大街120号相减，因为它们尽管位于同一条街，但所在的街区不同(对指针来说，就是所指向的数组不同)。
C本身无法防止非法的指针减法运算，即使其结果可能会给你的程序带来麻烦，C也不会给出任何提示或警告。
指针相减的结果是某种整类型的值，为此，ANSIC标准
尽管在不同的编译程序中ptrdiff_t的类型可能各不相同(int或long或其它)，但它们都适当地定义了ptrdiff_t 类型。
例7．7演示了指针的减法运算。该例中有一个结构体数组，每个结构体的长度都是16字节。
如果是对指向结构体数组的指针进行减法运算，则a[0]和a[8]之间的距离为8；如果将指向结构体数组的指针强制转换成指向纯粹的内存地址的指针后再相减，则a[0]和aL8]之间的距离为128(即十六进制数0x80)。如果将指向a[8]的指针减去8，该指针所指向的位置并不是往前移了8个字节，而是往前移了8个数组元素。
注意：把指针强制转换成指向纯粹的内存地址的指针，通常就是转换成void *类型，但是，本例将指针强制转换成char *类型，因为void。类型的指针之间不能进行减法运算(见7．27)。
例7.7 指针的算术运算
# include
# include
struct stuff {
char name[l6];
/ * other stuff could go here, too * /
};
struct stuff array [] = {
{ "The" },
{ "quick" },
{ "brown" >,
{ "fox" },
{ "jumped" },
{ "over" },
{ "the" },
{ "lazy" },
{ "dog. " },
/*
an empty string signifies the end;
not used in this program,
but without it, there'd be no way
to find the end (see FAQ IX. 4)
*/
{ " " }
};
main ( )
{
struct stuff * p0 = &.array[0];
struct stuff * p8 = &-array[8];
ptrdiff_t diff = p8-p0;
ptrdiff_t addr.diff = (char * ) p8 - (char * ) p0;
/*
cast the struct stuff pointers to void *
(which we know printf() can handles see FAQ VII. 28)
*/
printf ("&array[0] = p0 = %P\n" , (void* ) p0);
printf ("&. array[8] = p8 = %P\n" , (void* ) p8) ;
*/
cast the ptrdiff_t's to long's
(which we know printf () can handle)
*/
printf ("The difference of pointers is %ld\n" , (long) diff) ;
printf ("The difference of addresses is %ld\n" , (long) addr_diff);
printf ("p8-8 = %P\n" , (void*) (p8-8));
/ * example for FAQ VII. 8 * /
printf ("p0 + 8 = %P (same as p8)\n", (void* ) (p0 + 8));
return 0; / * see FAQ XVI. 4 * /
}
请参见：
7．8 把一个值加到一个指针上意味着什么?
7．12 两个指针可以相加吗?为什么?
7．27 可以对void指针进行算术运算吗?
7.8. 把一个值加到一个指针上意味着什么?
当把一个整型值加到一个指针上后，该指针指向的位置就向前移动了一段距离。就纯粹的内存地址而言，这段距离对应的字节数等于该值和该指针所指向的对象的大小的乘积；但是，就C指针真正的工作机理而言，这段距离对应的元素数等于该整型值。
在例7．7末尾，当程序将8和&array[o]相加后，所得的指针并不是指向&array[0]后的第8个字节，而是第8个元素。
仍以本章开头介绍的街道地址的比喻为例，假设你住在沃克大街744号，在你这一侧用连续的偶数作为街道地址，每家之间的地址间距是2。如果有人想知道你家往前第3家的地址，他就会先将2和3相乘，然后将6和你家的地址相加，得到他想要的地址750号。同理，你家往回第1家的地址是774+(-1)*2，即742号。
街道地址的算术运算只有在一个特定的街区中进行才有意义，同样，指针的算术运算也只有在一个特定的数组中进行才有意义。仍以上一段所介绍的背景为例，如果你想知道你家往回第400家的地址，你将得到沃克大街-56号，但这是一个毫无意义的地址。如果你的程序中使用了一个毫无意义的地址，你的程序很可能会被彻底破坏。
请参见：
7．7两个指针可以相减吗?为什么?
7．12两个指针可以相加吗，为什么?
7．27可以对void指针进行算术运算吗?
7.9. NULL总是被定义为0吗?
NULL不是被定义为o，就是被定义为(void *)0，这两种值几乎是相同的。当程序中需要一个指针时(尽管编译程序并不是总能指示什么时候需要一个指针)，一个纯粹的零或者一个void指针都能自动被转换成所需的任何类型的指针。
请参见：
7．10NULL总是等于0吗?
7.10. NULL总是等于0吗?
对这个问题的回答与“等于”所指的意思有关。如果你是指“与。比较的结果为相等”，例如：
if(/* ．．．*/)
{
p＝NULL；
}
else
{
p＝/* something else */；
}
/* ．．．*/
if(p＝＝0)
那么NULL确实总是等于0，这也就是空指针定义的本质所在。
如果你是指“其存储方式和整型值。相同”，那么答案是“不”。NULL并不必须被存为一个整型值0，尽管这是NULL最常见的存储方式。在有些计算机中，NULL会被存成另外一些形式。
如果你想知道NULL是否被存为一个整型值0，你可以(并且只能)通过调试程序来查看空指针的值，或者通过程序直接将空指针的值打印出来(如果你将一个空指针强制转换成整类型，那么你所看到的很可能就是一个非零值)。
请参见：
7．9NULL总是被定义为0吗?
7．28怎样打印一个地址?
7.11. 用指针作if语句的条件表达式意味著什么?
当把一个指针作为条件表达式时，所要判断的条件实际上就是“该指针是否为一空指针”。在if,while，for 或do/while等语句中，或者在条件表达式中，都可以使用指针。请看下例：
if(p)
{
/*dO something*/
}
else
{
/* dOsomethingelse */
}
当条件表达式的值不等于零时，if语句就执行“then”子句(即第一个子句)，即“if(/*something*/)”和“if(/*something*/!＝0)”是完全相同的。因此，上例和下例也完全相同:
if(p !＝0)
{
/* dO something(not anull pointer)*/
}
else
{
/* dOsomethingelse(a null pointer)*/
}
以上两例中的代码不易读，但经常出现在许多C程序中，你不必编写这样的代码，但要理解这些代码的作用。
请参见：
7．3 什么是空指针?
7.12. 两个指针可以相加吗?为什么?
两个指针是不能相加的。仍以街道地址的比喻为例，假设你住在湖滨大道1332号，你的邻居住在湖滨大道1364号，那么1332+1364指的是什么呢?其结果是一个毫无意义的数字。如果你的C程序试图将两个指针相加，编译程序就会发出警告。
当你试图将一个指针和另外两个指针的差值相加的时候，你很可能会误将其中的两个指针相加，例如，你很可能会使用下述语句：
p＝p+p2-p1;
上述语句是不正确的，因为它和下述语句完全相同：
p=(p+p2)-p1;
正确的语句应该是：
p＝p+(p2-p1);
对此例来说，使用下述语句更好：
p+＝p2-p1;
请参见：
7．7 两个指针可以相减吗?为什么?
7.13. 怎样使用指向函数的指针?
在使用指向函数的指针时，最难的一部分工作是说明该指针。例如，strcmp()函数的说明如下所示：
int strcmp(const char*，const char*);
如果你想使指针pf指向strcmp()函数，那么你就要象说明strcmp()函数那样来说明pf，但此时要用*pf代替strcmp：
int (*pr)(const char*，const char*)；
请注意，*pf必须用括号括起来，因为
int *p{ (constchar * ，constchar * )；/* wrong */
等价于
(int *)pr(const char *，const char * ); /* wrong */
它们都只是说明了一个返回int *类型的函数。
在说明了pf后，你还要将
pf＝strcmp;
或
pf＝Slstrcmp; /* redundant& */
此后，你就可以通过间接引用pf来调用strcmp()函数：
if(pr(strl，str2)>0) /*．．．*/
请参见：
7．14 怎样用指向函数的指针作函数的参数?
《C语言程序设计》第三章 C语言基础 课堂笔记
页眉内容 《C语言程序设计》第三章C语言基础课堂笔记 §3.1 基本字符集、关键字和标识符 一．基本字符集 字符是C的基本元素，C语言允许使用的基本字符集： 1．26个大写字母A B C D E F G H I J K L M N O P Q R S T U V W X Y Z 2．26个小写子母a b c d e f g h I j k l m n o p q r s t u v w x y z 3．10个阿拉伯数字0 1 2 3 4 5 6 7 8 9 4．其他字符！" # % & ' ( ) * + , - . / : < = > ? [ \ ] ^ _ { | } ~ 5．空格字符以及制表符合换行符等控制字符 二．关键字（P375，附录II） C中具有固定意义的字符串。 (1) C中的关键字共32个，必须用小写字母 (2) 关键字不可用于变量名、函数名等。 auto break case char const continue default do double else enum extern float for goto if int long register return short signed sizeof static struct switch typedef union unsigned void volatile while 三．标识符 标识符用于命名变量、类型、函数和其他各种用户定义的对象，是由字母、下划线和数字三种字符组成。 (1) 第一个字符必须为字母或下划线 (2) C对标识符的长度规定为任意，Turbo C区分32 个字符 (3) C区分大小写 (4) 不允许关键字作为标识符 §3.2 C数据类型
C语言程序设计读书笔记题目
读书笔记注意事项： 1、 读书笔记要求至少有六个题目，在一类、二类、三类题目中各选两题，具体题目选择由 学生自行选择。 2、 每个题目必须包含所选题目，以及具体题目的程序实现过程，要求每行语句后都需要有 程序解释，如：int a,b,c; /*定义三个变量a,b,c ，变量类型为整型*/。 3、 读书笔记要求全部手写，在17周由学习委员统一交给任课教师。 一、一类题目 1. 输入任意3个整数，求它们的平均值。 2. 输入任意4个整数，求它们的平均值。 3. 输入一个非负数，计算以这个数为半径的圆周长和面积。 4. 将从键盘输入的实型十进制数分离为整数部分和小数部分后输出。如输入 123.45，输出为：123.45=123+0.45 5. 输入3个字符，反向输出这3个字符和它们的ASCII 码。 6. 输入4个字符，反向输出这4个字符和它们的ASCII 码。 7. 输入任意一个3位数，将其各位数字反序输出（例如输入123，输出321）。 8. 求前n 项的累加和。如S=1+2+3+…+n 。 9. 求n ！。如fac=1*2*3*…*n 。 10.输入三角形的边长，求三角形的面积（面积=sqrt(s(s-a)(s-b)(s-c))， s=(a+b+c)/2）。 11.输入一个华氏温度，要求输出摄氏温度，公式为：）（32f 95 c -=，输出前要有提示信息，输出结果保留小数点后两位。 12.求前驱字符和后继字符。输入一个字符，找出它的前驱字符和后继字符，并 按ASCII 码值，按从大到小的顺序输出这3个字符及其对应的ASCII 码值。 13.输入一个非负数，计算以这个数为半径的圆周长和面积。 14.输入两个字符，若这两个字符的序号（ASCII 码）之差为偶数，则输出它们 的后继字符，否则输出它们的前驱字符。 15.输入整数a 和b ，如果a 能被b 整除，就输出算式和商，否则输出算式、整 数商和余数。 二、二类题目 1. 输入一个3位数，判断是否是一个“水仙花数”。水仙花数是指3位数的各位 数字的立方和等于这个3位数本身。例如：153=1*1*1+5*5*5+3*3*3。 2. 试编写一程序，将所有3位数中是“水仙花数”的输出。
操作系统内存动态分配模拟算法
实验四存分配算法 1.实验目的 一个好的计算机系统不仅要有一个足够容量的、存取速度高的、稳定可靠的主存储器，而且要能合理地分配和使用这些存储空间。当用户提出申请主存储器空间时，存储管理必须根据申请者的要求，按一定的策略分析主存空间的使用情况，找出足够的空闲区域分配给申请者。当作业撤离或主动归还主存资源时，则存储管理要收回作业占用的主存空间或归还部分主存空间。主存的分配和回收的实现是与主存储器的管理方式有关的，通过本实验帮助学生理解在动态分区管理方式下应怎样实现主存空间的分配和回收。 背景知识： 可变分区方式是按作业需要的主存空间大小来分割分区的。当要装入一个作业时，根据作业需要的主存量查看是否有足够的空闲空间，若有，则按需要量分割一个分区分配给该作业；若无，则作业不能装入。随着作业的装入、撤离、主存空间被分成许多个分区，有的分区被作业占用，而有的分区是空闲的。 2.实验容 采用首次适应算法或循环首次算法或最佳适应算法分配主存空间。 由于本实验是模拟主存的分配，所以当把主存区分配给作业后并不实际启动装入程序装入作业，而用输出“分配情况”来代替。（即输出当时的空闲区说明表及其存分配表） 利用VC++6.0实现上述程序设计和调试操作。 3.实验代码 #include using namespace std; //定义存的大小 const int SIZE=64; //作业结构体，保存作业信息 struct Project{ int number; int length; }; //存块结构体，保存存块信息 struct Block{
笔记排列组合C语言编程
排列组合 所谓排列，就是指从给定个数的元素中取出指定个数的元素进行排序。组合则是指从给定个数的元素中仅仅取出指定个数的元素，不考虑排序。排列组合的中心问题是研究给定要求的排列和组合可能出现的情况总数 排列组合的基本公式 A(n,m)=n(n-1)(n-2)……(n-m+1)=n!/(n-m) C(n,m)=A(n,m)/m!=n！/((n-m)!*m!) C(n,m)=C（n-1,m-1）+C(n-1,m) 排列实现 1.回溯实现 1)算法设计 应用回溯法产生排列A(n,m).设置一维a数组，a(i)在1—n中取值，出现数字相同时返回。 当i long s=0; printf(“input n (n<10):”); scanf(“%d”,&n); printf(“input m (1 浅析动态内存分配及Malloc/free的实现2011-03-18 22:47一、概述： 动态内存分配，特别是开发者经常接触的Malloc/Free接口的实现，对许多开发者来说，是一个永远的话题，而且有时候也是一个比较迷惑的问题，本文根据自己的理解，尝试简单的探究一下在嵌入式系统中，两类典型系统中动态内存分配以及Malloc/Free的实现机制。 二、内存分配方式 Malloc/Free主要实现的是动态内存分配，要理解它们的工作机制，就必须先了解操作系统内存分配的基本原理。 在操作系统中，内存分配主要以下面三种方式存在： （1）静态存储区域分配。内存在程序编译的时候或者在操作系统初始化的时候就已经分配好，这块内存在程序的整个运行期间都存在，而且其大小不会改变，也不会被重新分配。例如全局变量，static变量等。 （2）栈上的内存分配。栈是系统数据结构，对于进程/线程是唯一的，它的分配与释放由操作系统来维护，不需要开发者来 [url=javascript:;]管理[/url] 。在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时，这些存储单元会被自动释放。栈内存分配运算内置于处理器的指令集中，效率很高，不同的操作系统对栈都有一定的限制。 （3）堆上的内存分配，亦称动态内存分配。程序在运行的期间用malloc申请的内存，这部分内存由程序员自己负责管理，其生存期由开发者决定：在何时分配，分配多少，并在何时用free来释放该内存。这是唯一可以由开发者参与管理的内存。使用的好坏直接决定系统的性能和稳定。 三、动态内存分配概述 首先，对于支持虚拟内存的操作系统，动态内存分配(包括内核加载,用户进程加载,动态库加载等等)都是建立在操作系统的虚拟内存分配之上的，虚拟内存分配主要包括： 1、进程使用的内存地址是虚拟的(每个进程感觉自己拥有所有的内存资源)，需要经过页表的映射才能最终指向系统实际的物理地址。 2、主内存和磁盘采用页交换的方式加载进程和相关数据，而且数据何时加载到主内存，何时缓存到磁盘是OS调度的，对应用程序是透明的。 3、虚拟存储器给用户程序提供了一个基于页面的内存大小，在32位系统中，用户可以页面大小为单位，分配到最大可以到4G(内核要使用1G或2G等内存地址)字节的虚拟内存。 4、对于虚拟内存的分配，操作系统一般先分配出应用要求大小的虚拟内存，只有当应用实际使用时，才会调用相应的操作系统接口，为此应用程序分配大小以页面为单位的实际物理内存。 5、不是所有计算机系统都有虚拟内存机制，一般在有MMU硬件支持的系统中才有虚拟内存的实现。许多嵌入式操作系统中是没有虚拟内存机制的，程序的动态分配实际是直接针对物理内存进行操作的。许多典型的实时嵌入式系统如Vxworks、Uc/OS 等就是这样。 四、动态内存分配的实现 由于频繁的进行动态内存分配会造成内存碎片的产生，影响系统性能，所以在不同的系统中，对于动态内存管理，开发了许多不同的算法（具体的算法实现不想在这里做详细的介绍，有兴趣的读者可以参考Glib C 的源代码和附录中的资料）。不同的操作系统有不同的实现方式，为了程序的可移植性，一般在开发语言的库中都提供了统一接口。对于C语言，在标准C库和Glib 中，都实现了以malloc/free为接口的动态内存分配功能。也就是说，malloc/free库函索包装了不同操作系统对动态内存管理的不同实现，为开发者提供了一个统一的开发环境。对于我们前面提到的一些嵌入式操作系统，因为实时系统的特殊要求（实 一个程序本质上都是由BSS 段、data段、text段三个组成的。这种概念在当前的计算机程序设计中是非常重要的一个基本概念，并且在嵌入式系统的设计中也非常重要，牵涉到嵌入式系统执行时的内存大小分配，存储单元占用空间大小的问题。 ●BSS段：在採用段式内存管理的架构中。BSS段（bss segment）一般是指用 来存放程序中未初始化的全局变量的一块内存区域。 BSS是英文Block Started by Symbol的简称。 BSS段属于静态内存分配。 ●数据段：在採用段式内存管理的架构中，数据段（data segment）一般是指 用来存放程序中已初始化的全局变量的一块内存区域。数据段属于静态内存分配。 ●代码段：在採用段式内存管理的架构中，代码段（text segment）一般是指 用来存放程序执行代码的一块内存区域。这部分区域的大小在程序执行前就已经确定，而且内存区域属于仅仅读。 在代码段中。也有可能包括一些仅仅读的常数变量，比如字符串常量等。 程序编译后生成的目标文件至少含有这三个段。这三个段的大致结构图例如以下所看到的： 当中.text即为代码段，为仅仅读。.bss段包括程序中未初始化的全局变量和static变量。 data段包括三个部分：heap(堆)、stack(栈)和静态数据区。 ●堆（heap）：堆是用于存放进程执行中被动态分配的内存段。它的大小并不 固定，可动态扩张或缩减。当进程调用malloc等函数分配内存时。新分配的内存就被动态加入到堆上（堆被扩张）；当利用free等函数释放内存时，被释放的内存从堆中被剔除（堆被缩减） 栈(stack)：栈又称堆栈，是用户存放程序暂时创建的局部变量，也就是说我们函数括弧“{}”中定义的变量（但不包含static声明的变量。static意味着在数据段中存放变量）。 除此以外，在函数被调用时。其參数也会被压入发起调用的进程栈中。而且待到调用结束后。函数的返回值也会被存放回栈中。 因为栈的先进先出特点，所以栈特别方便用来保存/恢复调用现场。从这个意义上讲，我们能够把堆栈看成一个寄存、交换暂时数据的内存区。 当程序在运行时动态分配空间（C中的malloc函数），所分配的空间就属于heap。其概念与数据结构中“堆”的概念不同。 stack段存放函数内部的变量、參数和返回地址，其在函数被调用时自己主动分配。訪问方式就是标准栈中的LIFO方式。 （由于函数的局部变量存放在此，因此其訪问方式应该是栈指针加偏移的方式，否则若通过push、pop操作来訪问相当麻烦） data段中的静态数据区存放的是程序中已初始化的全局变量、静态变量和常量。 在採用段式内存管理的架构中（比方intel的80x86系统），BSS 段（Block Started by Symbol segment）一般是指用来存放程序中未初始化的全局变量的一块内存区域，一般在初始化时BSS 段部分将会清零。BSS 段属于静态内存分配。即程序一開始就将其清零了。 比方，在C语言之类的程序编译完毕之后，已初始化的全局变量保存在.data 段中，未初始化的全局变量保存在.bss 段中。 text和data段都在可运行文件里（在嵌入式系统里通常是固化在镜像文件里）。由系统从可运行文件里载入；而BSS段不在可运行文件里，由系统初始化。 《动态分配内存与数据结构》习题 学号姓名 一、选择题 1、是一种限制存取位置的线性表，元素的存取必须服从先进先出的规则。 A．顺序表B．链表C．栈D．队列 2、是一种限制存取位置的线性表，元素的存取必须服从先进后出的规则。 A．顺序表B．链表C．栈D．队列 3、与顺序表相比，链表不具有的特点是。 A．能够分散存储数据，无需连续内存空间 B．插入和删除无需移动数据 C．能够根据下标随机访问 D．只要内存足够，没有最大长度的限制 4、如果通过new运算符动态分配失败，返回结果是。 A．-1 B．0 C．1D．不确定 5、实现深复制中，不是必须自定义的。 A．构造函数B．复制构造函数 C．析构函数D．复制赋值操作符函数 6、分析下列代码是否存在问题，选择合适的选项：。 int main(void) { int *p = new int [10]; p = new int [10]; delete [] p; p = NULL; return 0; } A．没有问题 B．有内存泄漏 C．存在空悬指针 D．存在重复释放同一空间 7、通过new运算符动态分配的对象，存储于内存中的。 A．全局变量与静态变量区 B．代码区 C．栈区 D．堆区 8、下列函数中，可以是虚函数。 A．构造函数 B．析构函数 C．静态成员函数 D．友元函数 9、关于通过new运算符动态创建的对象数组，下列判断中是错误的。 A. 动态创建的对象数组只能调用默认构造函数 B. 动态创建的对象数组必须调用delete []动态撤销 C. 动态创建的对象数组的大小必须是常数或常变量 D. 动态创建的对象数组没有数组名 10、顺序表不具有的特点是 A. 元素的存储地址连续 B. 存储空间根据需要动态开辟，不会溢出 C. 可以直接随机访问元素 D. 插入和删除元素的时间开销与位置有关 11、假设一个对象Ob1的数据成员是指向动态对象的指针，如果采用浅复制的方式复制该对象得到对象Ob2，那么在析构对象Ob1和对象Ob2时会的问题。 A. 有重复释放 B. 没有 C. 内存泄漏 D. 动态分配失败 12、假设对5个元素A、B、C、D、E进行压栈或出栈的操作，压栈的先后顺序是ABCDE，则出栈的先后顺序不可能是。 A. ABCDE B. EDCBA C. EDBCA D. BCADE 13、假设对4个元素A、B、C、D、E进行压栈或出栈的操作，压栈的先后顺序是ABCD，则出栈的先后顺序不可能是。 A. ABCD B. DCBA C. BCAD D. DCAB 14、通过new运算符动态创建的对象的存放在中。 A. 代码区 B. 栈区 C. 自由存储区 D. 全局数据区 15、链表不具有的特点是。 A. 元素的存储地址可以不连续 B. 存储空间根据需要动态开辟，不会溢出 C. 可以直接随机访问元素 D. 插入和删除元素的时间开销与位置无关 16、有关内存分配和释放的说法，下面当中错误的是 A．new运算符的结果只能赋值给指针变量 B．动态创建的对象数组必须调用delete []动态撤销 C．用new分配的空间位置是在内存的栈区 D．动态创建的对象数组没有数组名 17、关于栈，下列哪项不是基本操作 A．删除栈顶元素 B．删除栈底元素 C．判断栈是否为空 D．把栈置空 18、关于链表，说法错误的是 c语言中动态内存申请与释放的简单理解 在C里，内存管理是通过专门的函数来实现的。与c++不同，在c++中是通过new、delete函数动态申请、释放内存的。 1、分配内存 malloc 函数 需要包含头文件： #include 十速单片机TM57MA15 ---C语言编程应用笔记 Tomson.Liu Aug.17,2016 All for dream 一切为了梦想 一、端口设置的注意事项 1. PA7端口 PA7端口既可以作为复位端口，也可以作为普通IO口使用，作为普通IO口时，可作为的输入口。具体设置如下： INT2 PA7 端口作为INT2中断源时，只能是下降沿中断； https://www.wendangku.net/doc/8a17362107.html, 一、端口设置的注意事项 2. PA7以外的端口 在设置单片机的端口方向时，如果将端口设置为施密特输入端口时，必须在初始化端口初始值时，将该端口置为高，否则端口输出为低电平，无法读取状态。 ------该单片机不像普通的51单片机，只需要设置端口方向后，就可以直接读取端口状态，而需要将端口初始化赋值为高，方可。 关于端口设置的描述，详见TM57MA15的datasheet中描述，如下： 二、寄存器使用时注意的事项 该单片机的内部寄存器分为F寄存器和R寄存器，由R寄存器只能写入，因此在程序中定义R寄存器变量时，该变量只能进行赋值，不能进行逻辑和算术运算。否则会出现一些意想不到的问题。另外对RAM中使用的关键变量，初始化时需要清零。RAM上电后，为不定态。在程序空间允许的情况下，上电后对使用的连续RAM空间进行清零操作。 三、端口初始化注意的事项 TM57MA15单片机，我公司有使用10Pin的小封装，该封装只有PA端口和PD0口。该单片机的标准封装为SOP-16，具有PA,PB和PD端口。10Pin的小封装，只是将未用引脚对外引出而已，芯片内部仍存在。因此初始化时，仍需对PB等未用的端口进行初始化，否则很难较低静态功耗。 C语言程序设计笔记 1. 合法的标识符由字母（大、小写均可）、数字和下划线组成，并且必须以字母或下划线开头。 2. 整型常量：用不带小数点的数字表示。 实型常量：用带小数点的数字表示。 字符型常量：用带有单引号的字符表示。 3. #define是一条预处理命令，又被称为宏定义命令，其功能是把命令格式中的标识符定义为其后的常量值。例如#define PI 3.14 一经定义，以后在程序中所有出现该标识符的地方均以该常量值代之。 习惯上符号常量的标识符用大写字母表示，变量标识符用小写字母表示，以示区别。 用#define进行定义时，必须用“#”号作为一行的开头，在#define命令行的最后不得加分号结束 4. 字符常量就是用一对单引号括起来的单个字符。 5. 注意switch语句中的default，代表所有case以外的情况，在不能找到符合的case并且存在default时就会执行default后的语句。 6. 在switch结构中，如果没有break出现，当遇到符合的case时将会自动执行其后的所有case和default中的语句。可见break在switch结构中的重要性。有了break的switch 语句才起到真正的分支作用。 7. 语句标号和goto语句的使用。Goto语句为无条件转向语句，必须与语句标号配合使用。语句标号必须是标识符。 8. 真值表。或门中，即“||”，有真就真，全假才假。与门中，即&&，有假就假，全真才真。 9. C语言中，不只是1表示逻辑真，而是所有非零都表示逻辑上的真值。 10.要时刻注意if语句与其后的表达式的关系，是包含还是无关。注意花括号。 11.要记住C语言中的运算符的优先级。 12. switch结构中，case于表达式之间一定要有空格，例如case 10，而不是case10. 13. 必要的时候case后面的语句可以省略不写，意为与后面的case合并选择。 14. switch和case后的括号中的用于匹配的表达式的类型必须相同。各个case后的值应该不同。 15 .关于牛顿迭代法解方程： 若是解隐函数方程，如x=cosx，可以让x1=0，应该令x2=cosx1。注意分析，满足方程的根无非就是要x和cosx相等，想办法构造循环让x自己运算自己就可以。 如果未达到精度要求，再将x2给x1，然后计算出一个新的x2，这样一轮一轮的来，总会找到符合要求的解，跳出循环，此时x1和x2都可以作为方程的解。 若是解一般方程，x2有公式， x2=x1-f(x1)/f`(x1) 《程序设计基础C》 第一课程序设计入门 一、问题->面向过程的程序设计思想+高级程序设计语言C语言的语法+集成开发环境（编辑+编译+链接+调试工具）+C语言函数库->可执行文件 例：已知一个圆的半径为3，求其面积。 #include 实验报告 实验课程名称：动态内存分配算法 年12月1日 实验报告 一、实验内容与要求 动态分区分配又称为可变分区分配，它是根据进程的实际需要，动态地为之分配内存空间。在实验中运用了三种基于顺序搜索的动态分区分配算法，分别是1.首次适应算法2.循环首次适应算法3.最佳适应法3.最坏适应法分配主存空间。 二、需求分析 本次实验通过C语言进行编程并调试、运行，显示出动态分区的分配方式，直观的展示了首次适应算法循环首次适应算法、最佳适应算法和最坏适应算法对内存的释放和回收方式之间的区别。 首次适应算法 要求空闲分区链以地址递增的次序链接，在分配内存时，从链首开始顺序查找，直至找到一个大小能满足要求的空闲分区为止，然后在按照作业的大小，从该分区中划出一块内存空间，分配给请求者，余下的空余分区仍留在空链中。 优点：优先利用内存中低址部分的空闲分区，从而保留了高址部分的大空闲区，为以后到达的大作业分配大的内存空间创造了条件。 缺点：低址部分不断被划分，会留下许多难以利用的、很小的空闲分区即碎片。而每次查找又都是从低址部分开始的，这无疑又会增加查找可用空闲分区时的开销。 循环首次适应算法 在为进程分配内存空间时，不是每次都从链首开始查找，而是从上次找到的空闲分区的下一个空闲分区开始查找，直到找到一个能满足要求的空闲分区。 优点：该算法能使内存中的空闲分区分布得更均匀，从而减少了查找空闲分区时的开销。 最佳适应算法 该算法总是把能满足要求、又是最小的空闲分区分配给作业，避免大材小用，该算法要求将所有的空闲分区按其容量以从小到大的顺序形成一空闲分区链。 缺点：每次分配后所切割下来的剩余部分总是最小的，这样，在存储器中会留下许多难以利用的碎片。 最坏适应算法 最坏适应算法选择空闲分区的策略正好与最佳适应算法相反：它在扫描整个空闲分区或链表时，总会挑选一个最大的空闲区，从中切割一部分存储空间给作业使用。该算法要求，将所有的空闲分区，按其容量以大到小的顺序形成一空闲分区链。查找时，只要看第一个分区能否满足作业要求即可。 优点：可使剩下的空闲区不至于太小，产生碎片的可能性最小，对中小作业有利，同时，最坏适应算法查找效率很高。 缺点：导致存储器中缺乏大的空闲分区 三、数据结构 为了实现动态分区分配算法，系统中配置了相应的数据结构，用以描述空闲分区和已分配分区的情况，常用的数据结构有空闲分区表和空闲分区链 流程图 『C程序设计』读书笔记 关键字：c语言 原作者姓名：loose_went 文章原出处：https://www.wendangku.net/doc/8a17362107.html, 写在前面： 《C程序设计》可以说是一本再基础不过的编程书了，但每读一遍的感觉却都是不同的，可以说，每读一遍，都会有很多新的收获。真所谓老书再读，回味无穷啊！此笔记是《C程序设计》谭浩强编著，清华大学出版社出版。除了将书中的重点知识点记下来外，也加入了我对知识点的理解，我想这一点是读书笔记的重要性所在。 第一章概述第二章数据类型、运算符与表达式 第三章最简单的ｃ程序设计第四章逻辑运算和判断选取控制 第五章循环控制第六章数组 第七章函数第八章预编译处理 第九章指针第十章结构体与共用体 第十一章位运算第十二章文件 第一章概述 1． C语言的特点 ①语言简洁、紧凑，使用方便、灵活。共有３２个关键字，９种控制语句。 ②运算符丰富，公有３４种运算符。 ③数据结构丰富，数据类型有：整型、实型、字符型、数组、指针、结构体、共用体等。 ④具有结构化的控制语句（如if…else、while、do…while、switch、for） ⑤语法限制不太严格，程序设计自由度大。 ⑥允许直接访问物理地址，能进行位（bit）操作，可以直接对硬件操作。 ⑦生成目标代码质量高，程序执行效率高。 ⑧可移植性好。 2． C语言的用途 C虽不擅长科学计算和管理领域，但对操作系统和系统实用程序以及对硬件进行操作方面，C有明显的优势。现在很多大型应用软件也用Ｃ编写。 Top of Page 第二章数据类型、运算符与表达式 1． C的数据类型 C的数据类型包括：整型、字符型、实型或浮点型（单精度和双精度）、枚举类型、数组类型、结构体类型、共用体类型、指针类型和空类型。 2．常量与变量 常量其值不可改变，符号常量名通常用大写。变量其值可以改变，变量名只能由字母、数字和下划线组成，且第一个字符必须为字母或下划线。否则为不合法的变量名。变量在编译时为其分配相应存储单元。 3．整型数据 整型常量的表示方法：十进制不用说了，八进制以0开头，如0123，十六进制以0x开头，如0x1e。整型变量分为：基本型（int）、短整型（short int）、长整型（long int）和无符号型。不同机器上各类数据所占内存字节数不同，一般int型为２个字节，long型为4个字节。 4．实型数据 实型常量表示形式：十进制形式由数字和小数点组成（必须有小数点），如：0.12、.123、123.、0.0等。指数形式如123e3代表123×10的三次方。 实型变量分为单精度（float）和双精度（double）两类。在一般系统中float型占4字节，7位有效数字，double型占8字节，15~16位有效数字。 5．字符型数据 字符变量用单引号括起来，如'a','b'等。还有一些是特殊的字符常量，如'\n','\t'等。分别代表换行和横向跳格。 字符变量以char 来定义，一个变量只能存放一个字符常量。 字符串常量是由双引号括起来的字符序列。这里一定要注意'a'和"a"的不同，前者为字符常量，后者为字符串常量，c规定：每个字符串的结尾加一个结束标志'\0'，实际上"a"包含两个字符：'a'和'\0'。 6．数值型数据间的混合运算 整型、字符型、实型数据间可以混合运算，运算时不同类型数据要转换成同一类型再运算，转换规则： char,short -> int -> unsigned -> long -> double <- float 7．运算符和表达式 c运算符包括： 算数运算符（+ - * / % ） 关系运算符（ > < == >= <= != ） 动态分配内存算法以及源程序讲解 整体思路： 动态分区管理方式将内存除操作系统占用区域外的空间看成一个大的空闲区。当作业要求装入内存时，根据作业需要内存空间的大小查询内存中的各个空闲区，当从内存空间中找到一个大于或等于该作业大小的内存空闲区时，选择其中一个空闲区，按作业需求量划出一个分区装人该作业，作业执行完后，其所占的内存分区被收回，成为一个空闲区。如果该空闲区的相邻分区也是空闲区，则需要将相邻空闲区合并成一个空闲区。 设计所采用的算法： 采用最优适应算法，每次为作业分配内存时，总是把既能满足要求、又是最小的空闲分区分配给作业。但最优适应算法容易出现找到的一个分区可能只比作业所需求的长度略大一点的情行，这时，空闲区分割后剩下的空闲区就很小以致很难再使用，降低了内存的使用率。为解决此问题，设定一个限值minsize，如果空闲区的大小减去作业需求长度得到的值小于等于minsize，不再将空闲区分成己分分区和空闲区两部分，而是将整个空闲区都分配给作业。 内存分配与回收所使用的结构体： 为便于对内存的分配和回收，建立两张表记录内存的使用情况。一张为记录作业占用分区的“内存分配表”，内容包括分区起始地址、长度、作业名/标志（为0时作为标志位表示空栏目）；一张为记录空闲区的“空闲分区表”，内容包括分区起始地址、长度、标志（0表空栏目，1表未分配）。两张表都采用顺序表形式。 关于分配留下的内存小碎片问题： 当要装入一个作业时，从“空闲分区表”中查找标志为“1”（未分配）且满足作业所需内存大小的最小空闲区，若空闲区的大小与作业所需大小的差值小于或等于minsize，把该分区全部分配给作业，并把该空闲区的标志改为“0”（空栏目）。同时，在已分配区表中找到一个标志为“0”的栏目登记新装人作业所占用分区的起始地址，长度和作业名。若空闲区的大小与作业所需大小的差值大于minsize。则把空闲区分成两部分，一部分用来装入作业，另外一部分仍为空闲区。这时只要修改原空闲区的长度，且把新装人的作业登记到已分配区表中。 内存的回收： 在动态分区方式下回收内存空间时，先检查是否有与归还区相邻的空闲区（上邻空闲区， 网络通讯中数据大小端的问题： 大端模式：高位字节放在内存的低地址端，即该值的起始地址；低位字节排放在内存的高地址端。 小端模式：低位字节放在内存的低地址端，即该值的起始地址；高位字节放在内存的高地址端。 数组的名字是一个常量指针，如X【2】，X是一个常量指针，没有分配的内存。 数据存在存储空间，数值不存在。 在C语言里，指针可以访问到任何地方，但是对不应该访问的地址进行访问没有意义，也可能会禁止读写。 函数的接口类型，可变参数的类型和执行跳转： C语言的函数名可以看做一个地址常量（和数组一样）。 系统的堆栈：堆和栈的第一个区别就是申请方式不同：栈（英文名称是stack）是系统自动分配空间的，例如我们定义一个char a；系统会自动在栈上为其开辟空间。而堆（英文名称是heap）则是程序员根据需要自己申请的空间，例如malloc（10）；开辟十个字节的空间。由于栈上的空间是自动分配自动回收的，所以栈上的数据的生存周期只是在函数的运行过程中，运行后就释放掉，不可以再访问。而堆上的数据只要程序员不释放空间，就一直可以访问到，不过缺点是一旦忘记释放会造成内存泄露。、 、 预处理操作： 宏定义：#define M 3; #define M(x,y) 2*x+y; 预处理对宏的处理，分为3类： 预处理“标识符”的展开； 预处理“标识符”的判断； 预处理“标识符”的文本替换。 #if 0 。。。。 #endif 用作代码注释。 基础类型重定义：一个C程序在PC上开发，逻辑验证正确后，下需要移植到某个嵌入式系统中，但是它们对应的int的位宽定义不同，目标系统是X86时，编译器将其看做32位，而目标系统为嵌入式系统的时候，编译器将其看作16位（对应的32位为long关键词）。这种情况，就需要进行基础类型的重定义： #define _TARGET_X86_SYSYTEM 0 #define _TARGET_DEV_SYSYTEM 1 #define _TARGET_SYSYTEM _TARGET_X86_SYSYTEM #if(_TARGET_SYSYTEM = _TARGET_X86_SYSYTEM) Typedef signed int _i32 Typedef unsigned int _u32 #elif(_TARGET_SYSYTEM = _TARGET_DEV_SYSYTEM) 1.内存分配方式 内存分配方式有三种： [1]从静态存储区域分配。内存在程序编译的时候就已经分配好，这块内存在程序的整个运行期间都存在。例如全局变量，static变量。 [2]在栈上创建。在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集中，效率很高，但是分配的内存容量有限。 [3]从堆上分配，亦称动态内存分配。程序在运行的时候用malloc或new申请任意多少的内存，程序员自己负责在何时用free或delete释放内存。动态内存的生存期由程序员决定，使用非常灵活，但如果在堆上分配了空间，就有责任回收它，否则运行的程序会出现内存泄漏，频繁地分配和释放不同大小的堆空间将会产生堆内碎块。 2.程序的内存空间 一个程序将操作系统分配给其运行的内存块分为4个区域，如下图所示。 一个由C/C++编译的程序占用的内存分为以下几个部分, 1、栈区（stack）— 由编译器自动分配释放，存放为运行函数而分配的局部变量、函数参数、返回数据、返回地址等。其操作方式类似于数据结构中的栈。 2、堆区（heap） — 一般由程序员分配释放，若程序员不释放，程序结束时可能由OS回收。分配方式类似于链表。 3、全局区（静态区）（static）—存放全局变量、静态数据、常量。程序结束后由系统释放。 4、文字常量区—常量字符串就是放在这里的。程序结束后由系统释放。 5、程序代码区—存放函数体（类成员函数和全局函数）的二进制代码。 下面给出例子程序， int a = 0; //全局初始化区 char *p1; //全局未初始化区 int main() { int b; //栈 char s[] = "abc"; //栈 char *p2; //栈 char *p3 = "123456"; //123456在常量区，p3在栈上。 static int c =0;//全局（静态）初始化区 第三部分 1.标识符 标识符要求： (1)标识符是由字符、数字、下划线组成，但必须是以字母、下划线开头，不能以数字开头。 (2)标识符必须区分大小写 (3)标识符的长度不能超过8位。 (4)不能用C语言系统中的关键字作为标识符(if while)。预定义标识符(printf scanf )。用户定义标识符 2.常量 在程序运行过程中，其值不能被改变的量称为常量。 #include "stdio.h" #define PI 3.14159 main() { float r,s; r=5.0; s=PI*r*r; printf("s=%f\n",s); } 3.变量 变量代表一个有名字的、具有特定属性的一个存储单元。它用来存放数据，也就是存放变量的值。在程序运行期间，变量的值是可以改变的。 变量必须先定义后使用，在定义时指定该变量的名字和类型。一个变量应该有一个名字，以便被引用。请注意区分变量名和变量值。例如a=3，a是变量名，3是变量的值。即存放在变量a的内存单元中的数据，变量名实际上是一个名字代表的一个存储地址。在对程序编译连接时由编译系统给每一个变量名分配对应的内存地址。从变量中取值，实际上是通过变量名找到相应的内存地址，从该存储单元中读取数据。 n 其值可以改变的量称为变量 n 变量有一个名字，即标识符 n 变量在存储器中占据一定的存储单元 n 变量占据存储空间的大小由其类型决定 n 程序中的变量参与计算时,从这个变量所占据的存储单元里取出存储的数据的值 n 变量要“先定义，后使用” 整型数据的分类 分类： 1)signed有符号整型：int基本整型、short短整型、long长整型 2)unsigned无符号整型：unsigned无符号基本整型、unsigned short 无符号短整型、unsigned long长整型 注意：若要表示一个长整型常量，则应该在一个证整型常量后面加一个字母后缀l或者L。例如：long i; i=32768l 无论是短整型还是长整型，都别识别为有符号整数，无符号整数应该在数字末尾加上“u” （操作系统课程设计） 连续动态分区内存 管理模拟实现 目录 《操作系统》课程设计 (1) 引言 (3) 课程设计目的和内容 (3) 需求分析 (3) 概要设计 (3) 开发环境 (4) 系统分析设计 (4) 有关了解内存管理的相关理论 (4) 内存管理概念 (4) 内存管理的必要性 (4) 内存的物理组织 (4) 什么是虚拟内存 (5) 连续动态分区内存管理方式 (5) 单一连续分配（单个分区) (5) 固定分区存储管理 (5) 可变分区存储管理（动态分区） (5) 可重定位分区存储管理 (5) 问题描述和分析 (6) 程序流程图 (6) 数据结构体分析 (8) 主要程序代码分析 (9) 分析并实现四种内存分配算法 (11) 最先适应算 (11) 下次适应分配算法 (13) 最优适应算法 (16) 最坏适应算法......................................................... (18) 回收内存算法 (20) 调试与操作说明 (22) 初始界面 (22) 模拟内存分配 (23) 已分配分区说明表面 (24) 空闲区说明表界面 (24) 回收内存界面 (25) 重新申请内存界面..........................................................26. 总结与体会 (28) 参考文献 (28) 引言 操作系统是最重要的系统软件，同时也是最活跃的学科之一。我们通过操作系统可以理解计算机系统的资源如何组织，操作系统如何有效地管理这些系统资源，用户如何通过操作系统与计算机系统打交道。 存储器是计算机系统的重要组成部分，近年来，存储器容量虽然一直在不断扩大，但仍不能满足现代软件发展的需要，因此，存储器仍然是一种宝贵而又紧俏的资源。如何对它加以有效的管理，不仅直接影响到存储器的利用率，而且还对系统性能有重大影响。而动态分区分配属于连续分配的一种方式，它至今仍在内存分配方式中占有一席之地。 课程设计目的和内容： 理解内存管理的相关理论，掌握连续动态分区内存管理的理论；通过对实际问题的编程实现，获得实际应用和编程能力。 编写程序实现连续动态分区内存管理方式，该程序管理一块虚拟内存，实现内存分配和回收功能。分析并实现四种内存分配算法，即最先适应算法，下次最先适应算法，最优适应算法，最坏适应算法。内存分配算法和回收算法的实现。 需求分析 动态分区分配是根据进程的实际需要，动态地为之分配内存空间。在实现动态分区分配时，将涉及到分区分配中所用的数据结构、分区分配算法和分区的分配和回收操作这样三个问题。常用的数据结构有动态分区表和动态分区链。在对数据结构有一定掌握程度的情况下设计合理的数据结构来描述存储空间，实现分区存储管理的内存分配功能，应该选择最合适的适应算法（首次适应算法，最佳适应算法，最后适应算法，最坏适应算法），在动态分区存储管理方式中主要实现内存分配和内存回收算法，在这些存储管理中间必然会有碎片的产生，当碎片产生时，进行碎片的拼接等相关的内容 概要设计 本程序采用机构化模块化的设计方法，共分为四大模块。 ⑴最先适应算法实现 从空闲分区表的第一个表目起查找该表，把最先能够满足要求的空闲区分配 给作业，这种方法目的在于减少查找时间。为适应这种算法，空闲分区表（空闲 区链）中的空闲分区要按地址由低到高进行排序。该算法优先使用低址部分空闲 区，在低址空间造成许多小的空闲区，在高地址空间保留大的空闲区。 ⑵下次适应分配算法实现 该算法是最先适应算法的变种。在分配内存空间时，不再每次从表头（链首） 开始查找，而是从上次找到空闲区的下一个空闲开始查找，直到找到第一个能满 足要求的的空闲区为止，并从中划出一块与请求大小相等的内存空间分配给作 业。该算法能使内存中的空闲区分布得较均匀。动态内存分配
C语言的代码内存布局具体解释
《动态分配内存与数据结构》课后习题
c语言中动态内存申请与释放的简单理解
十速单片机TM57MA15---C语言编程应用笔记 [兼容模式]
C语言程序设计笔记
程序设计基础C备课笔记
动态内存分配(C语言)
C程序设计 读书笔记
动态分配内存管理源代码及讲解
c语言学习笔记
C语言程序的内存分配方式
C语言程序设计学习笔记(3)
操作系统课程设计--连续动态分区内存管理模拟实现