摘要: MongoDB的查询表示为JSON（BSON）对象。此快速参考图表显示了作为SQL的例子，Mongo shell 语法，Mongo的C + +驱动程序的语法。 MongoDB的（和其他的东西，比如一个索引键模式）中的查询表达式表示为BSON。在C + +中，你可以使用BSONObjBuilder（又名 bson::bob ）建立BSON对象，或BSON（）宏。下面的...  阅读全文

要编写出优秀的代码同样要扎实的基础，如果排序和查找算法学的不好，怎么对程序的性能进行优化？废话不多说，本文要介绍的这些排序算法就是基础中的基础，程序员必知！

1、直接插入排序

（1）基本思想：在要排序的一组数中，假设前面(n-1) [n>=2] 个数已经是排

好顺序的，现在要把第n个数插到前面的有序数中，使得这n个数

也是排好顺序的。如此反复循环，直到全部排好顺序。

（2）实例

2、希尔排序（也称最小增量排序）

（1）基本思想：算法先将要排序的一组数按某个增量d（n/2,n为要排序数的个数）分成若干组，每组中记录的下标相差d.对每组中全部元素进行直接插入排序，然后再用一个较小的增量（d/2）对它进行分组，在每组中再进行直接插入排序。当增量减到1时，进行直接插入排序后，排序完成。

（2）实例：

3、简单选择排序

（1）基本思想：在要排序的一组数中，选出最小的一个数与第一个位置的数交换；

然后在剩下的数当中再找最小的与第二个位置的数交换，如此循环到倒数第二个数和最后一个数比较为止。

（2）实例：

4、堆排序

（1）基本思想：堆排序是一种树形选择排序，是对直接选择排序的有效改进。

堆的定义如下：具有n个元素的序列（h1,h2,...,hn),当且仅当满足（hi>=h2i,hi>=2i+1）或（hi<=h2i,hi<=2i+1）(i=1,2,...,n/2)时称之为堆。在这里只讨论满足前者条件的堆。由堆的定义可以看出，堆顶元素（即第一个元素）必为最大项（大顶堆）。完全二叉树可以很直观地表示堆的结构。堆顶为根，其它为左子树、右子树。初始时把要排序的数的序列看作是一棵顺序存储的二叉树，调整它们的存储序，使之成为一个堆，这时堆的根节点的数最大。然后将根节点与堆的最后一个节点交换。然后对前面(n-1)个数重新调整使之成为堆。依此类推，直到只有两个节点的堆，并对它们作交换，最后得到有n个节点的有序序列。从算法描述来看，堆排序需要两个过程，一是建立堆，二是堆顶与堆的最后一个元素交换位置。所以堆排序有两个函数组成。一是建堆的渗透函数，二是反复调用渗透函数实现排序的函数。

（2）实例：

初始序列：46,79,56,38,40,84

建堆：

交换，从堆中踢出最大数

剩余结点再建堆，再交换踢出最大数

依次类推：最后堆中剩余的最后两个结点交换，踢出一个，排序完成。

5、冒泡排序

（1）基本思想：在要排序的一组数中，对当前还未排好序的范围内的全部数，自上而下对相邻的两个数依次进行比较和调整，让较大的数往下沉，较小的往上冒。即：每当两相邻的数比较后发现它们的排序与排序要求相反时，就将它们互换。

（2）实例：

6、快速排序

（1）基本思想：选择一个基准元素,通常选择第一个元素或者最后一个元素,通过一趟扫描，将待排序列分成两部分,一部分比基准元素小,一部分大于等于基准元素,此时基准元素在其排好序后的正确位置,然后再用同样的方法递归地排序划分的两部分。

（2）实例：

上图中将待排序列分成两部分,一部分比基准元素小,一部分大于基准元素,然后对这两部分重复上图的求解过程。

（这只是快速排序的一种实现方式，个人认为比较容易理解）

7、归并排序

（1）基本排序：归并（Merge）排序法是将两个（或两个以上）有序表合并成一个新的有序表，即把待排序序列分为若干个子序列，每个子序列是有序的。然后再把有序子序列合并为整体有序序列。

（2）实例：

8、基数排序

（1）基本思想：将所有待比较数值（正整数）统一为同样的数位长度，数位较短的数前面补零。然后，从最低位开始，依次进行一次排序。这样从最低位排序一直到最高位排序完成以后,数列就变成一个有序序列。

（2）实例：

稳定性说明：排序前，2（或者更多）个相等的数在序列的前后位置顺序和排序后它们在序列中的前后位置顺序一样。

实例：

待排序数列：5,4,8,6,1,8,7,9

排序结果：1,4,5,6,7,8,8,9

稳定：1,4,5,6,7,8,8,9

不稳定：1,4,5,6,7,8,8,9

说明：对比红色的8和紫色的8，看他们排序前后的位置。排序前，红8在紫8前面，如果排序后红8仍然在紫8前面，则排序算法稳定，否则不稳定。

现在我们分析一下8种排序算法的稳定性。

（请网友结合前面的排序基本思想来理解排序的稳定性（8种排序的基本思想已经在前面说过，这里不再赘述）不然可能有些模糊）

（1）直接插入排序：一般插入排序，比较是从有序序列的最后一个元素开始，如果比它大则直接插入在其后面，否则一直往前比。如果找到一个和插入元素相等的，那么就插入到这个相等元素的后面。插入排序是稳定的。

（2）希尔排序：希尔排序是按照不同步长对元素进行插入排序，一次插入排序是稳定的，不会改变相同元素的相对顺序，但在不同的插入排序过程中，相同的元素可能在各自的插入排序中移动，稳定性就会被破坏，所以希尔排序不稳定。

（3）简单选择排序：在一趟选择，如果当前元素比一个元素小，而该小的元素又出现在一个和当前元素相等的元素后面，那么交换后稳定性就被破坏了。光说可能有点模糊，来看个小实例：858410，第一遍扫描，第1个元素8会和4交换，那么原序列中2个8的相对前后顺序和原序列不一致了，所以选择排序不稳定。

