套接字的I/O模型(二)

最新推荐文章于 2018-06-08 11:12:22 发布
最新推荐文章于 2018-06-08 11:12:22 发布
阅读量508 收藏
点赞数 1
分类专栏： 网络编程 C++ 文章标签： windows 函数 io 套接字编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zt_xcyk/article/details/70144181
版权

套接字的I/O模型(二)

  1. overlapped模型

    • 相比于其他的I/O模型，重叠I/O(Overlapped I/O)模型使应用程序能达到更佳的系统性能。
    • 重叠模型的基本设计原理是：让应用程序使用重叠的数据结构，一次投递一个或多个Winsock I/O请求。针对那些提交的请求，在它们完成之后，应用程序可以为它们提供服务。
    • Windows重叠I/O机制可通过ReadFile和WriteFile两个函数，在设备上执行I/O操作。
    • 要想在一个套接字上使用重叠I/O模型，首先必须创建一个设置了重叠标志的套接字。成功建好一个套接字，同时将它与一个本地接口绑定到一起后，便可开始进行重叠I/O的操作，方法是调用下列的Winsock函数，同时指定一个可选的WSAOVERLAPPED结构。
    WSASend      WSASendTo   WSARecv     WSARecvFrom     WSAloctl    WSARecvMsg
AcceptEx ConnectEx   TransmitFile    TransmitPackets     DisconnectEx    WSANSPloctl

    ​ 为了使用重叠I/O，每个函数都把WSAOVERLAPPED结构作为参数。若用一个WSAOVERLAPPED结构一起调用这些函数，函数会立即完成并返回，而不管套接字是否设为阻塞模式。这些函数依赖于WSAOVERLAPPED结构来管理一个I/O请求的完成。

    • 主要有两个方法可用来管理重叠I/O请求完成情况：
      1. 应用程序可等待事件对象通知(event object notification)
      2. 可通过完成例程(completion routines)，对已经完成的请求加以处理。
    一：事件通知
    1. 重叠I/O的事件通知方法要求将Windows事件对象与WSAOVERLAPPED结构关联在一起。若使用一个WSAOVERLAPPED结构，发出像WSASend和WSARecvv这样的I/O调用，它们会立即返回。

      通常，大家会发现这些I/O调用会以失败而告终，并返回SOCKET_ERROR。使用WSAGetLastError函数，便可获得与WSA_IO_PENDING错误状态有关的一个报告。这个错误状态意味着I/O操作正在进行。稍后的某个时间，应用程序需要等候与WSAOVERLAPPED结构相关联的事件对象，判断某个重叠I/O请求何时完成。WSAOVERLAPPED结构为重叠I/O请求的初始化及其后续的完成之间提供了一种通信媒介。 

      typedef struct _WSAOVERLAPPED {
 DWORD    Internal;             //Reserved(保留)
 DWORD    InternalHigh;         //Reserved(保留)
 DWORD    Offset;                   //Reserved(保留)
 DWORD    OffsetHigh;               //Reserved(保留)
 WSAEVENT hEvent;                   //Reserved(保留)
} WSAOVERLAPPED, *LPWSAOVERLAPPED;   //Handle to a WSAEVENT object that represents an event


    其中前四个参数均由系统在内部使用，不能由应用程序直接进行处理或使用。 hEvent允许应用程序将事件对象的句柄同操作关联起来。
    1. 一个重叠I/O请求最终完成后，应用程序要负责获取重叠I/O操作的结果。一个重叠请求操作最终完成之后，在事件通知方法中，Winsock会更改与WSAOVERLAPPED结构关联的事件对象的事件传信状态，将其从未传信变成已传信。由于已经有一个事件对象分配给WSAOVERLAPPED结构，所以只需简单地调用WSAWaitForMultipleEvents函数，便可判断出重叠I/O调用将在什么时候完成（WSAWaitForMultipleEvents函数会等候一段指定的时间，等待一个或多个事件对象进入已传信状态。它一次最多等待64个事件对象）。

    2. 确认某个重叠请求完成之后，接着需要调用WSAGetOverlappedResult函数，判断这个重叠调用到底是成功还是失败。函数定义如下：

      BOOL WSAAPI WSAGetOverlappedResult(
 _In_  SOCKET          s,               //重叠操作开始时被指定的套接字
 _In_  LPWSAOVERLAPPED lpOverlapped,    //被指定的WSAOVERLAPPED结构
 _Out_ LPDWORD         lpcbTransfer,    //一次重叠发送或接收操作实际传输的字节数
 _In_  BOOL            fWait,           //决定函数是否应该等待挂起操作完成
 _Out_ LPDWORD         lpdwFlags        //接收结果
);
      • fWait为TRUE，那么除非操作完成，否则函数不会返回；若为FALSE，而操作仍然处于挂起状态，那么WSAGetOverlappedResult函数会返回FALSE值，同时返回一个WSA_IO_INCOMPLETE错误。但就目前的情况来说，由于需要在一个已传信事件上等候重叠操作完成，所以该参数无论采用什么设置，都没有任何效果。
      • lpdwFlags指向一个DWORD，负责接收结果标志（假如原先的重叠调用时用WSARecv或WSARecvFrom函数发出的）
      • 如果WSAGetOverlappedResult函数调用成功，返回值就是TRUE。这意味着重叠I/O操作已成功完成，而且lpcbTransfer参数所指向的值已进行了更新。若返回值是FALSE，那么可能是由下述任何一种原因造成的：
        1. 重叠I/O操作仍处于挂起状态
        2. 重叠操作已经完成，但含有错误
        3. 因为在提供给WSAGetOverlappedResult函数中的一个或多个参数中，存在着错误，所以无法判断重叠操作的完成状态。
          失败后，lpcbTransfer参数指向的值不会被更新，而且应用程序调用WSAGetLastError函数，查看到底是何种原因造成了调用失败。
    3. 代码示例： 
      
