C/C++快速读写磁盘数据的方法

最新推荐文章于 2024-07-14 23:36:06 发布

lusic01

最新推荐文章于 2024-07-14 23:36:06 发布

阅读量1.5w

点赞数 4

快速读写磁盘数据的方法：

1.块读取：一下子将数据读取到内存的（无论是文本还是二进制)，而不是一行行的读取。

FILE *fp;
fp=fopen("bigfile.txt","rb");
int strNum;
char buffer[100];//每块大小
while((strNum=fread(buffer,sizeof(char),100,fp)>0)//不足100个字节时，返回实际读取个数
{
//对该块进行操作

}

fread是一个函数，它从文件流中读数据，最多读取count个项，每个项size个字节，如果调用成功返回实际读取到的项个数（小于或等于count），如果不成功或读到文件末尾返回 0。

size_t fread( void *buffer, size_t size, size_t count, FILE *stream )
buffer 是读取的数据存放的内存的指针（可以是数组，也可以是新开辟的空间，buffer就是一个索引）
size 是每次读取的字节数
count 是读取次数

strean 是要读取的文件的指针

size_t fwrite(const void* buffer, size_t size, size_t count, FILE* stream);
-- buffer:指向数据块的指针
-- size:每个数据的大小，单位为Byte(例如：sizeof(int)就是4)
-- count:数据个数
-- stream:文件指针

fseek

fseek的用途：控制件指针偏移。

函数原型：int fseek(FILE *stream, long offset, int fromwhere)

参数1是文件流指针，参数2是偏移量大小，参数3是偏移模式，通常为1：SEEK_CUR（文件当前位置） SEEK_SET（文件开头） SEEK_END（文件结尾）

请看例子：

[cpp] view plain copy

1 #include <stdio.h>
2 #include <stdlib.h>
3 #include <string.h>
4 int main()
5 {
6
7 char buf[20];
8 char msg[] = "hello world!";
9 FILE *fp = fopen("a.txt", "w+");
10
11 if(fp == NULL) {
12 perror("a.txt:");
13 exit(EXIT_FAILURE);
14 }
15 fseek(fp, 0, SEEK_SET);
16 fwrite(msg, 1, strlen(msg) + 1, fp);
17 fseek(fp, 0, SEEK_SET);
18 fread(buf, 1, strlen(msg) + 1, fp);
19 printf("%s\n", buf);
20 return 0;
21 }

首先看第9行，我们打开一个文本，并且设置为读写模式"w+"。这就意味着读写都用的是一个文件指针了。

注意第15行和第17行的fseek。在16行执行之后，字符指针去到了末尾，因此要用fseek让指针回到文件的开始位置，SEEK_SET就是回到文件开头，并且偏移量为0。

去掉16行，18行读的时候就从结尾开始了，这当然不是我们的本意。

当然，如果读写不共用同一个文件指针，那么久没有必要用fseek了。

下面的实例演示了 fseek() 函数的用法。

#include <stdio.h>

int main ()
{
   FILE *fp;

   fp = fopen("file.txt","w+");
   fputs("This is runoob.com", fp);
  
   fseek( fp, 7, SEEK_SET );
   fputs(" C Programming Langauge", fp);
   fclose(fp);
   
   return(0);
}

让我们编译并运行上面的程序，这将创建文件 file.txt，它的内容如下。最初程序创建文件和写入 This is runoob.com，但是之后我们在第七个位置重置了写指针，并使用 puts() 语句来重写文件，内容如下：

This is C Programming Langauge

==============================================================================================================================================================================================================================================================================================================

在阅读代码时，遇到了很早之前用过的fseek(),很久没有用了，有点陌生，写出来以便下次查阅。

函数功能是把文件指针指向文件的开头，需要包含头文件stdio.h

fseek
  函数名: fseek
  功能: 重定位流上的文件指针
  用法: int fseek(FILE *stream, long offset, int fromwhere);
  描述: 函数设置文件指针stream的位置。如果执行成功，stream将指向以fromwhere为基准，偏移offset个字     节的位置。如果执行失败(比如offset超过文件自身大小)，则不改变stream指向的位置。
  返回值: 成功，返回0，否则返回其他值。
  fseek position the file position pointer for the file referenced by stream to the byte location calculated by offset.
  程序例:

[cpp] view plain copy

#include <stdio.h>
long filesize(FILE *stream);
int main(void)
{
FILE *stream;
stream = fopen("MYFILE.TXT", "w+");
fprintf(stream, "This is a test");
printf("Filesize of MYFILE.TXT is %ld bytes\n", filesize(stream));
fclose(stream);
return 0;
}
long filesize(FILE *stream)
{
long curpos, length;
curpos = ftell(stream);
fseek(stream, 0L, SEEK_END);
length = ftell(stream);
fseek(stream, curpos, SEEK_SET);
return length;
}

  int fseek( FILE *stream, long offset, int origin );
  第一个参数stream为文件指针
  第二个参数offset为偏移量，整数表示正向偏移，负数表示负向偏移
  第三个参数origin设定从文件的哪里开始偏移,可能取值为：SEEK_CUR、 SEEK_END 或 SEEK_SET
  SEEK_SET：文件开头
  SEEK_CUR：当前位置
  SEEK_END：文件结尾
  其中SEEK_SET,SEEK_CUR和SEEK_END和依次为0，1和2.
  简言之：
  fseek(fp,100L,0);把fp指针移动到离文件开头100字节处；
  fseek(fp,100L,1);把fp指针移动到离文件当前位置100字节处；
  fseek(fp,100L,2);把fp指针退回到离文件结尾100字节处。
  使用实例：

[cpp] view plain copy

#include <stdio.h>
#define N 5
typedef struct student {
long sno;
char name[10];
float score[3];
} STU;
void fun(char *filename, STU n)
{
FILE *fp;
fp = fopen(filename, "rb+");
fseek(fp, -1L*sizeof(STU),SEEK_END);
fwrite(&n, sizeof(STU), 1, fp);
fclose(fp);
}
void main()
{
STU t[N]={ {10001,"MaChao", 91, 92, 77}, {10002,"CaoKai", 75, 60, 88},
{10003,"LiSi", 85, 70, 78}, {10004,"FangFang", 90, 82, 87},
{10005,"ZhangSan", 95, 80, 88}};
STU n={10006,"ZhaoSi", 55, 70, 68}, ss[N];
int i,j; FILE *fp;
fp = fopen("student.dat", "wb");
fwrite(t, sizeof(STU), N, fp);
fclose(fp);
fp = fopen("student.dat", "rb");
fread(ss, sizeof(STU), N, fp);
fclose(fp);
printf("\nThe original data :\n\n");
for (j=0; j<N; j++)
{
printf("\nNo: %ld Name: %-8s Scores: ",ss[j].sno, ss[j].name);
for (i=0; i<3; i++)

[cpp] view plain copy

printf("%6.2f ", ss[j].score[i]);
printf("\n");
}
fun("student.dat", n);
printf("\nThe data after modifing :\n\n");
fp = fopen("student.dat", "rb");
fread(ss, sizeof(STU), N, fp);
fclose(fp);
for (j=0; j<N; j++)
{
printf("\nNo: %ld Name: %-8s Scores: ",ss[j].sno, ss[j].name);
for (i=0; i<3; i++)

[cpp] view plain copy

printf("%6.2f ", ss[j].score[i]);
printf("\n");
}

1函数简介

函数名

: ftell

头文件

: <stdio.h>

功能

: 返回当前文件位置，也就是说返回FILE 指针当前位置。

函数原型

: long ftell(FILE *stream);

函数功能

：函数 ftell() 用于得到文件位置指针当前位置相对于文件首的偏移字节数。在随机方式存取文件时，由于文件位置频繁的前后移动，程序不容易确定文件的当前位置。使用fseek函数后再调用函数ftell()就能非常容易地确定文件的当前位置。

2调用示例

ftell(fp);利用函数 ftell() 也能方便地知道一个文件的长。如以下语句序列： fseek(fp, 0L,SEEK_END); len =ftell(fp)+1; 首先将文件的当前位置移到文件的末尾，然后调用函数ftell()获得当前位置相对于文件首的位移，该位移值等于文件所含字节数。

======================================================================

2.异步的IO，创建多线程，或者使用重叠IO,IO复用，异步的事件回调通知机制（可以用事件对象，信号驱动来实现)。

线程通常用来执行并行计算，为大量阻塞操作增加并发度。

计算机执行计算任务时，通常还需要与各种IO设备交互，这些设备和CPU、内存比起来慢几个数量级。大部分web应用的瓶颈都在于IO操作，如读写磁盘，网络操作，读取数据库。使用怎样的策略等待这段时间，就成了改善性能的关键。

线程怎么样？

如果大量创建线程，在线程数大于CPU数时，线程会有额外的调度开销，所以线程数太多反而会使计算性能下降。而且多线程又免不了就需要加锁。程序自己维护锁的状态，开发成本很高而且还不易调试。

基于回调的异步IO

这些时候，除了创建大量线程以外，还可以使用异步IO来完成同样的功能。如node.js，就是将所有的IO操作强制异步进行。异步IO原理上很简单，用户线程某一刻发起一个请求（对于IO来说通常只有读和写2种），在IO设备准备好的时候会回调用户指定的过程，异步IO并不阻塞用户线程，可以使用少量线程完成相同的功能。异步IO关键的优势在于，它去掉了处理单个请求中那些无意义的等待时间。虽然单位时间内处理的请求没有变化，但是每个请求的处理时间却减少了。不过异步IO用多了一点也不美，由于它要求程序必须遵从请求/回调的方式，所以一个完整的过程可能被分割为多个片断，程序架构非常难以控制。这种情况叫做回调地狱。

既不用基于回调的异步IO，又不大量使用线程，这时候可以引入轻量级线程解决。

轻量级线程
轻量级线程实际上是伪线程，它是由用户来控制“线程”切换的。当一个操作需要等待异步完成时，它告诉调度器，暂停自己的执行，切换到另一个任务。当IO事件发生时，再从该断点恢复执行。在windows上，系统提供了fiber，Linux上也可以使用ucontext轻松地实现协程。Python也实现了轻量级线程，著名的网络游戏EVE服务端就是使用它来实现的。其它一些语言的continuation机制也可以实现类似功能。
虽然有这么多轻量级线程的实现，但几乎都要自己进行调度，使用起来还是有相当难度的。每个“线程”中不能有阻塞操作，否则会使整个机制失效。

更好的方案
erlang提供了相对较好的解决方案。因为erlang在虚拟机上实现了轻量级线程和调度器，并且成为语言的基础。erlang里面用户并不控制线程，而是创建大量的轻量级线程，erlang里面称为进程（process）。每个进程都可代表一个主动对象，它有事件循环，各个进程间通过消息来通讯。一个进程向另一进程发送消息后，可以进入接收状态，这时候真正的线程会把执行权切换到其它进程，如果另一进程得到执行权，如果它回复了消息，再经过一些执行权的切换以后，原来发送消息的进程得到执行权，它就可以收到消息了，这个复杂的过程可能只需要一个真正意义上的线程就可以完成，程序的编写也是使用同步的方式，完全感觉不到底层的切换，你唯一需要的就是毫无顾忌地创建进程。erlang底层通常只需要1个线程就可以完成这些复杂的工作，因为没有一个进程阻塞。在多CPU机器上，可以选择创建和CPU数目相等的进程数来提高效率。
erlang自身是完美的，但它却无法避免使用一些“不完美”的库。比如它要调用MySQL，阻塞查询数据库，总不能把erlang虚拟机完全阻死吧？这个时候可以有2种选择，一种是不使用mysql的API，而是用erlang来实现mysql远程调用协议；另一种是写一个mysql调用程序，它和erlang通过网络或其它方式来通讯，接收查询指令，执行查询，并发回数据，这在erlang里面称为c-node方式。

erlang里面是怎么把这些复杂的异步调用都屏蔽掉的？留给我们的竟然只是简单的同步操作方式？因为它底层就是使用异步机制，用异步操作封装了整个系统，开放给用户的是轻量级线程，完全是同步操作方式（从这里看好像和node.js差不多对不对），用户不需要显式地请求线程切换，erlang虚拟机会以函数为单位进行调度，由于erlang不使用循环语句，代之以递归，所以即使是一个无限递归也不会导致其它进程不能获得执行权，erlang里面进程的调度是软实时的，它保证所有进程都能尽量平等地获得执行时间。

事实上，对于其它语言来说，完全写成异步也是可行的。但是问题在于，在语言层面，程序员来告诉虚拟机“这两个操作同时进行”是很麻烦是事。大多数人懒得去用。

线程通常用来执行并行计算，为大量阻塞操作增加并发度。

线程怎么样？

基于回调的异步IO

既不用基于回调的异步IO，又不大量使用线程，这时候可以引入轻量级线程解决。

3.优化分析文件的算法和尽量延后分析，分析算法里面频繁的申请字符串内存和释放字符串内存，尽量用指针解析出来，分析文件的内容可以延期到使用的时候才分析。

如果不注意，不小心，读取文件的主要性能消耗将会在这里，所以需要特别高的重视。

4.使用内存文件映射, window是CreateFileMapping，MapViewOfFile，UnmapViewOfFile，CloseHandle；linux是用mmap,munmap,msync,free。

内存文件映射的使用：

(1)大数据量文件的读取，有效的提高磁盘和内存间数据通信的性能；

(2）进程间快速的共享内存，实现进程间高效的通信。

内存映射文件性能高于普通IO的原因：

内存文件映射和普通的文件IO都是要通过文件系统和硬盘驱动拷贝数据到内存中，内存文件映射数据越大越快主要是：

（1）实际拷贝数据前，需要建立映射信息，内存文件映射已经提前准备好了映射关系，内核调度好了进程内的内存块，交付给内核进行了预先处理，内存文件映射会消耗掉一些时间。

（2）实际拷贝时候，内存文件映射将磁盘数据直接拷贝到用户进程内存空间只进行了一次拷贝，而普通的IO是先将文件拷贝到内核缓存空间，然后才拷贝到用户进程内存空间，进行了两次拷贝。

下面是一个使用普通的fread函数和内存映射文件函数，读取不同大小的磁盘文件的性能分析表：

文件大小(KB)	I/O函数读取时间(ms)	内存映射读取时间(ms)
5.56	0	47
56	31	47
508	94	47
4597.76	811	47
47820.8	7348	78
209920	31403	218
510976	72977	436

综合：当读写磁盘文件的数据较小(少于1MB)时候，使用内存文件映射和普通IO是差异很小的，所以建议使用普通IO就可以了；当很多文件的大小在几十MB, 几百MB, 或者1GB以上的文件数据需要进行较频繁的访问，或者一开始需要全部加载这些大文件的时候，那么就需要考虑使用内存文件映射了。

windows 纤程(fiber) 实现的协程

参考云风的协程库实现：https://github.com/cloudwu/coroutine

云风的协程为非对称的共享栈协程

以下为fiber实现的非对称协程：

环境:win7、VS2013

头文件: (coroutine.h)

[cpp] view plain copy

#ifndef __COROUTINE__H__
#define __COROUTINE__H__
#define COROUTINE_DEAD 0
#define COROUTINE_READY 1
#define COROUTINE_RUNNING 2
#define COROUTINE_SUSPEND 3
typedef struct schedule schedule;
typedef void(*coroutine_func)(schedule *s, void *ud);
schedule *coroutine_open();
void coroutine_close(schedule *s);
int coroutine_new(schedule *s, coroutine_func *, void *ud);
void coroutine_resume(schedule *s, int id);
void coroutine_yield(schedule *s);
int coroutine_status(schedule *s, int id);
int coroutine_running(schedule *s);
#endif

源文件:(coroutine.c)

[cpp] view plain copy

#include <stdio.h>
#include <stdlib.h>
#include <windows.h>
#include <assert.h>
#include "coroutine.h"
/* windows fiber版本的协程yield的时候直接切换到主协程(main)，
而不是swapcontext的切换到上次运行协程,但最后达到的结果却一样
*/
// 默认容量
#define DEFAULT_CAP 8
// 堆栈大小
#define INIT_STACK 1048576 //(1024*1024)
typedef struct schedule schedule;
typedef struct coroutine coroutine;
typedef struct coroutine_para coroutine_para;
struct schedule
{
int cap; // 容量
int conums;
int curID; // 当前协程ID
LPVOID main;
coroutine **co;
};
struct coroutine
{
schedule *s;
void *ud;
int status;
LPVOID ctx;
coroutine_func func;
};
static int co_putin(schedule *s, coroutine *co)
{
if (s->conums >= s->cap)
{
int id = s->cap;
s->co = realloc(s->co, sizeof(coroutine *) * s->cap * 2);
memset(&s->co[s->cap], 0, sizeof(coroutine *) * s->cap);
s->co[s->cap] = co;
s->cap *= 2;
++s->conums;
return id;
}
else
{
for (int i = 0; i < s->cap; i++)
{
int id = (i + s->conums) % s->cap;
if (s->co[id] == NULL)
{
s->co[id] = co;
++s->conums;
return id;
}
}
}
assert(0);
return -1;
}
static void co_delete(coroutine *co)
{
//If the currently running fiber calls DeleteFiber, its thread calls ExitThread and terminates.
//However, if a currently running fiber is deleted by another fiber, the thread running the
//deleted fiber is likely to terminate abnormally because the fiber stack has been freed.
DeleteFiber(co->ctx);
free(co);
}
schedule *coroutine_open()
{
schedule *s = malloc(sizeof(schedule));
s->cap = DEFAULT_CAP;
s->conums = 0;
s->curID = -1;
s->co = malloc(sizeof(coroutine *) * s->cap);
memset(s->co, 0, sizeof(coroutine *) * s->cap);
s->main = ConvertThreadToFiberEx(NULL, FIBER_FLAG_FLOAT_SWITCH);
return s;
}
void coroutine_close(schedule *s)
{
for (int i = 0; i < s->cap; i++)
{
coroutine *co = s->co[i];
if (co) co_delete(co);
}
free(s->co);
s->co = NULL;
free(s);
}
void __stdcall coroutine_main(LPVOID lpParameter)
{
schedule* s = (schedule*)lpParameter;
int id = s->curID;
coroutine *co = s->co[id];
(co->func)(s, co->ud);
s->curID = -1;
--s->conums;
s->co[id] = NULL;
//co_delete(co);
SwitchToFiber(s->main);
}
int coroutine_new(schedule *s, coroutine_func *func, void *ud)
{
coroutine *co = malloc(sizeof(coroutine));
co->s = s;
co->status = COROUTINE_READY;
co->func = func;
co->ud = ud;
int id = co_putin(s, co);
co->ctx = CreateFiberEx(INIT_STACK, 0, FIBER_FLAG_FLOAT_SWITCH, coroutine_main, s);
co->status = COROUTINE_READY;
return id;
}
void coroutine_resume(schedule *s, int id)
{
assert(id >= 0 && id < s->cap);
if (id < 0 || id >= s->cap) return;
coroutine *co = s->co[id];
if (co == NULL) return;
switch (co->status)
{
case COROUTINE_READY:case COROUTINE_SUSPEND:
co->status = COROUTINE_RUNNING;
s->curID = id;
SwitchToFiber(co->ctx);
if (!s->co[id]) co_delete(co);
break;
default:
assert(0);
break;
}
}
void coroutine_yield(schedule *s)
{
int id = s->curID;
assert(id >= 0 && id < s->cap);
if (id < 0) return;
coroutine *co = s->co[id];
co->status = COROUTINE_SUSPEND;
s->curID = -1;
SwitchToFiber(s->main);
}
int coroutine_status(schedule *s, int id)
{
assert(id >= 0 && id < s->cap);
if (id < 0) return;
if (s->co[id] == NULL) {
return COROUTINE_DEAD;
}
return s->co[id]->status;
}
int coroutine_running(schedule *s)
{
return s->curID;
}

测试程序:(main.c)

[cpp] view plain copy

#include "coroutine.h"
void test3(schedule *s, void *ud)
{
int *data = (int*)ud;
for (int i = 0; i < 3; i++)
{
printf("test3 i=%d\n",i);
coroutine_yield(s);
printf("yield co id = %d.\n", *data);
}
}
void coroutine_test()
{
printf("coroutine_test3 begin\n");
schedule *s = coroutine_open();
int a = 11;
int id1 = coroutine_new(s, test3, &a);
int id2 = coroutine_new(s, test3, &a);
while (coroutine_status(s, id1) && coroutine_status(s, id2))
{
printf("\nresume co id = %d.\n",id1);
coroutine_resume(s, id1);
//printf("resume co id = %d.\n", id2);
//coroutine_resume(s, id2);
}
int id3 = coroutine_new(s, test3, &a);
while (coroutine_status(s, id3))
{
printf("\nresume co id = %d.\n", id3);
coroutine_resume(s, id3);
}
printf("coroutine_test3 end\n");
coroutine_close(s);
}
int main()
{
coroutine_test();
return 0;
}

Drecik学习经验分享

转载请注明出处：http://blog.csdn.net/drecik__/article/details/8202023

Windows提供纤程是为了帮助各个公司更快地、正确地将它们的代码从UNIX移植到Windows中。

但我们要记住，自己在Windows上设计程序时，应该避免使用纤程，而使用Windows提供的线程机制。

首先要了解的是，纤程是在用户模式下实现的，内核对纤程一无所知，内核会根据我们定义的算法来对纤程进行调度。

一个线程可以包含一个或多个纤程。对内核而言它会对线程进行抢占式调度来让线程执行代码，但是，线程一次只能执行一个纤程代码（由我们决定哪个纤程）。

使用纤程的步骤：

通过函数ConvertThreadToFiber将一个已有的线程转化为一个纤程：

[cpp] view plain copy

LPVOID      // 返回纤程执行上下文的地址;
ConvertThreadToFiber(
    LPVOID lpParameter
    );

该函数会创建一个纤程的执行上下文，有下面元素构成：

一个用户自定义的值，即传入的lpParameter参数
结构化异常处理链的头
纤程栈的顶部和底部的内存地址
某些CPU寄存器，其中包括栈指针，指令指针以及其他寄存器
默认情况下CPU浮点状态信息不属于CPU寄存器一部分，不会每个纤程都维护一份，如果纤程需要执行浮点操作，则需要使用函数ConvertThreadToFiberEx来转换：

[cpp] view plain copy

LPVOID
ConvertThreadToFiberEx(
    LPVOID lpParameter,
    DWORD dwFlags           // 传入FIBER_FLAG_FLOAT_SWITCH标志;
    );

除非打算创建更多的纤程，并让它们在同一个线程中运行，否则没有理由将一个线程转换为纤程，创建另一个纤程，当前线程使用CreateFiber或CreateFiberEx：

[cpp] view plain copy

LPVOID      // 返回纤程执行上下文的地址;
CreateFiber(
    SIZE_T dwStackSize,         // 栈大小，通常为0;
    LPFIBER_START_ROUTINE lpStartAddress,   // 指定纤程函数的地址;
    LPVOID lpParameter          // 用户自定义值，会保存到纤程执行上下文;
    );

LPVOID
CreateFiberEx(
    SIZE_T dwStackCommitSize,   // 指定一开始要调拨的物理存储页;
    SIZE_T dwStackReserveSize,  // 预定指定数量的虚拟内存;
    DWORD dwFlags,              // 可以指定需要进行浮点操作，传入FIBER_FLAG_FLOAT_SWITCH标志;
    LPFIBER_START_ROUTINE lpStartAddress,
    LPVOID lpParameter
    );

// 纤程函数的函数原型;
// 该函数不应该返回，如果返回，该线程以及它创建的所有纤程都会立即被销毁;
typedef VOID (WINAPI *PFIBER_START_ROUTINE)(
    LPVOID lpFiberParameter     // 传入用户自定义的值;
    );

CreateFiber(Ex)与ConvertTreadToFiber(Ex)不同之处在于，它创建的纤程不会立即执行，因为当前运行的纤程还在执行，在同一时刻只能执行一个纤程，可以使用SwitchToFiber来让新的纤程执行：

[cpp] view plain copy

VOID
SwitchToFiber(
    LPVOID lpFiber  // 纤程执行上下文地址;
    );

在内部该函数会将正在执行的纤程CPU寄存器保存起来在执行上下文中，然后将要执行纤程的CPU寄存器载入到CPU中，并将新的纤程与线程关联，让线程运行指定的纤程，最后就是载入指令指针，让纤程从上次运行的地方开始执行。

最后可以调用DeleteFiber啦销毁纤程：

[cpp] view plain copy

VOID
DeleteFiber(
    LPVOID lpFiber  // 纤程执行上下文地址;
    );

函数会删除该参数标识的纤程，并释放线程的栈并销毁纤程的执行上下文，如果该纤程与线程正在关联，则会在内部调用ExitThread，从而使线程以及为它创建的纤程都结束。

DeleteFiber通常为一个纤程调用，以删除另一个纤程，与线程不同，线程是最好不要终止另外一个线程。

当所有纤程都被删除，可以调用ConvertFiberToThread(Ex)来解除线程的纤程状态，同时释放最后一块内存块。

如果想知道当先的线程相关联的纤程地址，可以调用GetCurrentFiber，也可以调用GetFiberData返回用户自定义的值。

纤程（Fiber），是微软加入到Windows中，使得UNIX服务器应用程序更好地移植到Windows中。所以本篇真正没有多少应用价值，只是为了使得笔记更加完整。

　　看完本章，感觉纤程是比线程的更小的一个运行单位。可以把一个线程拆分成多个纤程，然后通过人工转换纤程，从而让各个纤程工作。

　　要知道的是人工的转换，不是系统自动切换。因为线程的实现通过Windows内核完成的，因此Windows可以自动对线程进行调度。但是纤程是通过用户模式的代码来实现的，是程序员自己写的算法，内核不知道纤程的实现方式，而是你自己定义的调度算法，因此纤程是“非抢占”的调度方式。

　　还有要知道就是，一个线程可以包含多个纤程。

　　要使用纤程，首先要做的就是把当前线程转换为纤程：

PVOID ConvertThreadToFiber(PVOID pvParam);

　　调用这个函数之后，系统为纤程执行环境分配大概200字节的存储空间，这个执行环境有以下内容构成：

1、用户定义的值，由参数pvParam参数指定。

2、结构化异常处理链头。

3、纤程内存栈的最高和最低地址，当线程转换为纤程的时候，这也是线程的内存栈。

4、各种CPU寄存器信息，比如堆栈指针寄存器，指令指针寄存器等等。

　　默认情况下，x86系统的CPU的浮点数状态信息在纤程看来不属于CPU寄存器，因此会导致在纤程中执行一些相关的浮点运算会破坏数据。为了克服这个缺点，你需要呼叫ConvertThreadToFiberEx函数（Windows Vista及其以上版本中才有），并且传递FIBER_FLAG_FLOAT_SWITCH给它的第2个参数dwFlags：

PVOID ConvertThreadToFiberEx(
PVOID pvParam,
DWORD dwFlags);

　　当呼叫完上述两个函数之后，你就初始化了一个纤程执行环境，该执行环境与线程的执行环境关联，线程转换为纤程，纤程就在线程的内部运行。ConvertThreadToFiber(Ex)函数实际返回纤程的执行环境的内存地址，你稍后会用到这个地址，但是你不能直接读取或写入这个地址，你应该使用系统提供的纤程函数来对这个地址进行操纵。

　　当你的纤程返回或者呼叫ExitThread的时候，你的纤程也随之结束。

　　如果一个线程中只有一个纤程，那么是没有必要将该线程转换为纤程的，只有你打算在同一个线程中再创建一个纤程才有转换的必要。要创建一个纤程，使用CreateFiber函数：

PVOID CreateFiber(
   DWORD dwStackSize,      // 创建新的堆栈的大小，0表示默认大小
   PFIBER_START_ROUTINE pfnStartAddress,      // 纤程函数地址
   PVOID pvParam);      // 传递给纤程函数的参数

　　这个函数创建一个新的堆栈，堆栈的大小由dwStackSize指定。如果传递0给它，就意味着创建一个默认大小的堆栈。

　　如果你打算让一个线程包含多个纤程，而又想花费比较少的空间的话，可以使用CreateFiberEx函数（只有在Windows Vista及其以上版本中才有）：

PVOID CreateFiberEx(
   SIZE_T dwStackCommitSize,      // 堆栈初始提交的大小
   SIZE_T dwStackReserveSize,     // 需要保留的虚拟内存的大小
   DWORD dwFlags,      // 创建旗标
   PFIBER_START_ROUTINE pStartAddress,      // 纤程函数指针
   PVOID pvParam);      // 传递给纤程函数的参数

　　其中，如果传递FIBER_FLAG_FLOAT_SWITCH给dwFlags参数，则表明将浮点信息添加到纤程执行环境。

　　当CreateFiber(Ex)函数创建了一个新的堆栈之后，它分配一个新的纤程执行环境结构并初始化之，用户定义的数据通过pvParam参数被保存，新的堆栈的内存空间的最高和最低地址被保存，纤程函数的地址通过pStartAddress参数被保存。

　　纤程函数的格式必须如下定义：

VOID WINAPI FiberFunc(PVOID pvParam);

　　这个纤程在第一次被调度的时候，纤程函数被调用，其参数pvParam由CreateFiber(Ex)中的pvParam参数指定。在纤程函数中，你可以做你想做的任何事情。

　　像ConvertThreadToFiber(Ex)函数一样，CreateFiber(Ex)也返回纤程执行环境的内存地址，这个内存地址就像句柄一样，直接标识着一个纤程。

　　当你使用CreateFiber(Ex)函数创建一个纤程之后，该纤程不会执行，因为系统不会自动调度它。你必须调用函数SwitchToFiber来告诉系统你想要哪个纤程执行：

VOID SwitchToFiber(PVOID pvFiberExecutionContext);

　　SwitchToFiber函数的参数是一个纤程执行环境的内存地址，该地址由ConverThreadToFiber(Ex)或CreateFiber(Ex)返回。

　　SwitchToFiber函数内部的执行步骤如下：

1、保存当前的CPU寄存器信息，这些信息保存在正在运行的纤程的执行环境中。

2、从将要执行的纤程的执行环境中加载上次保存的CPU寄存器信息。

3、将即将执行的纤程执行环境与线程关联起来，由线程执行指定的纤程。

4、将指令指针设置为保存的值，继续上次的执行。

　　SwitchToFiber函数是一个纤程能够被调度的唯一的方法，因此，纤程的调度是由用户完全操纵的。纤程的调度和线程的调度无关。一个线程，包含了正在运行的纤程，仍会被其他线程抢占。当一个线程被调度，而它里面有几个纤程，那么只有被选择的那个纤程才会执行，其他纤程的执行需要调用SwitchToFiber函数。

　　最后，如果一个纤程完成了任务，你需要删除它，呼叫DeleteFiber函数，并传递这个纤程的执行环境内存地址：

VOID DeleteFiber(PVOID pvFiberExecutionContext);

　　该函数首先清除纤程堆栈，然后删除纤程执行环境。但是，如果参数指定的是一个与当前线程关联的纤程，该函数呼叫ExitThread函数，线程结束，其包含的其他纤程也都结束。因此，DeleteFiber函数一般是由一个纤程调用来删除另一个纤程。

　　当所有纤程结束了运行，你需要从纤程转换为线程，呼叫ConvertFiberToThread函数。

　　如果你需要在纤程中保存一些数据，可以使用“纤程局部存储”（FLS）的机制。这个机制和“线程局部存储”（TLS）类似。

　　首先，呼叫FlsAlloc函数分配FLS槽来存放数据，这个FLS槽可以被当前进程内所有纤程共同使用，函数有一个参数：一个回调函数指针，这个回调函数会在以下两种情况下被调用：一个纤程被删除；FLS槽通过FlsFree函数被删除。

　　然后，在你呼叫FlsAlloc函数之后，你可以在纤程中使用FlsSetValue函数来保存数据到FLS槽中，同时该函数需要一个DWORD类型的参数，表示一个FLS槽的索引，即在FLS槽的相关地方保存数据。

　　接着，你可以在各个纤程中使用FlsGetValue函数来取得FLS槽中对应的数据，同样需要上面那个FLS槽索引，并返回指向数据的指针。

　　当使用完这些数据之后，你可以使用FlsFree来释放FLS槽。

　　如果你想知道你是否正在一个纤程执行环境中运行，可以使用IsThreadAFiber函数，它返回一个BOOL值，指明你是否正在一个纤程中运行。

　　一个线程每次只能执行一个纤程，该纤程与这个线程相关联。你可以使用如下函数来得到正在执行的纤程的执行环境内存地址：

PVOID GetCurrentFiber();

　　每个纤程包含用户定义的一个数据，这个数据由CreateFiber(Ex)或ConvertThreadToFiber(Ex)的pvParam参数指定，你可以使用如下函数得到这个数据的指针：

PVOID GetFiberData();

　　最后，让我们假设一个线程中有2个纤程，总结一下纤程的用法：

1、使用ConverThreadToFiber(Ex)将当前线程转换到纤程，这是纤程F1

2、定义一个纤程函数，用于创建一个新纤程

3、纤程F1中调用CreateFiber(Ex)函数创建一个新的纤程F2

4、SwitchToFiber函数进行纤程切换，让新创建的纤程F2执行

5、F2纤程函数执行完毕的时候，使用SwitchToFiber转换到F1

6、在纤程F1中调用DeleteFiber来删除纤程F2

7、纤程F1中调用ConverFiberToThread，转换为线程

8、线程结束

apache的进程模型

nginx的进程模型

tomcat的进程模型

mysql的进程模型

memcache和redis的进程模型

异步：为了压榨CPU的处理能力，避免阻塞，CPU不去等待比较耗时的IO或者其他耗时的非计算密集型的操作，使得CPU可以自顾自个的去处理事情。IO操作完成之后会回调或者CPU主动获取结果，然后处理接下来的操作。举个例子，CPU发出烧水指令，让电热壶（其他硬件）去烧水，CPU然后去干其他事，并没有等待水烧开之后再去干其他事情，当电热壶把水烧开之后通知CPU或者CPU会监控电热壶水是否烧开，然后CPU把烧开的水倒入杯子

多线程：多线程也是为了压榨CPU的处理能力，多线程没有回调，一件事情多个线程并发的去处理，充分利用CPU多核的资源，举个例子，CPU要修一段100米的路，CPU有4个工程队，CPU发送指令，第一工程队去修0-25米，第二队去修25-50米，第三队去修50-75米，第四对去修75-100米，四个队公用一台压路机，压路机就是独占性资源，所以每个队在用的时候其他队不能使用，但是可以去干其他事，四个队是并发的去修路

异步优缺点：异步操作无需额外的线程负担，主要使用回调的方式进行处理，如果设计的充分好的情况下，处理函数不必要使用共享变量，避免的死锁的可能。但是异步操作编写比较复杂，尤其是回调机制，与正常理解不一致，不容易理解，难于调试

多线程优缺点：多线程按顺序执行，符合正常人的理解，变成简单。但是多线程直接的线程切换比较消耗CPU的资源，并且如果存在争用的资源，可能产生死锁

使用环境：异步比较适合IO操作，如数据库读取、读写文件、网络读写、RPC等。多线程比较适合大规模的计算，比如图形图像处理、复杂算法

多线程和异步的关系：从辩证的角度上看，异步是目的，多线程是其中的一个手段，多线程可以实现异步，异步是

当一个调用者的请求发送给被调动者后不

需要等待被调用者返回的结果，这个调用

者可以是一个线程处理操作也可以是进程

处理操作

异步有时候需要一个普通线程，有时候需要系统的异步调用功能，但是有限异步的IO操作未必需要一个线程来运行

============

============================

指针是Ｃ语言中广泛使用的一种数据类型。运用指针编程是Ｃ语言最主要的风格之一。利用指针变量可以表示各种数据结构；能很方便地使用数组和字符串；并能象汇编语言一样处理内存地址，从而编出精练而高效的程序。指针极大地丰富了Ｃ语言的功能。学习指针是学习Ｃ语言中最重要的一环，能否正确理解和使用指针是我们是否掌握Ｃ语言的一个标志。同时，指针也是Ｃ语言中最为困难的一部分，在学习中除了要正确理解基本概念，还必须要多编程，上机调试。只要作到这些，指针也是不难掌握的。

　　指针的基本概念在计算机中，所有的数据都是存放在存储器中的。一般把存储器中的一个字节称为一个内存单元，不同的数据类型所占用的内存单元数不等，如整型量占2个单元，字符量占1个单元等，在第二章中已有详细的介绍。为了正确地访问这些内存单元，必须为每个内存单元编上号。根据一个内存单元的编号即可准确地找到该内存单元。内存单元的编号也叫做地址。既然根据内存单元的编号或地址就可以找到所需的内存单元，所以通常也把这个地址称为指针。内存单元的指针和内存单元的内容是两个不同的概念。可以用一个通俗的例子来说明它们之间的关系。我们到银行去存取款时，银行工作人员将根据我们的帐号去找我们的存款单，找到之后在存单上写入存款、取款的金额。在这里，帐号就是存单的指针，存款数是存单的内容。对于一个内存单元来说，单元的地址即为指针，其中存放的数据才是该单元的内容。在Ｃ语言中，允许用一个变量来存放指针，这种变量称为指针变量。因此，一个指针变量的值就是某个内存单元的地址或称为某内存单元的指针。图中，设有字符变量C，其内容为“K”(ASCII码为十进制数 75)，C占用了011A号单元(地址用十六进数表示)。设有指针变量P，内容为011A，这种情况我们称为P指向变量C，或说P是指向变量C的指针。严格地说，一个指针是一个地址，是一个常量。而一个指针变量却可以被赋予不同的指针值，是变。但在常把指针变量简称为指针。为了避免混淆，我们中约定：“指针”是指地址，是常量，“指针变量”是指取值为地址的变量。定义指针的目的是为了通过指针去访问内存单元。
　
　　既然指针变量的值是一个地址，那么这个地址不仅可以是变量的地址，也可以是其它数据结构的地址。在一个指针变量中存放一
个数组或一个函数的首地址有何意义呢？因为数组或函数都是连续存放的。通过访问指针变量取得了数组或函数的首地址，也就找到了该数组或函数。这样一来，凡是出现数组，函数的地方都可以用一个指针变量来表示，只要该指针变量中赋予数组或函数的首地址即可。这样做，将会使程序的概念十分清楚，程序本身也精练，高效。在Ｃ语言中，一种数据类型或数据结构往往都占有一组连续的内存单元。用“地址”这个概念并不能很好地描述一种数据类型或数据结构，而“指针”虽然实际上也是一个地址，但它却是一个数据结构的首地址，它是“指向”一个数据结构的，因而概念更为清楚，表示更为明确。这也是引入“指针”概念的一个重要原因。

指针变量的类型说明

　　对指针变量的类型说明包括三个内容：
(1)指针类型说明，即定义变量为一个指针变量；
(2)指针变量名；
(3)变量值(指针)所指向的变量的数据类型。
　　其一般形式为：类型说明符 *变量名；
　　其中，*表示这是一个指针变量，变量名即为定义的指针变量名，类型说明符表示本指针变量所指向的变量的数据类型。
　　例如： int *p1;表示p1是一个指针变量，它的值是某个整型变量的地址。或者说p1指向一个整型变量。至于p1究竟指向哪一个整型变量，应由向p1赋予的地址来决定。
　　再如：
staic int *p2; /*p2是指向静态整型变量的指针变量*/
float *p3; /*p3是指向浮点变量的指针变量*/
char *p4; /*p4是指向字符变量的指针变量*/ 应该注意的是，一个指针变量只能指向同类型的变量，如P3 只能指向浮点变量，不能时而指向一个浮点变量，时而又指向一个字符变量。

指针变量的赋值

　　指针变量同普通变量一样，使用之前不仅要定义说明，而且必须赋予具体的值。未经赋值的指针变量不能使用，否则将造成系统混乱，甚至死机。指针变量的赋值只能赋予地址，决不能赋予任何其它数据，否则将引起错误。在Ｃ语言中，变量的地址是由编译系统分配的，对用户完全透明，用户不知道变量的具体地址。Ｃ语言中提供了地址运算符&来表示变量的地址。其一般形式为： & 变量名；如&a变示变量a的地址，&b表示变量b的地址。变量本身必须预先说明。设有指向整型变量的指针变量p，如要把整型变量a 的地址赋予p可以有以下两种方式：
(1)指针变量初始化的方法 int a;
int *p=&a;
(2)赋值语句的方法 int a;
int *p;
p=&a;
不允许把一个数赋予指针变量，故下面的赋值是错误的： int *p;p=1000; 被赋值的指针变量前不能再加“*”说明符，如写为*p=&a 也是错误的

指针变量的运算

　　指针变量可以进行某些运算，但其运算的种类是有限的。它只能进行赋值运算和部分算术运算及关系运算。
1.指针运算符

(1)取地址运算符&
　　取地址运算符&是单目运算符，其结合性为自右至左，其功能是取变量的地址。在scanf函数及前面介绍指针变量赋值中，我们已经了解并使用了&运算符。

(2)取内容运算符*
　　取内容运算符*是单目运算符，其结合性为自右至左，用来表示指针变量所指的变量。在*运算符之后跟的变量必须是指针变量。需要注意的是指针运算符*和指针变量说明中的指针说明符* 不是一回事。在指针变量说明中，“*”是类型说明符，表示其后的变量是指针类型。而表达式中出现的“*”则是一个运算符用以表示指针变量所指的变量。
main(){
int a=5,*p=&a;
printf ("%d",*p);
}
......
表示指针变量p取得了整型变量a的地址。本语句表示输出变量a的值。

2.指针变量的运算

(1)赋值运算

指针变量的赋值运算有以下几种形式：
①指针变量初始化赋值，前面已作介绍。

②把一个变量的地址赋予指向相同数据类型的指针变量。例如：
int a,*pa;
pa=&a; /*把整型变量a的地址赋予整型指针变量pa*/

③把一个指针变量的值赋予指向相同类型变量的另一个指针变量。如：
int a,*pa=&a,*pb;
pb=pa; /*把a的地址赋予指针变量pb*/
由于pa,pb均为指向整型变量的指针变量，因此可以相互赋值。 ④把数组的首地址赋予指向数组的指针变量。
例如： int a[5],*pa;
pa=a; (数组名表示数组的首地址，故可赋予指向数组的指针变量pa)
也可写为：
pa=&a[0]; /*数组第一个元素的地址也是整个数组的首地址，
也可赋予pa*/
当然也可采取初始化赋值的方法：
int a[5],*pa=a;

⑤把字符串的首地址赋予指向字符类型的指针变量。例如： char *pc;pc="c language";或用初始化赋值的方法写为： char *pc="C Language"; 这里应说明的是并不是把整个字符串装入指针变量，而是把存放该字符串的字符数组的首地址装入指针变量。在后面还将详细介绍。

⑥把函数的入口地址赋予指向函数的指针变量。例如： int (*pf)();pf=f; /*f为函数名*/

(2)加减算术运算

　　对于指向数组的指针变量，可以加上或减去一个整数n。设pa是指向数组a的指针变量，则pa+n,pa-n,pa++,++pa,pa--,--pa 运算都是合法的。指针变量加或减一个整数n的意义是把指针指向的当前位置(指向某数组元素)向前或向后移动n个位置。应该注意，数组指针变量向前或向后移动一个位置和地址加1或减1 在概念上是不同的。因为数组可以有不同的类型，各种类型的数组元素所占的字节长度是不同的。如指针变量加1，即向后移动1 个位置表示指针变量指向下一个数据元素的首地址。而不是在原地址基础上加1。
例如：
int a[5],*pa;
pa=a; /*pa指向数组a，也是指向a[0]*/
pa=pa+2; /*pa指向a[2]，即pa的值为&pa[2]*/ 指针变量的加减运算只能对数组指针变量进行，对指向其它类型变量的指针变量作加减运算是毫无意义的。(3)两个指针变量之间的运算只有指向同一数组的两个指针变量之间才能进行运算，否则运算毫无意义。

①两指针变量相减
两指针变量相减所得之差是两个指针所指数组元素之间相差的元素个数。实际上是两个指针值(地址) 相减之差再除以该数组元素的长度(字节数)。例如pf1和pf2 是指向同一浮点数组的两个指针变量，设pf1的值为2010H，pf2的值为2000H，而浮点数组每个元素占4个字节，所以pf1-pf2的结果为(2000H-2010H)/4=4，表示pf1和 pf2之间相差4个元素。两个指针变量不能进行加法运算。例如， pf1+pf2是什么意思呢?毫无实际意义。

②两指针变量进行关系运算
指向同一数组的两指针变量进行关系运算可表示它们所指数组元素之间的关系。例如：
pf1==pf2表示pf1和pf2指向同一数组元素
pf1>pf2表示pf1处于高地址位置
pf1<pf2表示pf2处于低地址位置
main(){
int a=10,b=20,s,t,*pa,*pb;
pa=&a;
pb=&b;
s=*pa+*pb;
t=*pa**pb;
printf("a=%d/nb=%d/na+b=%d/na*b=%d/n",a,b,a+b,a*b);
printf("s=%d/nt=%d/n",s,t);
}
......
说明pa,pb为整型指针变量
给指针变量pa赋值，pa指向变量a。
给指针变量pb赋值，pb指向变量b。
本行的意义是求a+b之和，(*pa就是a，*pb就是b)。
本行是求a*b之积。
输出结果。
输出结果。
......
指针变量还可以与0比较。设p为指针变量，则p==0表明p是空指针，它不指向任何变量；p!=0表示p不是空指针。空指针是由对指针变量赋予0值而得到的。例如： #define NULL 0　int *p=NULL; 对指针变量赋0值和不赋值是不同的。指针变量未赋值时，可以是任意值，是不能使用的。否则将造成意外错误。而指针变量赋0值后，则可以使用，只是它不指向具体的变量而已。
main(){
int a,b,c,*pmax,*pmin;
printf("input three numbers:/n");
scanf("%d%d%d",&a,&b,&c);
if(a>b){
pmax=&a;
pmin=&b;}
else{
pmax=&b;
pmin=&a;}
if(c>*pmax) pmax=&c;
if(c<*pmin) pmin=&c;
printf("max=%d/nmin=%d/n",*pmax,*pmin);
}
......
pmax,pmin为整型指针变量。
输入提示。
输入三个数字。
如果第一个数字大于第二个数字．．．
指针变量赋值
指针变量赋值

指针变量赋值
指针变量赋值
判断并赋值
判断并赋值
输出结果
......

数组指针变量的说明和使用

　　指向数组的指针变量称为数组指针变量。在讨论数组指针变量的说明和使用之前，我们先明确几个关系。
一个数组是由连续的一块内存单元组成的。数组名就是这块连续内存单元的首地址。一个数组也是由各个数组元素(下标变量) 组成的。每个数组元素按其类型不同占有几个连续的内存单元。一个数组元素的首地址也是指它所占有的几个内存单元的首地址。一个指针变量既可以指向一个数组，也可以指向一个数组元素，可把数组名或第一个元素的地址赋予它。如要使指针变量指向第i号元素可以把i元素的首地址赋予它或把数组名加i赋予它。

　　设有实数组a，指向a的指针变量为pa，从图6.3中我们可以看出有以下关系：
pa,a,&a[0]均指向同一单元，它们是数组a的首地址，也是0 号元素a[0]的首地址。pa+1,a+1,&a[1]均指向1号元素a[1]。类推可知a+i,a+i,&a[i]
指向i号元素a[i]。应该说明的是pa是变量，而a,&a[i]都是常量。在编程时应予以注意。
main(){
int a[5],i;
for(i=0;i<5;i++){
a[i]=i;
printf("a[%d]=%d/n",i,a[i]);
}
printf("/n");
}
主函数
定义一个整型数组和一个整型变量
循环语句
给数组赋值
打印每一个数组的值
......
输出换行
......
数组指针变量说明的一般形式为：
类型说明符 * 指针变量名
　　其中类型说明符表示所指数组的类型。从一般形式可以看出指向数组的指针变量和指向普通变量的指针变量的说明是相同的。
引入指针变量后，就可以用两种方法来访问数组元素了。
　　第一种方法为下标法，即用a[i]形式访问数组元素。在第四章中介绍数组时都是采用这种方法。
　　第二种方法为指针法，即采用*(pa+i)形式，用间接访问的方法来访问数组元素。
main(){
int a[5],i,*pa;
pa=a;
for(i=0;i<5;i++){
*pa=i;
pa++;
}
pa=a;
for(i=0;i<5;i++){
printf("a[%d]=%d/n",i,*pa);
pa++;
}
}
主函数
定义整型数组和指针
将指针pa指向数组a
循环
将变量i的值赋给由指针pa指向的a[]的数组单元
将指针pa指向a[]的下一个单元
......
指针pa重新取得数组a的首地址
循环
用数组方式输出数组a中的所有元素
将指针pa指向a[]的下一个单元
......
......
下面，另举一例，该例与上例本意相同，但是实现方式不同。
main(){
int a[5],i,*pa=a;
for(i=0;i<5;){
*pa=i;
printf("a[%d]=%d/n",i++,*pa++);
}
}
主函数
定义整型数组和指针，并使指针指向数组a
循环
将变量i的值赋给由指针pa指向的a[]的数组单元
用指针输出数组a中的所有元素，同时指针pa指向a[]的下一个单元
......
......

数组名和数组指针变量作函数参数

　　在第五章中曾经介绍过用数组名作函数的实参和形参的问题。在学习指针变量之后就更容易理解这个问题了。数组名就是数组的首地址，实参向形参传送数组名实际上就是传送数组的地址，形参得到该地址后也指向同一数组。这就好象同一件物品有两个彼此不同的名称一样。同样，指针变量的值也是地址，数组指针变量的值即为数组的首地址，当然也可作为函数的参数使用。
float aver(float *pa);
main(){
float sco[5],av,*sp;
int i;
sp=sco;
printf("/ninput 5 scores:/n");
for(i=0;i<5;i++) scanf("%f",&sco[i]);
av=aver(sp);
printf("average score is %5.2f",av);
}
float aver(float *pa)
{
int i;
float av,s=0;
for(i=0;i<5;i++) s=s+*pa++;
av=s/5;
return av;
}

指向多维数组的指针变量

本小节以二维数组为例介绍多维数组的指针变量。

一、多维数组地址的表示方法
设有整型二维数组a[3][4]如下：
0 1 2 3
4 5 6 7
8 9 10 11
　　设数组a的首地址为1000，各下标变量的首地址及其值如图所示。在第四章中介绍过，Ｃ语言允许把一个二维数组分解为多个一维数组来处理。因此数组a可分解为三个一维数组，即a[0]，a[1]，a[2]。每一个一维数组又含有四个元素。例如a[0]数组，含有a[0][0]，a[0][1]，a[0][2]，a[0][3]四个元素。数组及数组元素的地址表示如下：a是二维数组名，也是二维数组0行的首地址，等于1000。a[0]是第一个一维数组的数组名和首地址，因此也为1000。*(a+0)或*a是与a[0]等效的，它表示一维数组a[0]0 号元素的首地址。也为1000。&a[0][0]是二维数组a的0行0列元素首地址，同样是1000。因此，a，a[0]，*(a+0)，*a?amp;a[0][0]是相等的。同理，a+1是二维数组1行的首地址，等于1008。a[1]是第二个一维数组的数组名和首地址，因此也为1008。 &a[1][0]是二维数组a的1行0列元素地址，也是1008。因此a+1,a[1],*(a+1),&a[1][0]是等同的。由此可得出：a+i，a[i]，*(a+i)，&a[i][0]是等同的。此外，&a[i]和a[i]也是等同的。因为在二维数组中不能把&a[i]理解为元素a[i]的地址，不存在元素a[i]。

　　Ｃ语言规定，它是一种地址计算方法，表示数组a第i行首地址。由此，我们得出：a[i]，&a[i]，*(a+i)和a+i也都是等同的。另外，a[0]也
可以看成是a[0]+0是一维数组a[0]的0号元素的首地址，而a[0]+1则是a[0]的1号元素首地址，由此可得出a[i]+j则是一维数组a[i]的j号元素首地址，它等于&a[i][j]。由a[i]=*(a+i)得a[i]+j=*(a+i)+j，由于*(a+i)+j是二维数组a的i行j列元素的首地址。该元素的值等于*(*(a+i)+j)。
[Explain]#define PF "%d,%d,%d,%d,%d,/n"
main(){
static int a[3][4]={0,1,2,3,4,5,6,7,8,9,10,11};
printf(PF,a,*a,a[0],&a[0],&a[0][0]);
printf(PF,a+1,*(a+1),a[1],&a[1],&a[1][0]);
printf(PF,a+2,*(a+2),a[2],&a[2],&a[2][0]);
printf("%d,%d/n",a[1]+1,*(a+1)+1);
printf("%d,%d/n",*(a[1]+1),*(*(a+1)+1));
}

二、多维数组的指针变量

　　把二维数组a 分解为一维数组a[0],a[1],a[2]之后，设p为指向二维数组的指针变量。可定义为： int (*p)[4] 它表示p是一个指针变量，它指向二维数组a 或指向第一个一维数组a[0]，其值等于a,a[0]，或&a[0][0]等。而p+i则指向一维数组a[i]。从前面的分析可得出*(p+i)+j是二维数组i行j 列的元素的地址，而*(*(p+i)+j)则是i行j列元素的值。

　　二维数组指针变量说明的一般形式为：类型说明符 (*指针变量名)[长度] 其中“类型说明符”为所指数组的数据类型。“*”表示其后的变量是指针类型。 “长度”表示二维数组分解为多个一维数组时，一维数组的长度，也就是二维数组的列数。应注意“(*指针变量名)”两边的括号不可少，如缺少括号则表示是指针数组(本章后面介绍)，意义就完全不同了。
[Explain]main(){
static int a[3][4]={0,1,2,3,4,5,6,7,8,9,10,11};
int(*p)[4];
int i,j;
p=a;
for(i=0;i<3;i++)
for(j=0;j<4;j++) printf("%2d ",*(*(p+i)+j));
}
'Expain字符串指针变量的说明和使用字符串指针变量的定义说明与指向字符变量的指针变量说明是相同的。只能按对指针变量的赋值不同来区别。对指向字符变量的指针变量应赋予该字符变量的地址。如： char c,*p=&c;表示p是一个指向字符变量c的指针变量。而： char *s="C Language";则表示s是一个指向字符串的指针变量。把字符串的首地址赋予s。
请看下面一例。
main(){
char *ps;
ps="C Language";
printf("%s",ps);
}
运行结果为：
C Language
上例中，首先定义ps是一个字符指针变量，然后把字符串的首地址赋予ps(应写出整个字符串，以便编译系统把该串装入连续的一块内存单元)，并把首地址送入ps。程序中的： char *ps;ps="C Language";等效于： char *ps="C Language";输出字符串中n个字符后的所有字符。
main(){
char *ps="this is a book";
int n=10;
ps=ps+n;
printf("%s/n",ps);
}
运行结果为：
book 在程序中对ps初始化时，即把字符串首地址赋予ps，当ps= ps+10之后，ps指向字符“b”，因此输出为"book"。
main(){
char st[20],*ps;
int i;
printf("input a string:/n");
ps=st;
scanf("%s",ps);
for(i=0;ps[i]!='/0';i++)
if(ps[i]=='k'){
printf("there is a 'k' in the string/n");
break;
}
if(ps[i]=='/0') printf("There is no 'k' in the string/n");
}
　　本例是在输入的字符串中查找有无‘k’字符。下面这个例子是将指针变量指向一个格式字符串，用在printf函数中，用于输出二维数组的各种地址表示的值。但在printf语句中用指针变量PF代替了格式串。这也是程序中常用的方法。
main(){
static int a[3][4]={0,1,2,3,4,5,6,7,8,9,10,11};
char *PF;
PF="%d,%d,%d,%d,%d/n";
printf(PF,a,*a,a[0],&a[0],&a[0][0]);
printf(PF,a+1,*(a+1),a[1],&a[1],&a[1][0]);
printf(PF,a+2,*(a+2),a[2],&a[2],&a[2][0]);
printf("%d,%d/n",a[1]+1,*(a+1)+1);
printf("%d,%d/n",*(a[1]+1),*(*(a+1)+1));
}
　　在下例是讲解，把字符串指针作为函数参数的使用。要求把一个字符串的内容复制到另一个字符串中，并且不能使用strcpy函数。函数cprstr的形参为两个字符指针变量。pss指向源字符串，pds指向目标字符串。表达式：
(*pds=*pss)!=`/0'
cpystr(char *pss,char *pds){
while((*pds=*pss)!='/0'){
pds++;
pss++; }
}
main(){
char *pa="CHINA",b[10],*pb;
pb=b;
cpystr(pa,pb);
printf("string a=%s/nstring b=%s/n",pa,pb);
}
　　在上例中，程序完成了两项工作：一是把pss指向的源字符复制到pds所指向的目标字符中，二是判断所复制的字符是否为`/0'，若是则表明源字符串结束，不再循环。否则，pds和pss都加1，指向下一字符。在主函数中，以指针变量pa,pb为实参，分别取得确定值后调用cprstr函数。由于采用的指针变量pa和pss,pb和pds均指向同一字符串，因此在主函数和cprstr函数中均可使用这些字符串。也可以把cprstr函数简化为以下形式：
cprstr(char *pss,char*pds)
{while ((*pds++=*pss++)!=`/0');}
　　即把指针的移动和赋值合并在一个语句中。进一步分析还可发现`/0'的ASCⅡ码为0，对于while语句只看表达式的值为非0就循环，为0则结束循环，因此也可省去“!=`/0'”这一判断部分，而写为以下形式：
cprstr (char *pss,char *pds)
{while (*pdss++=*pss++);}
表达式的意义可解释为，源字符向目标字符赋值，移动指针，若所赋值为非0则循环，否则结束循环。这样使程序更加简洁。简化后的程序如下所示。
cpystr(char *pss,char *pds){
while(*pds++=*pss++);
}
main(){
char *pa="CHINA",b[10],*pb;
pb=b;
cpystr(pa,pb);
printf("string a=%s/nstring b=%s/n",pa,pb);
}

使用字符串指针变量与字符数组的区别

用字符数组和字符指针变量都可实现字符串的存储和运算。但是两者是有区别的。在使用时应注意以下几个问题：

1. 字符串指针变量本身是一个变量，用于存放字符串的首地址。而字符串本身是存放在以该首地址为首的一块连续的内存空间中并以‘/0’作为串的结束。字符数组是由于若干个数组元素组成的，它可用来存放整个字符串。

2. 对字符数组作初始化赋值，必须采用外部类型或静态类型，如： static char st[]={“C Language”};而对字符串指针变量则无此限制，如： char *ps="C Language";

3. 对字符串指针方式 char *ps="C Language";可以写为： char *ps;　ps="C Language";而对数组方式：
static char st[]={"C Language"};
不能写为：
char st[20];st={"C Language"};
而只能对字符数组的各元素逐个赋值。

　　从以上几点可以看出字符串指针变量与字符数组在使用时的区别，同时也可看出使用指针变量更加方便。前面说过，当一个指针变量在未取得确定地址前使用是危险的，容易引起错误。但是对指针变量直接赋值是可以的。因为C系统对指针变量赋值时要给以确定的地址。因此，
char *ps="C Langage";
或者 char *ps;
ps="C Language";都是合法的。

函数指针变量

　　在Ｃ语言中规定，一个函数总是占用一段连续的内存区，而函数名就是该函数所占内存区的首地址。我们可以把函数的这个首地址(或称入口地址)赋予一个指针变量，使该指针变量指向该函数。然后通过指针变量就可以找到并调用这个函数。我们把这种指向函数的指针变量称为“函数指针变量”。
函数指针变量定义的一般形式为：
类型说明符 (*指针变量名)();
其中“类型说明符”表示被指函数的返回值的类型。“(* 指针变量名)”表示“*”后面的变量是定义的指针变量。最后的空括号表示指针变量所指的是一个函数。
例如： int (*pf)();
表示pf是一个指向函数入口的指针变量，该函数的返回值(函数值)是整型。
下面通过例子来说明用指针形式实现对函数调用的方法。
int max(int a,int b){
if(a>b)return a;
else return b;
}
main(){
int max(int a,int b);
int(*pmax)();
int x,y,z;
pmax=max;
printf("input two numbers:/n");
scanf("%d%d",&x,&y);
z=(*pmax)(x,y);
printf("maxmum=%d",z);
}
　　从上述程序可以看出用，函数指针变量形式调用函数的步骤如下：1. 先定义函数指针变量，如后一程序中第9行 int (*pmax)();定义pmax为函数指针变量。

2. 把被调函数的入口地址(函数名)赋予该函数指针变量，如程序中第11行 pmax=max;

3. 用函数指针变量形式调用函数，如程序第14行 z=(*pmax)(x,y);　调用函数的一般形式为： (*指针变量名) (实参表)使用函数指针变量还应注意以下两点：

a. 函数指针变量不能进行算术运算，这是与数组指针变量不同的。数组指针变量加减一个整数可使指针移动指向后面或前面的数组元素，而函数指针的移动是毫无意义的。

b. 函数调用中"(*指针变量名)"的两边的括号不可少，其中的*不应该理解为求值运算，在此处它只是一种表示符号。

指针型函数

前面我们介绍过，所谓函数类型是指函数返回值的类型。在Ｃ语言中允许一个函数的返回值是一个指针(即地址)，这种返回指针值的函数称为指针型函数。
定义指针型函数的一般形式为：
类型说明符 *函数名(形参表)
{
…… /*函数体*/
}
其中函数名之前加了“*”号表明这是一个指针型函数，即返回值是一个指针。类型说明符表示了返回的指针值所指向的数据类型。
如：
int *ap(int x,int y)
{
...... /*函数体*/
}
　　表示ap是一个返回指针值的指针型函数，它返回的指针指向一个整型变量。下例中定义了一个指针型函数 day_name，它的返回值指向一个字符串。该函数中定义了一个静态指针数组name。name 数组初始化赋值为八个字符串，分别表示各个星期名及出错提示。形参n表示与星期名所对应的整数。在主函数中，把输入的整数i作为实参，在printf语句中调用day_name函数并把i值传送给形参 n。day_name函数中的return语句包含一个条件表达式， n 值若大于7或小于1则把name[0] 指针返回主函数输出出错提示字符串“Illegal day”。否则返回主函数输出对应的星期名。主函数中的第7行是个条件语句，其语义是，如输入为负数(i<0)则中止程序运行退出程序。exit是一个库函数，exit(1)表示发生错误后退出程序， exit(0)表示正常退出。

　　应该特别注意的是函数指针变量和指针型函数这两者在写法和意义上的区别。如int(*p)()和int *p()是两个完全不同的量。int(*p)()是一个变量说明，说明p 是一个指向函数入口的指针变量，该函数的返回值是整型量，(*p)的两边的括号不能少。int *p() 则不是变量说明而是函数说明，说明p是一个指针型函数，其返回值是一个指向整型量的指针，*p两边没有括号。作为函数说明，在括号内最好写入形式参数，这样便于与变量说明区别。对于指针型函数定义，int *p()只是函数头部分，一般还应该有函数体部分。
main(){
int i;
char *day_name(int n);
printf("input Day No:/n");
scanf("%d",&i);
if(i<0) exit(1);
printf("Day No:%2d-->%s/n",i,day_name(i));
}
char *day_name(int n){
static char *name[]={ "Illegal day",
"Monday",
"Tuesday",
"Wednesday",
"Thursday",
"Friday",
"Saturday",
"Sunday"};
return((n<1||n>7) ? name[0] : name[n]);
}
　　本程序是通过指针函数，输入一个1～7之间的整数，输出对应的星期名。指针数组的说明与使用一个数组的元素值为指针则是指针数组。指针数组是一组有序的指针的集合。指针数组的所有元素都必须是具有相同存储类型和指向相同数据类型的指针变量。
　　指针数组说明的一般形式为：类型说明符*数组名[数组长度]
　　其中类型说明符为指针值所指向的变量的类型。例如： int *pa[3] 表示pa是一个指针数组，它有三个数组元素，每个元素值都是一个指针，指向整型变量。通常可用一个指针数组来指向一个二维数组。指针数组中的每个元素被赋予二维数组每一行的首地址，因此也可理解为指向一个一维数组。图6—6表示了这种关系。
int a[3][3]={1,2,3,4,5,6,7,8,9};
int *pa[3]={a[0],a[1],a[2]};
int *p=a[0];
main(){
int i;
for(i=0;i<3;i++)
printf("%d,%d,%d/n",a[i][2-i],*a[i],*(*(a+i)+i));
for(i=0;i<3;i++)
printf("%d,%d,%d/n",*pa[i],p[i],*(p+i));
}
　　本例程序中，pa是一个指针数组，三个元素分别指向二维数组a的各行。然后用循环语句输出指定的数组元素。其中*a[i]表示i行0列元素值；*(*(a+i)+i)表示i行i列的元素值；*pa[i]表示i行0列元素值；由于p与a[0]相同，故p[i]表示0行i列的值；*(p+i)表示0行i列的值。读者可仔细领会元素值的各种不同的表示方法。应该注意指针数组和二维数组指针变量的区别。这两者虽然都可用来表示二维数组，但是其表示方法和意义是不同的。

　　二维数组指针变量是单个的变量，其一般形式中"(*指针变量名)"两边的括号不可少。而指针数组类型表示的是多个指针( 一组有序指针)在一般形式中"*指针数组名"两边不能有括号。例如： int (*p)[3];表示一个指向二维数组的指针变量。该二维数组的列数为3或分解为一维数组的长度为3。 int *p[3] 表示p是一个指针数组，有三个下标变量p[0]，p[1]，p[2]均为指针变量。

　　指针数组也常用来表示一组字符串，这时指针数组的每个元素被赋予一个字符串的首地址。指向字符串的指针数组的初始化更为简单。例如在例6.20中即采用指针数组来表示一组字符串。其初始化赋值为：
char *name[]={"Illagal day",
"Monday",
"Tuesday",
"Wednesday",
"Thursday",
"Friday",
"Saturday",
"Sunday"};
　　完成这个初始化赋值之后，name[0]即指向字符串"Illegal day"，name[1]指?quot;Monday"......。

　　指针数组也可以用作函数参数。在本例主函数中，定义了一个指针数组name，并对name 作了初始化赋值。其每个元素都指向一个字符串。然后又以name 作为实参调用指针型函数day name，在调用时把数组名 name 赋予形参变量name，输入的整数i作为第二个实参赋予形参n。在day name函数中定义了两个指针变量pp1和pp2，pp1被赋予name[0]的值(即*name)，pp2被赋予name[n]的值即*(name+ n)。由条件表达式决定返回pp1或pp2指针给主函数中的指针变量ps。最后输出i和ps的值。

指针数组作指针型函数的参数
main(){
static char *name[]={ "Illegal day",
"Monday",
"Tuesday",
"Wednesday",
"Thursday",
"Friday",
"Saturday",
"Sunday"};
char *ps;
int i;
char *day name(char *name[],int n);
printf("input Day No:/n");
scanf("%d",&i);
if(i<0) exit(1);
ps=day name(name,i);
printf("Day No:%2d-->%s/n",i,ps);
}
char *day name(char *name[],int n)
{
char *pp1,*pp2;
pp1=*name;
pp2=*(name+n);
return((n<1||n>7)? pp1:pp2);
}
下例要求输入5个国名并按字母顺序排列后输出。在以前的例子中采用了普通的排序方法，逐个比较之后交换字符串的位置。交换字符串的物理位置是通过字符串复制函数完成的。反复的交换将使程序执行的速度很慢，同时由于各字符串(国名) 的长度不同，又增加了存储管理的负担。用指针数组能很好地解决这些问题。把所有的字符串存放在一个数组中，把这些字符数组的首地址放在一个指针数组中，当需要交换两个字符串时，只须交换指针数组相应两元素的内容(地址)即可，而不必交换字符串本身。程序中定义了两个函数，一个名为sort完成排序，其形参为指
针数组name，即为待排序的各字符串数组的指针。形参n为字符串的个数。另一个函数名为print，用于排序后字符串的输出，其形参与sort的形参相同。主函数main中，定义了指针数组name 并作了初始化赋值。然后分别调用sort函数和print函数完成排序和输出。值得说明的是在sort函数中，对两个字符串比较，采用了strcmp 函数，strcmp函数允许参与比较的串以指针方式出现。name[k]和name[ j]均为指针，因此是合法的。字符串比较后需要交换时，只交换指针数组元素的值，而不交换具体的字符串，这样将大大减少时间的开销，提高了运行效率。
现编程如下：
#include"string.h"
main(){
void sort(char *name[],int n);
void print(char *name[],int n);
static char *name[]={ "CHINA","AMERICA","AUSTRALIA",
"FRANCE","GERMAN"};
int n=5;
sort(name,n);
print(name,n);
}
void sort(char *name[],int n){
char *pt;
int i,j,k;
for(i=0;i<n-1;i++){
k=i;
for(j=i+1;j<n;j++)
if(strcmp(name[k],name[j])>0) k=j;
if(k!=i){
pt=name[i];
name[i]=name[k];
name[k]=pt;
}
}
}
void print(char *name[],int n){
int i;
for (i=0;i<n;i++) printf("%s/n",name[i]);
}

ｍａｉｎ函数的参数

　　前面介绍的main函数都是不带参数的。因此main 后的括号都是空括号。实际上，main函数可以带参数，这个参数可以认为是 main函数的形式参数。Ｃ语言规定main函数的参数只能有两个，习惯上这两个参数写为argc和argv。因此，main函数的函数头可写为： main (argc,argv)Ｃ语言还规定argc(第一个形参)必须是整型变量,argv( 第二个形参)必须是指向字符串的指针数组。加上形参说明后，main函数的函数头应写为：
main (argc,argv)
int argv;
char *argv[];或写成：
main (int argc,char *argv[])
　　由于main函数不能被其它函数调用，因此不可能在程序内部取得实际值。那么，在何处把实参值赋予main函数的形参呢? 实际上,main函数的参数值是从操作系统命令行上获得的。当我们要运行一个可执行文件时，在DOS提示符下键入文件名，再输入实际参数即可把这些实参传送到main的形参中去。

　　DOS提示符下命令行的一般形式为： C:/>可执行文件名参数参数……; 但是应该特别注意的是，main 的两个形参和命令行中的参数在
位置上不是一一对应的。因为,main的形参只有二个，而命令行中的参数个数原则上未加限制。argc参数表示了命令行中参数的个数(注意：文件名本身也算一个参数)，argc的值是在输入命令行时由系统按实际参数的个数自动赋予的。例如有命令行为： C:/>E6 24 BASIC dbase FORTRAN由于文件名E6 24本身也算一个参数，所以共有4个参数，因此argc取得的值为4。argv参数是字符串指针数组，其各元素值为命令行中各字符串(参数均按字符串处理)的首地址。指针数组的长度即为参数个数。数组元素初值由系统自动赋予。其表示如图6.8所示：
main(int argc,char *argv){
while(argc-->1)
printf("%s/n",*++argv);
}
本例是显示命令行中输入的参数如果上例的可执行文件名为e24.exe，存放在A驱动器的盘内。
因此输入的命令行为： C:/>a:e24 BASIC dBASE FORTRAN
则运行结果为：
BASIC
dBASE
FORTRAN
　　该行共有4个参数，执行main时，argc的初值即为4。argv的4个元素分为4个字符串的首地址。执行while语句，每循环一次 argv值减1，当argv等于1时停止循环，共循环三次，因此共可输出三个参数。在printf函数中，由于打印项*++argv是先加1再打印，故第一次打印的是argv[1]所指的字符串BASIC。第二、三次循环分别打印后二个字符串。而参数e24是文件名，不必输出。

　　下例的命令行中有两个参数，第二个参数20即为输入的n值。在程序中*++argv的值为字符串“20”，然后用函数"atoi"把它换为整型作为while语句中的循环控制变量，输出20个偶数。
#include"stdlib.h"
main(int argc,char*argv[]){
int a=0,n;
n=atoi(*++argv);
while(n--) printf("%d ",a++*2);
}
　　本程序是从0开始输出n个偶数。指向指针的指针变量如果一个指针变量存放的又是另一个指针变量的地址，则称这个指针变量为指向指针的指针变量。

　　在前面已经介绍过，通过指针访问变量称为间接访问，简称间访。由于指针变量直接指向变量，所以称为单级间访。而如果通过指向指针的指针变量来访问变量则构成了二级或多级间访。在Ｃ语言程序中，对间访的级数并未明确限制，但是间访级数太多时不容易理解解，也容易出错，因此，一般很少超过二级间访。指向指针的指针变量说明的一般形式为：
类型说明符** 指针变量名；
例如： int ** pp; 表示pp是一个指针变量，它指向另一个指针变量，而这个指针变量指向一个整型量。下面举一个例子来说明这种关系。
main(){
int x,*p,**pp;
x=10;
p=&x;
pp=&p;
printf("x=%d/n",**pp);
}
　　上例程序中p 是一个指针变量，指向整型量x；pp也是一个指针变量，它指向指针变量p。通过pp变量访问x的写法是**pp。程序最后输出x的值为10。通过上例，读者可以学习指向指针的指针变量的说明和使用方法。

　　下述程序中首先定义说明了指针数组ps并作了初始化赋值。又说明了pps是一个指向指针的指针变量。在5次循环中， pps 分别取得了ps[0]，ps[1]，ps[2]，ps[3]，ps[4]的地址值(如图6.10所示)。再通过这些地址即可找到该字符串。
main(){
static char *ps[]={ "BASIC","DBASE","C","FORTRAN",
"PASCAL"};
char **pps;
int i;
for(i=0;i<5;i++){
pps=ps+i;
printf("%s/n",*pps);
}
}
本程序是用指向指针的指针变量编程，输出多个字符串。

本章小结
1. 指针是Ｃ语言中一个重要的组成部分，使用指针编程有以下优点：
(1)提高程序的编译效率和执行速度。
(2)通过指针可使用主调函数和被调函数之间共享变量或数据结构，便于实现双向数据通讯。
(3)可以实现动态的存储分配。
(4)便于表示各种数据结构，编写高质量的程序。

2. 指针的运算
(1)取地址运算符&：求变量的地址
(2)取内容运算符*：表示指针所指的变量
(3)赋值运算
·把变量地址赋予指针变量
·同类型指针变量相互赋值
·把数组，字符串的首地址赋予指针变量
·把函数入口地址赋予指针变量
(4)加减运算
对指向数组，字符串的指针变量可以进行加减运算，如p+n,p-n,p++,p--等。对指向同一数组的两个指针变量可以相减。对指向其它类型的指针变量作加减运算是无意义的。
(5)关系运算
指向同一数组的两个指针变量之间可以进行大于、小于、等于比较运算。指针可与0比较，p==0表示p为空指针。

3. 与指针有关的各种说明和意义见下表。
int *p; 　　　 p为指向整型量的指针变量
int *p[n]; 　　p为指针数组，由n个指向整型量的指针元素组成。
int (*p)[n]; 　p为指向整型二维数组的指针变量，二维数组的列数为n
int *p() 　　　p为返回指针值的函数，该指针指向整型量
int (*p)() 　　p为指向函数的指针，该函数返回整型量
int **p 　　　 p为一个指向另一指针的指针变量，该指针指向一个整型量。

4. 有关指针的说明很多是由指针，数组，函数说明组合而成的。
但并不是可以任意组合，例如数组不能由函数组成，即数组元素不能是一个函数；函数也不能返回一个数组或返回另一个函数。例如
int a[5]()；就是错误的。

5. 关于括号
在解释组合说明符时，标识符右边的方括号和圆括号优先于标识符左边的“*”号，而方括号和圆括号以相同的优先级从左到右结合。但可以用圆括号改变约定的结合顺序。

6. 阅读组合说明符的规则是“从里向外”。
从标识符开始，先看它右边有无方括号或园括号，如有则先作出解释，再看左边有无*号。如果在任何时候遇到了闭括号，则在继续之前必须用相同的规则处理括号内的内容。例如：
int*(*(*a)())[10]
↑ ↑↑↑↑↑↑
7 6 4 2 1 3 5
上面给出了由内向外的阅读顺序，下面来解释它：
(1)标识符a被说明为；
(2)一个指针变量，它指向；
(3)一个函数，它返回；
(4)一个指针，该指针指向；
(5)一个有10个元素的数组，其类型为；
(6)指针型，它指向；
(7)int型数据。
因此a是一个函数指针变量，该函数返回的一个指针值又指向一个指针数组，该指针数组的元素指向整型量。

在开发软件过程里，也经常碰到进程间共享数据的需求。比如 A 进程创建计算数据， B 进程进行显示数据的图形。这样的开发方式可以把一个大程序分开成独立的小程序，提高软件的成功率，也可以更加适合团队一起开发，加快软件的开发速度。下面就来使用文件映射的方式进行共享数据。先要使用函数 CreateFileMapping 来创建一个想共享的文件数据句柄，然后使用 MapViewOfFile 来获取共享的内存地址，然后使用 OpenFileMapping 函数在另一个进程里打开共享文件的名称，这样就可以实现不同的进程共享数据。

函数 CreateFileMapping 、 MapViewOfFile 声明如下：

WINBASEAPI

__out

HANDLE

WINAPI

CreateFileMappingA(

__in HANDLE hFile,

__in_opt LPSECURITY_ATTRIBUTES lpFileMappingAttributes,

__in DWORD flProtect,

__in DWORD dwMaximumSizeHigh,

__in DWORD dwMaximumSizeLow,

__in_opt LPCSTR lpName