（4）堆排序：堆排序的过程是从第n/2开始和其子节点共3个值选择最大(大顶堆)或者最小(小顶堆),这3个元素之间的选择当然不会破坏稳定性。但当为n/2-1, n/2-2, ...这些父节点选择元素时，有可能第n/2个父节点交换把后面一个元素交换过去了，而第n/2-1个父节点把后面一个相同的元素没有交换，所以堆排序并不稳定。

（5）冒泡排序：由前面的内容可知，冒泡排序是相邻的两个元素比较，交换也发生在这两个元素之间，如果两个元素相等，不用交换。所以冒泡排序稳定。

（6）快速排序：在中枢元素和序列中一个元素交换的时候，很有可能把前面的元素的稳定性打乱。还是看一个小实例：6 4 4 5 4 7 8 9，第一趟排序，中枢元素6和第三个4交换就会把元素4的原序列破坏，所以快速排序不稳定。

（7）归并排序：在分解的子列中，有1个或2个元素时，1个元素不会交换，2个元素如果大小相等也不会交换。在序列合并的过程中，如果两个当前元素相等时，我们把处在前面的序列的元素保存在结果序列的前面，所以，归并排序也是稳定的。

（8）基数排序：是按照低位先排序，然后收集；再按照高位排序，然后再收集；依次类推，直到最高位。有时候有些属性是有优先级顺序的，先按低优先级排序，再按高优先级排序，最后的次序就是高优先级高的在前，高优先级相同的低优先级高的在前。基数排序基于分别排序，分别收集，所以是稳定的。

8种排序的分类，稳定性，时间复杂度和空间复杂度总结：

三种查找算法:顺序查找，二分法查找（折半查找），分块查找，散列表（以后谈）

一、顺序查找的基本思想：

从表的一端开始，顺序扫描表，依次将扫描到的结点关键字和给定值（假定为a）相比较，若当前结点关键字与a相等，则查找成功；若扫描结束后，仍未找到关键字等于a的结点，则查找失败。

说白了就是，从头到尾，一个一个地比，找着相同的就成功，找不到就失败。很明显的缺点就是查找效率低。

适用于线性表的顺序存储结构和链式存储结构。

计算平均查找长度。

例如上表，查找1，需要1次，查找2需要2次，依次往下推，可知查找16需要16次，

可以看出，我们只要将这些查找次数求和（我们初中学的，上底加下底乘以高除以2），然后除以结点数，即为平均查找长度。

设n=节点数

平均查找长度=（n+1）/2

二、二分法查找（折半查找）的基本思想：

前提：

（1）确定该区间的中点位置：mid=（low+high）/2

min代表区间中间的结点的位置，low代表区间最左结点位置，high代表区间最右结点位置

（2）将待查a值与结点mid的关键字（下面用R[mid].key）比较，若相等，则查找成功，否则确定新的查找区间：

如果R[mid].key>a，则由表的有序性可知，R[mid].key右侧的值都大于a，所以等于a的关键字如果存在，必然在R[mid].key左边的表中。这时high=mid-1

如果R[mid].key<a,则等于a的关键字如果存在，必然在R[mid].key右边的表中。这时low=mid

如果R[mid].key=a，则查找成功。

（3）下一次查找针对新的查找区间，重复步骤（1）和（2）

（4）在查找过程中，low逐步增加，high逐步减少，如果high<low，则查找失败。

平均查找长度=Log2(n+1)-1

注：虽然二分法查找的效率高，但是要将表按关键字排序。而排序本身是一种很费时的运算，所以二分法比较适用于顺序存储结构。为保持表的有序性，在顺序结构中插入和删除都必须移动大量的结点。因此，二分查找特别适用于那种一经建立就很少改动而又经常需要查找的线性表。

三、分块查找的基本思想：

二分查找表使分块有序的线性表和索引表（抽取各块中的最大关键字及其起始位置构成索引表

）组成，由于表是分块有序的，所以索引表是一个递增有序表，因此采用顺序或二分查找索引表，以确定待查结点在哪一块，由于块内无序，只能用顺序查找。

设表共n个结点，分b块，s=n/b

(分块查找索引表)平均查找长度=Log2（n/s+1）+s/2

(顺序查找索引表)平均查找长度=(S2+2S+n)/(2S)

注：分块查找的优点是在表中插入或删除一个记录时，只要找到该记录所属块，就在该块中进行插入或删除运算（因块内无序，所以不需要大量移动记录）。它主要代价是增加一个辅助数组的存储控件和将初始表分块排序的运算。

它的性能介于顺序查找和二分查找之间。

四、最近比较忙，后续找个时间还会谈谈散列表（哈希表）技术，希望大家关注！

散列表查找技术不同于顺序查找、二分查找、分块查找。它不以关键字的比较为基本操作，采用直接寻址技术。在理想情况下，无须任何比较就可以找到待查关键字，查找的期望时间为O(1)。

//矢量图和位图的区别

//介绍DC、了解DC
//CBrush brush(#ff0000);
//CClientDC dc(this->GetParent()->GetParent());
//CWindowDC dc(this);
//dc.FillRect(CRect(0,0,500,500),&brush);

//基本图形的绘制
//线段
pDC->MoveTo(20,30);
pDC->LineTo(300,30);
//矩形
pDC->Rectangle(20,50,300,200);
//椭圆
pDC->Ellipse(20,50,300,200);