#include<winsock2.h>


#include<Ws2tcpip.h>


#include<stdio.h>


#pragma comment(lib,"WS2_32")



#define DATA_BUFSIZE 4096

void main(void)
{
WSABUF DataBuf;
char buffer[DATA_BUFSIZE];
DWORD EventTotal = 0, RecvBytes = 0, Flags = 0, BytesTransferred=0;
WSAEVENT EventArray[WSA_MAXIMUM_WAIT_EVENTS];
WSAOVERLAPPED AcceptOverlapped;
SOCKET ListenSocket, AcceptSocket;

//第一步  启动Winsock，建立监听套接字
//..............................//

//第二步 接受一个入站连接
AcceptSocket = accept(ListenSocket, NULL, NULL);

//第三步 建立一个重叠结构
EventArray[EventTotal] = WSACreateEvent();

memset(&AcceptOverlapped, 0, sizeof(WSAOVERLAPPED));
AcceptOverlapped.hEvent = EventArray[EventTotal];

DataBuf.len = DATA_BUFSIZE;
DataBuf.buf = buffer;

EventTotal++;

//第四步 投递一个WSARecv请求，以便开始在套接字上接收数据
if (WSARecv(AcceptSocket, &DataBuf, 1, &RecvBytes, &Flags, &AcceptOverlapped, NULL) == SOCKET_ERROR)
{
    if (WSAGetLastError() != WSA_IO_PENDING)
    {
        //出错.......
    }
}

//处理套接字上的重叠接收
while (TRUE)
{
    DWORD Index;

//第五步 等候重叠I/O调用结束
    Index = WSAWaitForMultipleEvents(EventTotal, EventArray, FALSE, WSA_INFINITE, FALSE);
//索引应为0，因为EventArray中仅有一个事件

//第六步 重置已传信事件
    WSAResetEvent(EventArray[Index - WSA_WAIT_EVENT_0]);

//第七步 确定重叠请求的状态
    WSAGetOverlappedResult(AcceptSocket, &AcceptOverlapped, &BytesTransferred, FALSE, &Flags);

//先检查 通信对方是否已关闭连接，如果已关闭，则关闭套接字
    if (BytesTransferred == 0)
    {
        printf("Closing socket %d \n", AcceptSocket);
        closesocket(AcceptSocket);
        WSACloseEvent(EventArray[Index - WSA_WAIT_EVENT_0]);
        return;
    }
//对接收到的数据进行某种处理    DataBuf包含接收到的数据
//第八步 在套接字上投递另一个WSARecv()请求
    Flags = 0;
    memset(&AcceptOverlapped, 0, sizeof(WSAOVERLAPPED));
    AcceptOverlapped.hEvent = EventArray[Index - WSA_WAIT_EVENT_0];
    DataBuf.len = DATA_BUFSIZE;
    DataBuf.buf = buffer;

    if (WSARecv(AcceptSocket, &DataBuf, 1, &RecvBytes, &Flags, &AcceptOverlapped, NULL) == SOCKET_ERROR)
    {
        if (WSAGetLastError() != WSA_IO_PENDING)
        {
            //未预料到的错误
        }
    }
}
}

    对该程序采用的编程步骤总结如下：

    1. 创建一个套接字，开始在指定的端口上监听连接请求
    2. 接受一个入站的连接请求
    3. 为接受的套接字新建一个WSAOVERLAPPED结构，并为该结构分配一个事件对象句柄。也将该事件对象句柄分配给一个事件数组，以便稍后由WSAWaitForMultipleEvents函数使用
    4. 将WSAOVERLAPPED结构指定为参数，在套接字上投递一个异步WSARecv请求
    5. 使用步骤3的事件数组，调用WSAWaitForMultipleEvents函数，并等待与重叠调用关联在一起的事件进入已传信状态
    6. 使用WSAGetOverlappedResult函数，判断重叠调用的返回状态是什么
    7. 函数完成后，针对事件数组，调用WSAResetEvent函数，从而重设事件对象，并对完成的重叠请求进行处理
    8. 在套接字上投递另一个重叠WSARecv请求
    9. 重复步骤5~8

    如果用重叠方式(在WSAOVERLAPPED结构内部指定一个事件，或利用一个完成例程)调用Winsock函数，则调用操作有可能立即完成。例如：在数据已经被接收到并放入缓冲区之后调用WSARecv，就会导致WSARecv返回NO_ERROR。如果任何重叠函数失败并返回WSA_IO_PENDING，或立刻成功，完成事件将总会被传信，而完成例程也将随时运行(如果已做了指定)。对于带完成端口的重叠I/O而言，这意味着完成通知将被传递到完成端口，使其开始服务。

    二：完成例程

    ​ 完成例程是应用程序用来管理完成的重叠I/O请求的另一种方法。完成例程其实就是一些函数，我们将这些函数传递给重叠I/O请求，以供重叠I/O请求完成时由系统调用。它们的基本设计宗旨是，通过调用者的线程，为已完成的I/O请求提供服务。除此之外，应用程序可通过完成例程，继续进行重叠I/O的处理。

    • 如果希望用完成例程为重叠I/O请求提供服务，应用程序必须为一个绑定I/O的Winsock函数指定一个完成例程，同时指定一个WSAOVERLAPPED结构。一个完成例程必须拥有下述函数原型：

      void CALLBACK CompletionROUTING
{
DWORD dwError,                  //重叠操作(由lpOverlapped指定)的完成状态是什么
DWORD cbTransferred,            //在重叠操作期间，实际传输的字节量
LPWSAOVERLAPPED lpOverlapped,   //传递到最初的I/O调用内的一个WSAOVERLAPPED结构
DWORD dwFlags                   //返回操作结束时可能用的标志(如：从WSARecv结束)
}

    • 在用一个完成例程提交的重叠请求与用一个事件对象提交的重叠请求之间，存在着一个非常重要的区别。WSAOVERLAPPED结构的事件字段hEvent并未被使用；也就是说，不可以将一个事件对象同重叠请求关联到一起。用完成例程发出重叠I/O调用之后，调用线程一旦完成，最终必须为完成例程提供服务。这样，便要求我们将调用线程设置与一种警觉的等待状态(alertable wait state)。并在I/O操作完成后，对完成例程加以处理。WSAWaitForMultipleEvents函数可用来将线程置于一种警觉的等待状态。这样做的缺点在于，我们还必须有一个事件对象可用于WSAWaitForMultipleEvents函数。假定应用程序用完成例程只对重叠请求进行处理，便不大可能又什么事件对象需要处理。作为一种变通方法，应用程序可用Windows的SleepEx函数将线程置为一种警觉的等待状态。当然，亦可创建一个伪事件对象，它不与任何东西关联在一起。假如调用线程总是处于繁忙状态，而不是处于一种警觉的等待状态，那么根本不会有投递的完成例程会得到调用。

    • 如前所见，WSAWaitForMultipleEvents通常会等待同WSAOVERLAPPED结构关联在一起的事件对象。该函数也用来将线程置入一种警觉的等待状态，并可为已经完成的重叠I/O请求进行完成例程的处理(前提是将fAlertable参数设为TRUE)。用完成例程结束重叠I/O请求之后，返回值是WSA_IO_COMPLETION，而不是事件数组中的一个事件对象的索引。SleepEx函数的行为实际上和WSAWaitForMultipleEvents差不多，只是它不需要任何事件对象。

      DWORD WINAPI SleepEx(
_In_ DWORD dwMilliseconds,   //等待时间 以ms(毫秒)为单位 INFINITE表示一直等待
_In_ BOOL  bAlertable            //完成例程的执行方式
);
//加入将bAlertable设为FALSE，而且进行了一次I/O完成回调，那么I/O完成函数就不会执行，而且该函数也不会返回，除非超过由dwMilliseconds规定的时间。若设为TRUE，那么完成例程会得到执行，同时SleepEX函数返回WAIT_IO_COMPLETION
    • 代码示例：（简单的服务器应用程序） 
      
#include<winsock2.h>


#include<Ws2tcpip.h>


#include<stdio.h>


#pragma comment(lib,"WS2_32")



#define DATA_BUFSIZE 4096

SOCKET AcceptSocket, ListenSocket;
WSABUF DataBuf;
WSAEVENT EventArray[MAXIMUM_WAIT_OBJECTS];
DWORD Flags, RecvBytes, Index;
char buffer[DATA_BUFSIZE];
void CALLBACK WorkerRoutine(DWORD Error, DWORD BytesTransferred, LPWSAOVERLAPPED Overlapped, DWORD InFlags);
int main(void)
{
WSAOVERLAPPED overlapped;
//第一步 启动Winsock，建立监听套接字
//..............................//

//第二步 接受一个新连接
AcceptSocket = accept(ListenSocket, NULL, NULL);

//第三步 已经有了一个接受套接字之后，开始使用带有完全例程的重叠I/O来处理I/O
//为了启动重叠I/O处理，先提交一个重叠WSARecv()请求
Flags = 0;
memset(&overlapped, 0, sizeof(WSAOVERLAPPED));
DataBuf.len = DATA_BUFSIZE;
DataBuf.buf = buffer;

//第四步 将WSAOVERLAPPED结构指定为一个参数，在套接字上投递一个异步WSARecv()请求并提供下面的
//作为完成例程的WorkerRoutine函数
if (WSARecv(AcceptSocket, &DataBuf, 1, &RecvBytes, &Flags, &overlapped, WorkerRoutine) == SOCKET_ERROR)
{
    if (WSAGetLastError() != WSA_IO_PENDING)
    {
        printf("WSARecv() failed with error %d \n", WSAGetLastError());
        return;
    }
}
//因为WSAWaitForMultipleEvents() API要求在一个或多个事件对象上等待，
//因此不得不创建一个伪事件对象。作为一种可选方案，也可使用SleepEx()替代
EventArray[0] = WSACreateEvent();
while (TRUE)
{
//第五步 ：
    Index = WSAWaitForMultipleEvents(1, EventArray, FALSE, WSA_INFINITE, TRUE);
//第六步：
    if (Index == WAIT_IO_COMPLETION)
    {
        //一个重叠请求完成例程结束。继续为更多的完成例程服务
        continue;
    }
    else
    {
        //发生了一个严重错误：停止处理
        //如果正在处理一个事件对象，那么这也就可能是事件数组的一个索引
        return;
    }
}
return 1;
}