CPen pen, *pOldPen;
CBrush brush, *pOldBrush;
//1.使用画笔
pen.CreatePen(PS_SOLID,6,#ff0000);
pOldPen=pDC->SelectObject(&pen);
pDC->MoveTo(20,250);
pDC->LineTo(300,250);
pDC->SelectObject(pOldPen);

//2.使用画刷(填充)
//创建一个蓝色的画刷
brush.CreateSolidBrush(#0000ff);
pOldBrush=pDC->SelectObject(&brush);
pDC->Rectangle(20,300,300,400);
pDC->SelectObject(pOldBrush);

//创建一个蓝色的网格画刷
brush.DeleteObject();
brush.CreateHatchBrush(HS_CROSS,#0000ff);
pOldBrush=pDC->SelectObject(&brush);
pDC->Rectangle(20,420,300,520);
pDC->SelectObject(pOldBrush);

//创建一个位图画刷
brush.DeleteObject();
CBitmap bitmap_brush;
bitmap_brush.LoadBitmap(IDB_BITMAP1);
brush.CreatePatternBrush(&bitmap_brush);
pOldBrush=pDC->SelectObject(&brush);
pDC->Rectangle(20,540,300,640);
pDC->SelectObject(pOldBrush);

//空画刷
brush.DeleteObject();
brush.CreateStockObject(NULL_BRUSH);
pDC->Rectangle(20,660,300,760);
pDC->SelectObject(pOldBrush);

//3.使用位图
//定义位图
CBitmap bitmap;

//保存位图信息;
BITMAP bmp;

//建立兼容设备
CDC dcCompatible;
dcCompatible.CreateCompatibleDC(pDC);

//从资源中装入位图
bitmap.LoadBitmap(IDB_BITMAP1);

//将位图选入设备
dcCompatible.SelectObject(&bitmap);

//获取位图信息
bitmap.GetBitmap(&bmp);

//拷贝
pDC->BitBlt(600,0,bmp.bmWidth,bmp.bmHeight,&dcCompatible,0,0,SRCCOPY);

//从文件中获取位图
HBITMAP hBitmap;
hBitmap=(HBITMAP)LoadImage(AfxGetInstanceHandle(),
"res\\ball.bmp", //实际位图文件的路径
IMAGE_BITMAP,0, 0,LR_LOADFROMFILE|LR_CREATEDIBSECTION);//从文件中装入位图
bitmap.Detach();
bitmap.Attach(hBitmap);
bitmap.GetBitmap(&bmp);

dcCompatible.SelectObject(&bitmap);

//绘制非透明位图（将dcCompatible上的内容拷贝到pDC中）
pDC->BitBlt(600,40,bmp.bmWidth,bmp.bmHeight,&dcCompatible,0,0,SRCCOPY);
pDC->StretchBlt(600,100,bmp.bmWidth*2,bmp.bmHeight*2,&dcCompatible,0,0,bmp.bmWidth,bmp.bmHeight,SRCCOPY);

//绘制透明位图（将dcCompatible上的内容拷贝到pDC中，同时去掉最后一个参数指定的颜色）
pDC->TransparentBlt(600,200,bmp.bmWidth,bmp.bmHeight,&dcCompatible,0,0,bmp.bmWidth,bmp.bmHeight,#ff0000);

//4.输出文字
pDC->SetTextColor(#ff0000);
pDC->SetBkMode(TRANSPARENT);

CFont font;//当前字体
font.CreateFont(32,0,0,0,FW_NORMAL,FALSE,FALSE,0,ANSI_CHARSET,OUT_DEFAULT_PRECIS,CLIP_DEFAULT_PRECIS,ANTIALIASED_QUALITY,DEFAULT_PITCH | FF_SWISS,"宋体");

CFont *pOldFont=pDC->SelectObject(&font);

pDC->TextOut(50,320,"输出文字");
CSize cs;
cs=pDC->GetTextExtent("输出文字");
pDC->TextOut(50+cs.cx,320,"abcdefg");
pDC->SelectObject(pOldFont);

//复杂图形
int step=30;
int center_x=700;
int center_y=500;
float x,y;
x=center_x-300;
y=sin(x/600*6*3.14)*100;
pDC->MoveTo(x,center_y+y);
while (x<center_x+300)
{
y=sin(x/600*6*3.14)*100;
pDC->LineTo(x,center_y+y);
x+=step;
}

lua作为小巧精悍的脚本语言，易于嵌入c/c++中 ， 广泛应用于游戏AI ，实际上在任何经常变化的逻辑上都可以使用lua实现，配合c/c++实现的底层接口服务，能够大大降低系统的维护成本。下面对lua和c/c++的交互调用做一个实例分析：
lua提供了API用于在c/c++中构造lua的运行环境，相关接口如下：
//创建lua运行上下文
lua_State* luaL_newstate(void) ;
//加载lua脚本文件
int luaL_loadfile(lua_State *L, const char *filename);

lua和c/c++的数据交互通过"栈"进行 ,操作数据时，首先将数据拷贝到"栈"上，然后获取数据，栈中的每个数据通过索引值进行定位，索引值为正时表示相对于栈底的偏移索引，索引值为负时表示相对于栈顶的偏移索引，索引值以1或-1为起始值，因此栈顶索引值永远为-1 ,栈底索引值永远为1 。 "栈"相当于数据在lua和c/c++之间的中转地。每种数据都有相应的存取接口 。
数据入"栈"接口：
void (lua_pushnil) (lua_State *L);
void (lua_pushnumber) (lua_State *L, lua_Number n);
void (lua_pushinteger) (lua_State *L, lua_Integer n);
void (lua_pushlstring) (lua_State *L, const char *s, size_t l);
void (lua_pushstring) (lua_State *L, const char *s);
void (lua_pushboolean) (lua_State *L, int b);
void (lua_pushcclosure) (lua_State *L, lua_CFunction fn, int n);

数据获取接口：
lua_Number (lua_tonumber) (lua_State *L, int idx);
lua_Integer (lua_tointeger) (lua_State *L, int idx);
int (lua_toboolean) (lua_State *L, int idx);
const char *(lua_tolstring) (lua_State *L, int idx, size_t *len);
lua_CFunction (lua_tocfunction) (lua_State *L, int idx);


"栈"操作接口：
int (lua_gettop) (lua_State *L);
void (lua_settop) (lua_State *L, int idx);
void (lua_pushvalue) (lua_State *L, int idx);
void (lua_remove) (lua_State *L, int idx);
void (lua_insert) (lua_State *L, int idx);
void (lua_replace) (lua_State *L, int idx);
int (lua_checkstack) (lua_State *L, int sz);

lua中定义的变量和函数存放在一个全局table中，索引值为LUA_GLOBALSINDEX ，table相关操作接口：
void (lua_gettable) (lua_State *L, int idx);
void (lua_getfield) (lua_State *L, int idx, const char *k);
void (lua_settable) (lua_State *L, int idx);
void (lua_setfield) (lua_State *L, int idx, const char *k);

当"栈"中包含执行脚本需要的所有要素(函数名和参数)后，调用lua_pcall执行脚本：
int (lua_pcall) (lua_State *L, int nargs, int nresults, int errfunc);

下面进行实例说明：
func.lua

test_lua.c

一、TCP/IP 体系结构与特点

　　1、TCP/IP体系结构

　　TCP/IP协议实际上就是在物理网上的一组完整的网络协议。其中TCP是提供传输层服务，而IP则是提供网络层服务。TCP/IP包括以下协议：（结构如图1.1）

(图1.1)

　　IP： 网间协议(Internet Protocol) 负责主机间数据的路由和网络上数据的存储。同时为ICMP，TCP，　　　UDP提供分组发送服务。用户进程通常不需要涉及这一层。

　　ARP： 地址解析协议(Address Resolution Protocol)
　　　此协议将网络地址映射到硬件地址。

　　RARP： 反向地址解析协议(Reverse Address Resolution Protocol)
　　　此协议将硬件地址映射到网络地址

　　ICMP： 网间报文控制协议(Internet Control Message Protocol)
　　　此协议处理信关和主机的差错和传送控制。

　　TCP： 传送控制协议(Transmission Control Protocol)
　　　这是一种提供给用户进程的可靠的全双工字节流面向连接的协议。它要为用户进程提供虚电路服务，并为数据可靠传输建立检查。（注：大多数网络用户程序使用TCP）

　　UDP： 用户数据报协议(User Datagram Protocol)
　　　这是提供给用户进程的无连接协议，用于传送数据而不执行正确性检查。

　　FTP： 文件传输协议(File Transfer Protocol)
　　　允许用户以文件操作的方式（文件的增、删、改、查、传送等）与另一主机相互通信。

　　SMTP： 简单邮件传送协议(Simple Mail Transfer Protocol)
　　　SMTP协议为系统之间传送电子邮件。

　　TELNET：终端协议(Telnet Terminal Procotol)
　　　允许用户以虚终端方式访问远程主机

　　HTTP： 超文本传输协议(Hypertext Transfer Procotol)
　　
　　TFTP: 简单文件传输协议(Trivial File Transfer Protocol)

　　2、TCP/IP特点

　　TCP/IP协议的核心部分是传输层协议(TCP、UDP)，网络层协议(IP)和物理接口层，这三层通常是在操作系统内核中实现。因此用户一般不涉及。编程时，编程界面有两种形式：一、是由内核心直接提供的系统调用；二、使用以库函数方式提供的各种函数。前者为核内实现，后者为核外实现。用户服务要通过核外的应用程序才能实现，所以要使用套接字(socket)来实现。

　　图1.2是TCP/IP协议核心与应用程序关系图。


(图1.2)

　　二、专用术语

　　1、套接字

　　套接字是网络的基本构件。它是可以被命名和寻址的通信端点，使用中的每一个套接字都有其类型和一个与之相连听进程。套接字存在通信区域（通信区域又称地址簇）中。套接字只与同一区域中的套接字交换数据（跨区域时，需要执行某和转换进程才能实现）。WINDOWS 中的套接字只支持一个域——网际域。套接字具有类型。

　　WINDOWS SOCKET 1.1 版本支持两种套接字：流套接字(SOCK_STREAM)和数据报套接字(SOCK_DGRAM)

　　2、WINDOWS SOCKETS 实现

　　一个WINDOWS SOCKETS 实现是指实现了WINDOWS SOCKETS规范所描述的全部功能的一套软件。一般通过DLL文件来实现

　　3、阻塞处理例程

　　阻塞处理例程(blocking hook,阻塞钩子)是WINDOWS SOCKETS实现为了支持阻塞套接字函数调用而提供的一种机制。

　　4、多址广播（multicast，多点传送或组播）

　　是一种一对多的传输方式，传输发起者通过一次传输就将信息传送到一组接收者，与单点传送
(unicast)和广播(Broadcast)相对应。

一、客户机/服务器模式

　　在TCP/IP网络中两个进程间的相互作用的主机模式是客户机/服务器模式(Client/Server model)。该模式的建立基于以下两点：1、非对等作用；2、通信完全是异步的。客户机/服务器模式在操作过程中采取的是主动请示方式：

　　首先服务器方要先启动，并根据请示提供相应服务：（过程如下）

　　1、打开一通信通道并告知本地主机，它愿意在某一个公认地址上接收客户请求。

　　2、等待客户请求到达该端口。

　　3、接收到重复服务请求，处理该请求并发送应答信号。

　　4、返回第二步，等待另一客户请求

　　5、关闭服务器。

　　客户方：

　　1、打开一通信通道，并连接到服务器所在主机的特定端口。

　　2、向服务器发送服务请求报文，等待并接收应答；继续提出请求……

　　3、请求结束后关闭通信通道并终止。

　　二、基本套接字

　　为了更好说明套接字编程原理，给出几个基本的套接字，在以后的篇幅中会给出更详细的使用说明。

　　1、创建套接字——socket()

　　功能：使用前创建一个新的套接字

　　格式：SOCKET PASCAL FAR socket(int af,int type,int procotol);

　　参数：af: 通信发生的区域

　　type: 要建立的套接字类型

　　procotol: 使用的特定协议

　　2、指定本地地址——bind()

　　功能：将套接字地址与所创建的套接字号联系起来。

　　格式：int PASCAL FAR bind(SOCKET s,const struct sockaddr FAR * name,int namelen);

　　参数：s: 是由socket()调用返回的并且未作连接的套接字描述符（套接字号）。

　　其它：没有错误，bind()返回0，否则SOCKET_ERROR

　　地址结构说明：

struct sockaddr_in
{
short sin_family;//AF_INET
u_short sin_port;//16位端口号，网络字节顺序
struct in_addr sin_addr;//32位IP地址，网络字节顺序
char sin_zero[8];//保留
}

　　3、建立套接字连接——connect()和accept()

　　功能：共同完成连接工作

　　格式：int PASCAL FAR connect(SOCKET s,const struct sockaddr FAR * name,int namelen);

　　SOCKET PASCAL FAR accept(SOCKET s,struct sockaddr FAR * name,int FAR * addrlen);

　　参数：同上

　　4、监听连接——listen()

　　功能：用于面向连接服务器，表明它愿意接收连接。

　　格式：int PASCAL FAR listen(SOCKET s, int backlog);

　　5、数据传输——send()与recv()

　　功能：数据的发送与接收

　　格式：int PASCAL FAR send(SOCKET s,const char FAR * buf,int len,int flags);

　　int PASCAL FAR recv(SOCKET s,const char FAR * buf,int len,int flags);

　　参数：buf:指向存有传输数据的缓冲区的指针。

　　6、多路复用——select()

　　功能：用来检测一个或多个套接字状态。

　　格式：int PASCAL FAR select(int nfds,fd_set FAR * readfds,fd_set FAR * writefds,
fd_set FAR * exceptfds,const struct timeval FAR * timeout);

　　参数：readfds:指向要做读检测的指针

　　　　　writefds:指向要做写检测的指针

　　　　　exceptfds:指向要检测是否出错的指针

　　　　　timeout:最大等待时间

　　7、关闭套接字——closesocket()

　　功能：关闭套接字s

　　格式：BOOL PASCAL FAR closesocket(SOCKET s);

三、典型过程图

　　2.1 面向连接的套接字的系统调用时序图

 

　　2.2 无连接协议的套接字调用时序图



　2.3 面向连接的应用程序流程图

Windows Socket 程序设计

一、简介

　　Windows Sockets 是从 Berkeley Sockets 扩展而来的，其在继承 Berkeley Sockets 的基础上，又进行了新的扩充。这些扩充主要是提供了一些异步函数，并增加了符合WINDOWS消息驱动特性的网络事件异步选择机制。

　　Windows Sockets由两部分组成：开发组件和运行组件。

　　开发组件：Windows Sockets 实现文档、应用程序接口(API)引入库和一些头文件。

　　运行组件：Windows Sockets 应用程序接口的动态链接库(WINSOCK.DLL)。

　　二、主要扩充说明

　　1、异步选择机制：

　　Windows Sockets 的异步选择函数提供了消息机制的网络事件选择，当使用它登记网络事件发生时，应用程序相应窗口函数将收到一个消息，消息中指示了发生的网络事件，以及与事件相关的一些信息。

　　Windows Sockets 提供了一个异步选择函数 WSAAsyncSelect()，用它来注册应用程序感兴趣的网络事件，当这些事件发生时，应用程序相应的窗口函数将收到一个消息。

　　函数结构如下：

 

int PASCAL FAR WSAAsyncSelect(SOCKET s,HWND hWnd,unsigned int wMsg,long lEvent);

 

　　参数说明：

　　　hWnd：窗口句柄

　　　wMsg：需要发送的消息

　　　lEvent：事件（以下为事件的内容）

 

值：	含义：
FD_READ	期望在套接字上收到数据（即读准备好）时接到通知
FD_WRITE	期望在套接字上可发送数据（即写准备好）时接到通知
FD_OOB	期望在套接字上有带外数据到达时接到通知
FD_ACCEPT	期望在套接字上有外来连接时接到通知
FD_CONNECT	期望在套接字连接建立完成时接到通知
FD_CLOSE	期望在套接字关闭时接到通知

 

　　例如：我们要在套接字读准备好或写准备好时接到通知，语句如下：

 

rc=WSAAsyncSelect(s,hWnd,wMsg,FD_READ|FD_WRITE);

 

　　如果我们需要注销对套接字网络事件的消息发送，只要将 lEvent 设置为0

　　2、异步请求函数

　　在 Berkeley Sockets 中请求服务是阻塞的，WINDOWS SICKETS 除了支持这一类函数外，还增加了相应的异步请求函数(WSAAsyncGetXByY();)。

　　3、阻塞处理方法

　　Windows Sockets 为了实现当一个应用程序的套接字调用处于阻塞时，能够放弃CPU让其它应用程序运行，它在调用处于阻塞时便进入一个叫“HOOK”的例程，此例程负责接收和分配WINDOWS消息，使得其它应用程序仍然能够接收到自己的消息并取得控制权。

　　WINDOWS 是非抢先的多任务环境，即若一个程序不主动放弃其控制权，别的程序就不能执行。因此在设计Windows Sockets 程序时，尽管系统支持阻塞操作，但还是反对程序员使用该操作。但由于 SUN 公司下的 Berkeley Sockets 的套接字默认操作是阻塞的，WINDOWS 作为移植的 SOCKETS 也不可避免对这个操作支持。

　　在Windows Sockets 实现中，对于不能立即完成的阻塞操作做如下处理：DLL初始化→循环操作。在循环中，它发送任何 WINDOWS 消息，并检查这个 Windows Sockets 调用是否完成，在必要时，它可以放弃CPU让其它应用程序执行（当然使用超线程的CPU就不会有这个麻烦了^_^）。我们可以调用 WSACancelBlockingCall() 函数取消此阻塞操作。

　　在 Windows Sockets 中，有一个默认的阻塞处理例程 BlockingHook() 简单地获取并发送 WINDOWS 消息。如果要对复杂程序进行处理，Windows Sockets 中还有 WSASetBlockingHook() 提供用户安装自己的阻塞处理例程能力；与该函数相对应的则是 SWAUnhookBlockingHook()，它用于删除先前安装的任何阻塞处理例程，并重新安装默认的处理例程。请注意，设计自己的阻塞处理例程时，除了函数 WSACancelBlockingHook() 之外，它不能使用其它的 Windows Sockets API 函数。在处理例程中调用 WSACancelBlockingHook()函数将取消处于阻塞的操作，它将结束阻塞循环。

　　4、出错处理

　　Windows Sockets 为了和以后多线程环境（WINDOWS/UNIX）兼容，它提供了两个出错处理函数来获取和设置当前线程的最近错误号。（WSAGetLastEror()和WSASetLastError()）

　　5、启动与终止

　　使用函数 WSAStartup() 和 WSACleanup() 启动和终止套接字。

 

来自网络

实例

static void* listenconnect(void* param)
{
int sockfd = socket (PF_UNIX, SOCK_SEQPACKET, 0); //创建本地套接字
fcntl(sockfd, F_SETFL, O_NONBLOCK);
sockaddr_un myaddr;
memset (&myaddr, 0, sizeof(myaddr));
myaddr.sun_family = PF_UNIX;
strcpy (myaddr.sun_path, "@/brainaire_nvr/trans_serv/socket"); //套接字的名字，任意取
myaddr.sun_path[0] = 0;
bind (sockfd, (struct sockaddr*)&myaddr, sizeof(myaddr)); //将套接字与它的名字绑定
listen(sockfd, 50);

fd_set watchset, listenset, clientset;
FD_ZERO(&clientset);
FD_ZERO(&watchset);
FD_ZERO(&listenset);
FD_SET(sockfd, &listenset);
int max_listen = sockfd + 1;
int max_client = 0;
while (!process_exit)
{
watchset = listenset;
struct timeval tv;
tv.tv_sec = 0;
tv.tv_usec = 1000;
if (select(max_listen, &watchset, NULL, NULL, &tv) > 0 && FD_ISSET(sockfd, &watchset))
{
struct sockaddr addr;
socklen_t len;
int clientfd = accept(sockfd, &addr, &len);
if (clientfd < 0)
perror("accept");
else
{
if (clientfd >= max_client)
max_client = clientfd + 1;
FD_SET(clientfd, &clientset);
}
}
watchset = clientset;
tv.tv_sec = 0;
tv.tv_usec = 1000;
int ret = select(max_client, &watchset, NULL, NULL, &tv);
if (ret > 0)
{
for (int clientfd = max_client - 1; clientfd > 0; clientfd--)
{
int flags = 0;
char buff[BUFSIZ];
int len;
if (FD_ISSET(clientfd, &watchset))
{
len = recv(clientfd, buff, sizeof(buff), flags);
if (len <= 0)
{
FD_CLR(clientfd, &clientset);
fprintf(stderr, "[nvradmin] client socket %d closed.\n", clientfd);
close(clientfd);
if (clientfd == max_client - 1)
max_client --;
}
else
{
bool monitorworking = false;
buff[len] = 0;
int monitorID = atoi(buff);
if (monitorID != 0)
{
MyRW_Lock mylock(&monitorlock);
#if THREAD_NUM
list<MonitorDaemon>& monitors = monitorslists[monitorID%THREAD_NUM];
#endif
for (list<MonitorDaemon>::iterator intr = monitors.begin(); intr
!= monitors.end(); intr ++)
{
MonitorDaemon m_daemon = *intr;
if (m_daemon.monitor == NULL)
break;
if (m_daemon.monitor->Id() == monitorID)
{
fprintf(stderr, "[nvradmin] Start Transmitting RealPlay Data to client socket %d\n", clientfd);
monitorworking = (0 == m_daemon.monitor->StartTransData(clientfd));
}
}
}
else
fprintf(stderr, "[nvradmin] Received Msgs: len %d, content: %s\n", len, buff);

if(!monitorworking)
{
FD_CLR(clientfd, &clientset);
fprintf(stderr, "[nvradmin] Cannot Start Tranmitting, client Socket %d Closed.\n", clientfd);
close(clientfd);
if (clientfd == max_client - 1)
max_client --;
}
}
}
}
}
if(ret < 0)
perror("Select Connected Sockets");
usleep(0);
}
close(sockfd);
return 0;
}

三、MFC CAsyncSocket

但由于都是直接利用动态连接库wsock32.dll进行操作，实现比较繁琐。其实，为简化套接字编程，MFC 定义了两个套接字类：CAsyncSocket、CSocket。CAsyncSocket类在低层次上对 Windows Sockets API 进行了封装，其成员函数和 Windows Sockets API 函数直接相对应 。一个CAsyncSocket对 象 就 代 表 了一 个 套 接 字。而CSocket继承于CAsyncSocket 类，是对 Windows Sockets API 的高级封装。
建立Socket的WSAStartup过程和bind过程被简化成为Create过程，IP地址类型转换、主机名和IP地址转换的过程中许多复杂的变量类型都被简化成字符串和整数操作，特别是CAsyncSocket类的异步特点，完全可以替代繁琐的线程操作。
一、1.CAsyncSocket 类直接派生于CObject类，称为异步套接字对象。由于 CAsyncSocket类的构造函数不带参数，需要调用起成员函数 Create 来创建底层的套接字句柄，决定套接字对象的具体特性，并绑定它的地址。
BOOL Create( UINT nSocketPort=0，
Int nSocketType = SOCK_STREAM,
Long Ievent=FD_READ|FD_WRITE|FD_OOB|FD_ACCEPT|FD_CONNECT|FD_CLOSE,
LPCTSTR lpszSocketAddress = NULL );

CAsyncSocket 类的 6 种网络事件
事 件 涵 义 对应处理函数
FD_ACCEPT 通知侦听套接字当前有连接请求可以接受 OnAccept(int nErrorCode);
FD_CONNECT 通知请求连接的套接字，连接要求已被处理 OnConnect(int nErrorCode);
FD_CLOSE 通知套接字与其连接的套接字已关闭 OnClose(int nErrorCode);
FD_READ 通知有数据到达 OnReceive(int nErrorCode);
FD_WRITE 通知可以发送数据 OnSend(int nErrorCode);
FD_OOB 通知将有外带数据到达 OnOutOfBandData(int ErrorCode);

当某个网络事件发生时，MFC 框架把消息发送给相应的套接字对象，相当于给了该对象一个通知，告诉它某个重要的事件已经发生，接着自动调用该对象的事件处理函数。

2.如果从 CAsyncSocket 类派生了自己的套接字类，则必须重载某些网络事件所对应的通知函数。
3.服务器端
与Winsock不同，CAsyncSocket服务端不用绑定(Bind)，不用连接(Connect)。
正常情况下，服务器端必须首先创建一个 CAsyncSocket 套接字对象，并调用它的 Create成员函数创建底层套接字句柄。这个套接字对象专门用来侦听来自客户机的连接请求，所以称它为侦听套接字对象。再调用侦听套接字对象的

Listen 函数，使侦听套接字对象开始侦听来自客户端的连接请求。
(1) 当 Listen 函数确认并接纳了一个客户端连接请求后，触发 FD_ACCEPT 事件，侦听套接字收到通知，MFC 框架自动调用侦听套接字的 OnAccept 事件处理函数。一般需要重载 OnAccept 函数，再在其中调用侦听套接字对象的

Accept 函数。
(2) 创建一个新的空套接字对象，专门用来与客户端连接并进行数据的传输，一般称为连接套接字，并作为参数传递给下一步的 Accept 成员函数。m_sListenSocket.Accept(m_sConnectSocket);
4.客户端
客户端请求连接到服务器端，在服务器端套接字对象已经进入侦听状态之后，客户应用程序可以调用CAsyncSocket类的 Connect 成员函数，向服务器发出一个连接请求。调用结束返回时发生FD_CONNECT事件，MFC 框架会自动调用客户端套接字的 OnConnect 事件处理函数。
CSocket 类是 CAsyncSocket 的派生类。创建 CSocket 对象时，首先要调用 CSocket 类
的构造函数创建一个空的 CSocket 对象，再调用其 Create 成员函数，创建对象的底层套
接字。

BOOL Create(
UINT nSocketPort = 端口号，
Int nSocketPort = SOCK_STREAM | SOCK_DGRAM，
LPCTSTR lpszSocketAddress = 套接字所用的网络地址 )；
二、CSocket 类使用基类 CAsyncSocket 的同名成员函数 Connect、Listen、Accept 来建立服务器和客户机套接字之间的连接，使用方法基本相同。在创建 CSocket 类对象后，对于流式套接字，首先在服务器和客户机之间建立连接，然后使用 Send 函数、Receive 函数来发送和接收数据。
需要注意的是，CSocket对象从不调用OnConnect和OnSend事件处理函数。CSocket类继承了 CAsyncSocket 类的许多成员函数，用法基本一致。CSocket类的高级性主要表现在3个方面。
(1) CSocket 结合 CArchive 类来使用套接字。
(2) CSocket 管理了通信的许多方面，比如字节顺序问题和字符串转换问题。
(3) CSocket 类为 Windows 消息的后台处理提供了阻塞的工作模式。有关阻塞的概念读者可参阅相关文献资料，此处不再赘述。
因此，一般将 CSocket 与 CArchive、CSocketFile 类相结合，来发送和接收数据，这将使编程更为简单。

===============================================================================
---- 一个Echo例程来介绍CAsyncSocket类的用法。

---- 一． 客户端

---- 1． 创建一个Dialog Based项目：CSockClient。

---- 2． 设计对话框

---- 去掉Ok和Cancle两个按钮，增加ID_Connect（连接）、ID_Send（发送）、ID_Exit（关闭）按钮，增加ListBox控件IDC_LISTMSG和Edit控件IDC_EDITMSG，并按下表在ClassWizard中为CCSockClientDlg类添加变量。

Control ID Type Member

IDC_EDITMSG CEdit m_MSG
IDC_LISTMSG ClistBox m_MSGS

---- 3． CAsyncSocket类用DoCallBack函数处理MFC消息，当一个网络事件发生时，DoCallBack函数按网络事件类型：FD_READ、FD_WRITE、FD_ACCEPT、FD_CONNECT分别调用OnReceive、OnSend、OnAccept、OnConnect函数。由于MFC把这些事件处理函数定义为虚函数，所以要生成一个新的C++类，以重载这些函数，做法如下：

---- 以Public方式继承CAsyncSocket类，生成新类MySock；

---- 为MySock类添加虚函数OnReceive、OnConnect、OnSend

---- 4． 在MySock.**中添加以下代码

#include "CSockClient.h"
#include "CSockClientDlg.h"

---- 5． 在MySock.h中添加以下代码

public:
BOOL m_bConnected; //是否连接
UINT m_nLength; //消息长度
char m_szBuffer[4096]; //消息缓冲区

---- 6． 在MySock.**中重载各函数

MySock::MySock()
{
m_nLength=0;
memset(m_szBuffer,0,sizeof(m_szBuffer));
m_bConnected=FALSE;
}

MySock::~MySock()
{
//关闭套接字
if(m_hSocket!=INVALID_SOCKET)
Close();
}

void MySock::OnReceive(int nErrorCode)
{
m_nLength=Receive(m_szBuffer,sizeof(m_szBuffer),0);
//下面两行代码用来获取对话框指针
CCSockClientApp* pApp=(CCSockClientApp*)AfxGetApp();
CCSockClientDlg* pDlg=(CCSockClientDlg*)pApp- >m_pMainWnd;
pDlg- >m_MSGS.InsertString(0,m_szBuffer);
memset(m_szBuffer,0,sizeof(m_szBuffer));
CAsyncSocket::OnReceive(nErrorCode);
}

void MySock::OnSend(int nErrorCode)
{
Send(m_szBuffer,m_nLength,0);
m_nLength=0;
memset(m_szBuffer,0,sizeof(m_szBuffer));
//继续提请一个“读”的网络事件，接收Server消息
AsyncSelect(FD_READ);
CAsyncSocket::OnSend(nErrorCode);
}

void MySock::OnConnect(int nErrorCode)
{
if (nErrorCode==0)
{
m_bConnected=TRUE;
CCSockClientApp* pApp=(CCSockClientApp*)AfxGetApp();
CCSockClientDlg* pDlg=(CCSockClientDlg*)pApp- >m_pMainWnd;
memcpy(m_szBuffer,"Connected to ",13);
strncat(m_szBuffer,pDlg- >m_szServerAdr,
sizeof(pDlg- >m_szServerAdr));
pDlg- >m_MSGS.InsertString(0,m_szBuffer);
AsyncSelect(FD_READ); ////提请一个“读”的网络事件，准备接收
}
CAsyncSocket::OnConnect(nErrorCode);
}

---- 7． 新建对话框IDD_Addr，用来输入IP地址和Port；生成新类CAddrDlg。增加两个Edit控件：IDC_Addr、IDC_Port按下表在ClassWizard中为CAddrDlg类添加变量。

Control ID Type Member

IDC_Addr CString m_Addr
IDC_Port Int m_Port

---- 8． 在CSockClientDlg.h中添加代码

#include "AddrDlg.h"
protected:
int TryCount;
MySock m_clientSocket;
UINT m_szPort;
public:
char m_szServerAdr[256];

---- 9． 双击IDD_CSOCKCLIENT_DIALOG对话框中的“连接”按钮，添加以下代码

void CCSockClientDlg::OnConnect()
{
m_clientSocket.ShutDown(2);
m_clientSocket.m_hSocket=INVALID_SOCKET;
m_clientSocket.m_bConnected=FALSE;
CAddrDlg m_Dlg;
//默认端口1088
m_Dlg.m_Port=1088;
if (m_Dlg.DoModal()==IDOK && !m_Dlg.m_Addr.IsEmpty())
{
memcpy(m_szServerAdr,m_Dlg.m_Addr,sizeof(m_szServerAdr));
m_szPort=m_Dlg.m_Port;
//建立计时器，每1秒尝试连接一次，直到连上或TryCount>10
SetTimer(1,1000,NULL);
TryCount=0;
}
}

---- 10． 添加Windows消息WM_TIMER响应函数OnTimer

void CCSockClientDlg::OnTimer(UINT nIDEvent)
{
if (m_clientSocket.m_hSocket==INVALID_SOCKET)
{
BOOL bFlag=m_clientSocket.Create(0,SOCK_STREAM,FD_CONNECT);
if(!bFlag)
{
AfxMessageBox("Socket Error!");
m_clientSocket.Close();
PostQuitMessage(0);
return;
}
}
m_clientSocket.Connect(m_szServerAdr,m_szPort);
TryCount++;
if (TryCount >=10 || m_clientSocket.m_bConnected)
{
KillTimer(1);
if (TryCount >=10)
AfxMessageBox("Connect Failed!");
return;
}
CDialog::OnTimer(nIDEvent);
}

---- 11． 双击IDD_CSOCKCLIENT_DIALOG对话框中的“发送”按钮，添加以下代码

void CCSockClientDlg::OnSend()
{
if (m_clientSocket.m_bConnected)
{
m_clientSocket.m_nLength=m_MSG.GetWindowText
(m_clientSocket.m_szBuffer, sizeof(m_clientSocket.m_szBuffer));
m_clientSocket.AsyncSelect(FD_WRITE);
m_MSG.SetWindowText("");
}
}

---- 12． 双击IDD_CSOCKCLIENT_DIALOG对话框中的“关闭”按钮，添加以下代码

void CCSockClientDlg::OnExit()
{
//关闭Socket
m_clientSocket.ShutDown(2);
//关闭对话框
EndDialog(0);
}

----
12．运行此项目，连接时输入主机名或IP均可，CAsyncSocket类会自动处理。
----
二． 服务端
----
Server端的编程与Client端的类似，下面主要介绍他的Listen及Accept函数
----
1． 建立一个CNewSocket类，重载CAsyncSocket类的OnReceive、OnSend函数，如何进行信息的显示和发送可以参考Client程序。本例中采用将收到信息原封不动发回的方法来实现Echo功能，代码如下
CNewSocket：：OnReceive（int nErrorCOde）
{
m_nLength=Receive（m_szBuffer，sizeof（m_szBuffer），0）；
// 直接转发消息
AsyncSelect（FD_WRITE）；
}

CNewSocket：：OnSend（int nErrorCode）
{
Send（m_szBuffer，m_nLength，0）；
}

----
2． 建立一个CMyServerSocket类，重载CAsyncSocket类的OnAccept函数代码如下
----
在MyServerSocket.h中声明变量
public:：
CNewSocket* m_pSocket；

void CMyServerSocket：：OnAccept（int nErrorCode）
{
//侦听到连接请求，调用Accept函数
CNewSocket* pSocket = new CNewSocket（）；
if （Accept（*pSocket））
{
pSocket- >AsyncSelect（FD_READ）；
m_pSocket=pSocket；
}
else
delete pSocket；
}

----
3． 为对话框添加一个“侦听”按钮，添加如下代码
----
在CsockServerDlg.**中声明变量
public：
CMyServerSocket m_srvrSocket;
void CCSockServerDlg：：OnListen（）
{
if （m_srvrSocket.m_hSocket==INVALID_SOCKET）
{
BOOL bFlag=m_srvrSocket.Create
(UserPort，SOCK_STREAM，FD_ACCEPT)；
if （！bFlag）
{
AfxMessageBox（“Socket Error！”）；
M_srvrSocket.Close（）；
PostQuitMessage（0）；
Return；
}
}
//“侦听”成功，等待连接请求
if （！m_srvrSocket。Listen（1））
{
int nErrorCode = m_srvrSocket.GetLastError（）；
if （nError！=WSAEWOULDBLOCK）
{
AfxMessageBox（“Socket Error！”）；
M_srvrSocket.Close（）；
PostQuitMessage（0）；
Return；
}
}
}

----
4． 目前程序只能实现Echo功能，将信息原封不动的转发，若能将Accept中由CNewSocket* pSocket = new CNewSocket（）；得到的Socket指针存入一个CList或一个数组中，便像Client端那样，对所有的连接进行读写控制。

试验！