void CALLBACK WorkerRoutine(DWORD Error, DWORD BytesTransferred, LPWSAOVERLAPPED Overlapped, DWORD InFlags)
{
DWORD SendBytes, RecvBytes;
DWORD Flags;
if (Error != 0 || BytesTransferred == 0)
{
    //要么是套接字上发生了一个严重错误，要么套接字已被通信对方关闭
    closesocket(AcceptSocket);
    return;
}
//此刻，一个重叠WSARecv()请求顺利完成------现在可以接受DataBuf变量中包含的已收到的数据了
//处理完接收到的数据后，需要投递另外一个重叠WSARecv()或WSASend()请求
//--------下面值投递了另外一个WSARecv()请求
Flags = 0;
memset(Overlapped, 0, sizeof(WSAOVERLAPPED));
DataBuf.len = DATA_BUFSIZE;
DataBuf.buf = buffer;

if (WSARecv(AcceptSocket, &DataBuf, 1, &RecvBytes, &Flags, Overlapped, WorkerRoutine) == SOCKET_ERROR)
{
    if (WSAGetLastError() != WSA_IO_PENDING)
    {
        printf("WSARecv() failed with error &d \n", WSAGetLastError());
        return;
    }
}
}

    对该程序采用的编程步骤总结如下：

    1. 新建一个套接字，开始在指定端口上监听传入的连接
    2. 接受一个入站的连接请求
    3. 为接受的套接字创建一个WSAOVERLAPPED结构。
    4. 在套接字上投递一个异步WSARecv请求，需要将WSAOVERLAPPED指定为参数，同时提供一个完成例程
    5. 在将fAlertable参数设为TRUE的前提下，调用WSAWaitForMultipleEvents，并等待一个重叠I/O请求完成。重叠请求完成后，完成例程会自动执行，而且WSAWaitForMultipleEvents会返回一个WSA_IO_COMPLETION。在完成例程内，可用一个完成例程投递另一个重叠WSARecv请求
    6. 检查WSAWaitForMultipleEvents是否返回WAIT_IO_COMPLETION

    7. 重复步骤5和6

      • 重叠模型提供高性能套接字I/O。因为使用这种模型的应用程序通知缓冲区收发系统直接使用的数据，所以它和前面的几种不同。也就是说，如果应用程序投递了一个10KB大小的缓冲区来接收数据，且数据已到达套接字，则该数据将直接被拷贝到投递的缓冲区。在前面的讲述的模型中，数据到达并被拷贝到单套接字接收缓冲区中，此时应用程序会被告知可以读入的容量。当应用程序调用接收函数之后，数据姜葱单套接字缓冲区拷贝到应用程序的缓冲区。
      • 在事件中使用重叠I/O的缺点，也是每次最多只能等待64个事件这一局限性。完成例程是一个不错的替代方式，但必须注意确保投递完成操作的线程进入警觉的等待状态，以便使完成例程能够圆满结束。同时，还要注意确保完成例程不要做过量的运算，以便在很重的负载之下，这些完成过程能够尽快开始运行
  2. completionport模型

声明：以上整理于Windows网络编程（第二版）

zt_xcyk
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Windows套接字I/O模型代码
06-11
包括Windows网络编程套接字I/O模型中的select模型,WSAEventSelect模型,重叠模型,完成端口模型完整代码。因为Windows 网络编程这本书上提供的代码并不完全正确，所以花了3天,写了几个例子。其中也包括了一些C++编程的...
套接字I/O模型-完成端口IOCP
weixin_30408165的博客
04-28 70
“完成端口”模型是迄今为止最为复杂的一种I/O模型。然而，假若一个应用程序同时需要管理为数众多的套接字，那么采用这种模型，往往可以达到最佳的系统性能！但不幸的是，该模型只适用于Windows NT和Windows 2000操作系统。因其设计的复杂性，只有在你的应用程序需要同时管理数百乃至上千个套接字的时候，而且希望随着系统内安装的CPU数量的增多，应用程序的性能也可以线性提升，才应考虑采用“完...
基本套接字编程（2） -- I/O模型篇
指尖飞舞
12-23 903
1. I/O模型简介 最近一直在学习Unix网络编程，被Unix下各种I/O模型搞得头昏脑涨，结合《Unix网络编程 - 卷一》第六章 并参考了网上各牛们的分析，稍稍厘清了一些。因此记录下来，方便以后复习！
简述基本TCP套接字编程(一）
u013644957的博客
04-26 810
最近在看UNP的基本TCP套接字编程这一章，现总结如下： 首先用一张图阐述一下基本TCP socket的C/S框架 （1）socket函数 #include int socket(int family,int type,int protocol) 函数说明： 用于创建一个套接字 参数说明： family制定协议族，该参数也被称作协议域。具体常值如下表： fa
tcp套接字编程模型
网络安全研究
05-15 680
tcp套接字编程模型。
select选择模型 windows套接字I/O模型
05-13
本文将深入探讨select选择模型以及其在Windows套接字I/O中的应用。 首先，我们需要理解什么是I/O模型。I/O模型主要有五种：同步阻塞、同步非阻塞、异步阻塞（即回调）、I/O复用和信号驱动I/O。其中，I/O复用模型...
1_WINSOCK的I/O模型_
10-03
4. **信号驱动I/O**：在WINSOCK中，通过设置套接字为信号驱动I/O，当数据准备好时，操作系统会发送一个信号通知程序。这种模型减少了轮询的开销，但其信号处理机制可能增加编程复杂性。 5. **异步I/O**：WINSOCK的`...
浅谈Linux 网络 I/O 模型简介（图文）
09-15
通过开启套接字的信号驱动I/O功能，当数据准备好时，系统会产生SIGIO信号通知进程，然后进程调用`recvfrom`读取数据。这种方法避免了轮询，但可能因信号处理的复杂性带来问题。 5. **异步I/O模型**： 异步I/O允许...
套接字I/O模型中的select模型源码
08-02
在各种I/O模型中，`select`模型是一种广泛使用的机制，尤其在处理多路复用I/O时。本文将深入探讨`select`模型的工作原理、优缺点以及如何在实际代码中应用。 `select`模型是一种I/O多路复用技术，允许程序同时监控...
Socket原理与编程基础
月落满楼
01-23 3242
一、Socket简介 Socket是进程通讯的一种方式，即调用这个网络库的一些API函数实现分布在不同主机的相关进程之间的数据交换。 几个定义： （1）IP地址：即依照TCP/IP协议分配给本地主机的网络地址，两个进程要通讯，任一进程首先要知道通讯对方的位置，即对方的IP。 （2）端口号：用来辨别本地通讯进程，一个本地的进程在通讯时均会占用一个端口号，不同的进程端口号不同，因此在通讯前必须
abort()、exit()、atexit使用
热门推荐
zt_xcyk的专栏
06-08 2万+
abort()、exit()、atexit\atexit使用 1. abort() 立即终止当前进程，产生异常程序终止 进程终止时不会销毁任何对象 示例： /* abort example */ #include &lt;stdio.h&gt; /* fopen, fputs, fclose, stderr */ #include &lt;stdlib.h&gt; ...
VS2015设置DLL和LIB的输出目录
zt_xcyk的专栏
09-16 9840
VS2015设置DLL和LIB的输出目录 DLL设置输出目录工程点击右键–>属性–>链接器–>常规–>输出文件 工程点击右键Configuration Properties–>Linker–>General–>Output File 默认设置，一般为：$(OutDir)$(TargetName)$(TargetExt) 相对路径的起点为xxx.vcxproj 文件所在的目录lib设置输出目录
Windows网络编程（基础篇1）
zt_xcyk的专栏
03-10 8330
Windows网络编程（基础篇1） Winsock是一种网络编程接口，不是协议。 除了WSAStartup、WSACleanup、WSARecvEx、WSAGetLastError属于Winsocket1.1规范函数外，凡是有前缀WSA的，都是在Winsock 2 中更新或者增添的一个新的API函数。 一、Winsock初始化 包含头文件winsock2.h，链接库WS2_32i
DLL中的回调函数实现
zt_xcyk的专栏
09-27 5919
DLL中的回调函数实现DLL文件中存放的是各类程序的函数实现过程，当程序需要调用函数时需要先载入DLL，然后取得函数地址，最后进行调用。但是有时候我们需要DLL和程序进行通信，将应用程序的某些功能提供给DLL使用，这时就可以使用回调函数。 比如应用程序A调用动态链接库D，同时需要将D中的一些日志信息反馈给A进行处理。这时可以在A中设置写日志的回调函数提供给DLL。 一、调用程序中操作 应用程序提
获取当前焦点所在窗口句柄，通过 句柄获取执行路径
zt_xcyk的专栏
03-16 4961
获取当前焦点所在窗口句柄，通过 句柄获取执行路径
通过进程ID或名字结束进程
zt_xcyk的专栏
11-30 2316
1.通过进程名：void CloseProgram(CString strProgram) { HANDLE handle; //定义CreateToolhelp32Snapshot系统快照句柄 HANDLE handle1; //定义要结束进程句柄 handle = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);//获得
VS远程联机调试exe和dll
zt_xcyk的专栏
05-11 1900
VS远程联机调试exe和dll
用栈实现大数加法
zt_xcyk的专栏
09-18 1768
前天听到舍友说面试遇到一个大数加法的题自己想了（这里就不解释什么是大数运算了），自己想了几种方法，用字符串保存输入的大数字，然后分割成一个个比较小的数，存放在数组了，然后计算。还有就是用链表的方法，两条链表存放两个大数字，每个结点就是一个个位数，然后从尾到头依次相加；自己也在网上找了一下大数运算的方法，这两种方法都有； 今天突然想到用栈不是更好实现，把输入的数字一个个入栈，因为栈是先进后出，所以两
Windows套接字I/O模型详解
WINSOCK IO模型 WINSOCK IO模型是Windows套接字应用程序中对...WINSOCK IO模型是Windows套接字应用程序中对I/O操作进行管理的方法，需要根据应用程序的要求选择合适的套接字模式和I/O模型，以确保应用程序的高效运行。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值