基于OpenCV C++的网络实时视频流传输——Windows下使用TCP/IP编程原理

1.TCP/IP编程

1.1 概念

IP 是英文 Internet Protocol (网络之间互连的协议)的缩写,也就是为计算机网络相互连接进行通信而设计的协议。任一系统,只要遵守 IP协议就可以与因特网互连互通。

所谓IP地址就是给每个遵循tcp/ip协议连接在Internet上的主机分配的一个32bit地址。按照TCP/IP协议规定,IP地址用二进制来表示,每个IP地址长32bit,比特换算成字节,就是4个字节。为了方便人们的使用,IP地址经常被写成十进制的形式,中间使用符号 “.” 分开不同的字节,如:192.168.1.1。在因特网中,主机的标识便是它ip地址。

常见的获取服务器ip的方法是使用系统自带的ping命令。例,打开cmd输入:ping http://www.xxxx.com

1.2 Socket

socket的英文原义是“孔”或“插座”。作为4BDS UNIX的进程通信机制,取后一种意思。通常也称作”套接字”,用于描述IP地址和端口,是一个通信链的句柄。Scoket程勋分为服务端与客户端,服务端程序监听端口,等待客户端程序的连接。客户端程序发起连接,等待服务端的相应。客户端想要连接上服务端的话,需要 知道服务端的ip地址。

例如,客户想要访问百度网站的首页,通过浏览器访问http://www.baidu.com。浏览器发出请求之后,先是DNS服务器将百度的域名解析成ip地址之后,访问到ip地址为115.239.210.27服务器的80端口(http协议默认在80端口),请求发送后,百度的服务器作为响应将页面的源代码发送至客户端(通过浏览器右键->源代码,或者ctrl+u到服务器返回的页面源代码),随后浏览器将源代码渲染成页面。这样用户就看到了百度网站的

1.3 服务端与客户端

服务端与客户端在计算机的世界里,凡是提供服务的一方我们称为服务端(Server),而接受服务的另一方我们称作客户端(Client)。网站提供网页数据的服务,使用者接受网站所提供的数据服务,所以使用者在这里就是客户端,响应使用者要求的网站即称为服务端。不过客户端及服务端的关系不见得一定建立在两台分开的机器上,同一台机器中也有这种主从关系的存在,提供服务的服务端及接受服务的客户端也有可能都在同一台机器上。例如我们在提供网页的服务器上执行浏览器浏览本机所提供的网页,这样在同一台机器上就同时扮演服务端及客户端。

实现流程:

服务器端创建套接字后连续调用bind、listen函数进入等待状态,客户端通过调用connect函数发起连接请求。需要注意的是,客户端只能等到服务器调用listen函数后才能调用connect()函数。同时要清楚,客户端调用connect()函数前,服务器端有可能率先调用accept()函数。当然,此时服务器在调用accept()函数是进入阻塞状态,直到客户端调用connect()函数为止。

2、Windows与Linux下TCP/IP编程

2.1 函数说明

Windows套接字大部分是参考BSD系列UNIX套接字设计的,所以很多地方都跟Linux套接字类似。大多数项目都在Linux系列的操作系统下开发服务器端,而多数客户端是在windows平台下开发的。

在windows下做网络编程,需要做如下准备:导入头文件winsock2.h、链接ws2_32.lib。

Windows 下的 socket 程序和 Linux 思路相同,但细节有所差别:

Windows 下的 socket 程序依赖Winsock.dll 或 ws2_32.dll,必须提前加载。Windows Socket编程依赖于系统提供的动态链接库(DLL),有两个版本:较早的DLL是 wsock32.dll,大小为 28KB,对应的头文件为 winsock1.h;最新的DLL是 ws2_32.dll,大小为 69KB,对应的头文件为 winsock2.h。几乎所有的 Windows 操作系统都已经支持 ws2_32.dll,包括个人操作系统 Windows 95 OSR2、Windows 98、Windows Me、Windows 2000、XP、Vista、Win7、Win8、Win10 以及服务器操作系统 Windows NT 4.0 SP4、Windows Server 2003、Windows Server 2008 等,所以你可以毫不犹豫地使用最新的 ws2_32.dll。

使用 DLL 之前必须把 DLL 加载到当前程序,你可以在编译时加载,也可以在程序运行时加载。这里使用#pragma命令,在编译时加载:#pragma comment (lib, “ws2_32.lib”)

使用 DLL 之前,还需要调用 WSAStartup() 函数进行初始化,以指明 WinSock 规范的版本,并初始化相应版本的库。它的原型为:int WSAStartup(WORD wVersionRequested, LPWSADATA lpWSAData);

int WSAStartup(WORD wVersionRequested, LPWSADATA lpWSAData);

wVersionRequested:该参数为WinSock 规范的版本号,低字节为主版本号,高字节为副版本号(修正版本号);
lpWSAData:该参数为指向 WSAData 结构体的指针;

WinSock 规范的最新版本号为 2.2,较早的有 2.12.01.11.0,ws2_32.dll 支持所有的规范,而 wsock32.dll 仅支持 1.01.1。若版本为1.2,则其中1是主版本号,2是副版本号,应传递0x0201。
wsock32.dll 已经能够很好的支持 TCP/IP 通信程序的开发,ws2_32.dll 主要增加了对其他协议的支持,不过建议使用最新的 2.2 版本。

wVersionRequested 参数用来指明我们希望使用的版本号,它的类型为 WORD,等价于 unsigned short,是一个整数,所以需要用 MAKEWORD() 宏函数对版本号进行转换。例如:
MAKEWORD(1, 2); //主版本号为1,副版本号为2,返回 0x0201
MAKEWORD(2, 2); //主版本号为2,副版本号为2,返回 0x0202

Linux 使用“文件描述符”的概念,而 Windows 使用“文件句柄”的概念;

Linux 中的一切都是文件,每个文件都有一个整数类型的文件描述符,socket 也是一个文件,也有文件描述符,所以Linux 不区分 socket 文件和普通文件,而 Windows 区分;

Linux 下 socket() 函数的返回值为 int 类型,而 Windows 下为 SOCKET 类型,也就是句柄。

Linux 下使用 read() / write() 函数读写,而 Windows 下使用 recv() / send() 函数发送和接收。

关闭 socket 时,Linux 使用 close() 函数,而 Windows 使用 closesocket() 函数。

socket编程的基本函数有socket()、bind()、listen()、accept()、send()、sendto()、recv()以及recvfrom()等。

2.2 socket()

Linux 中的一切都是文件,每个文件都有一个整数类型的文件描述符;socket 也是一个文件,也有文件描述符。使用 socket() 函数创建套接字以后,返回值就是一个 int 类型的文件描述符。

Windows 会区分 socket 和普通文件,它把 socket 当做一个网络连接来对待,调用 socket() 以后,返回值是 SOCKET 类型,用来表示一个套接字。

不管是 Windows 还是 Linux,都使用 socket() 函数来创建套接字。socket() 在两个平台下的参数是相同的,不同的是返回值。

头文件

Linux

#include <sys/socket.h>

Windows

#include <winsock2.h>

函数原型

Linux

int socket(int family,int type,int protocol);

Windows

SOCKET socket(int  family, int type, int protocol);

作用

该函数用于创建一个套接字,同时指定协议和类型

参数

family:协议族(AF前缀和PF前缀是等价的)

AF_INET(PF_INET):IPv4协议族

AF_INET6(PF_INET6):IPv6协议族

AF_LOCAL:UNIX域协议族

AF_ROUTE:路由套接字协议族

AF_KEY:密钥套接字协议族

type:套接字类型,即套接字的数据传输方式(有的协议族中存在多种数据传输方式,所以协议族和数据传输方式分开)

SOCK_STREAM:流式套接字

SOCK_DGRAM:数据报套接字

SOCK_RAM:原始套接字

Protocol:传输协议(该参数一般置0,原始套接字除外),比如满足AF_INET和SOCK_STREAM这两个条件的只有IPPROTO_TCP,满足AF_INET和SOCK_DGRAM这两个条件的只有IPPTOTO_UDP

IPPROTO_TCP:TCP协议

IPPTOTO_UDP:UDP协议

返回值

成功

Linux

非负套接字文件描述符

Windows

套接字句柄

失败

Linux

-1

Windows

INVALID_SOCKET

注意:
protocol 表示传输协议,常用的有 IPPROTO_TCP 和 IPPTOTO_UDP,分别表示 TCP 传输协议和 UDP 传输协议。有了地址类型和数据传输方式,还不足以决定采用哪种协议吗?为什么还需要第三个参数呢?

正如大家所想,一般情况下有了 af 和 type 两个参数就可以创建套接字了,操作系统会自动推演出协议类型,除非遇到这样的情况:有两种不同的协议支持同一种地址类型和数据传输类型。如果我们不指明使用哪种协议,操作系统是没办法自动推演的。

当参数 family 的值为 PF_INET时:

如果使用 SOCK_STREAM 传输数据,那么满足这两个条件的协议只有 TCP,因此可以这样来调用 socket() 函数:

int tcp_socket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); //IPPROTO_TCP表示TCP协议 这种套接字称为 TCP 套接字

如果使用 SOCK_DGRAM 传输方式,那么满足这两个条件的协议只有 UDP,因此可以这样来调用 socket() 函数:

int udp_socket = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP); //IPPROTO_UDP表示UDP协议 这种套接字称为 UDP 套接字

上面两种情况都只有一种协议满足条件,可以将 protocol 的值设为 0,系统会自动推演出应该使用什么协议,如下所示:

int tcp_socket = socket(AF_INET, SOCK_STREAM, 0); //创建TCP套接字

int udp_socket = socket(AF_INET, SOCK_DGRAM, 0); //创建UDP套接字

2.3 bind()

它主要用于服务器,客户端创建的套接字可以不绑定地址。绑定时一般要指定IP地址和端口号,否则内核会随意分配一个临时端口给该套接字,IP地址可以是本机的IP地址,或者使用宏INADDR_ANY,允许将套接字与服务器的任意网络接口(如eth0、eth0:1、eth1等)进行绑定。

头文件

Linux

#include <sys/socket.h>

Windows

#include <winsock2.h>

函数原型

Linux

int bind(int sockfd, struct sockaddr *addr, socklen_t addrlen);

Windows

int bind(SOCKET sockfd, const struct sockaddr *addr, int addrlen);

作用

给服务器套接字分配IP地址和端口号

参数

sockfd

套接字描述符(服务器端socket函数的的返回值)

addr

绑定的地址(struct sockaddr_in强转)

addrlen

地址长度(sizeof(server_addr))

返回值

成功

Linux

0

Windows

0

失败

Linux

-1

Windows

SOCKET_ERROR

2.4 listen()

在服务器端程序成功建立套接字并与地址进行绑定之后,通过调用listen()函数将服务器套接字设置成被动监听模式(被动模式),并且设置客户端请求连接的队列长度。所谓被动监听,是指套接字一直处于“睡眠”中,直到客户端发起请求才会被“唤醒”。

头文件

Linux

#include <sys/socket.h>

Windows

#include <winsock2.h>

函数原型

Linux

int listen(int sockfd, int backlog);

Windows

int listen(SOCKET sockfd, int backlog);

作用

该函数将服务器套接字转为可接收连接状态

参数

sockfd

套接字描述符(服务器端的套接字)

backlog

请求队列中允许的最大请求数,大多数系统默认值为5,最大为1024

返回值

成功

Linux

0

Windows

0

失败

Linux

-1

Windows

SOCKET_ERROR

sock 为需要进入监听状态的套接字,backlog 为请求队列的最大长度。

所谓被动监听,是指当没有客户端请求时,套接字处于“睡眠”状态,只有当接收到客户端请求时,套接字才会被“唤醒”来响应请求。

当套接字正在处理客户端时,如果有新的客户端请求进来,套接字是没法处理的,只能把它放进缓冲区进行排队,待当前客户端处理完毕后,再从缓冲区中读取出来处理。如果不断有新的请求进来,它们就按照先后顺序在缓冲区中排队,直到缓冲区满。这个缓冲区,就称为请求队列(Request Queue)。

缓冲区的长度(能存放多少个客户端请求)可以通过 listen() 函数的 backlog 参数指定,但究竟为多少并没有什么标准,可以根据你的需求来定,并发量小的话可以是10或者20。

如果将 backlog 的值设置为 SOMAXCONN,就由系统来决定请求队列长度,这个值一般比较大,可能是几百,或者更多。

当请求队列满时,就不再接收新的请求,对于 Linux,客户端会收到 ECONNREFUSED 错误,对于 Windows,客户端会收到 WSAECONNREFUSED 错误。

注意:listen() 只是让套接字处于监听状态,将各个客户端的请求放入缓冲区进行排队,并没有处理客户端的请求。接受请求需要使用 accept() 函数。

2.5 accept()

服务器端通过调用accept()函数等待并处理客户端的连接请求,程序一旦执行到 accept() 就会被阻塞(暂停运行),直到客户端发起请求。建立好TCP连接后,该函数会返回一个新的已连接的套接字。

头文件

Linux

#include <sys/socket.h>

Windows

#include <winsock2.h>

函数原型

Linux

int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);

Windows

SOCKET accept(SOCKET sockfd, struct sockaddr *addr, int *addrlen);

作用

该函数用来处理连接请求,如果在没有连接请求,该函数不会返回。一直到有连接请求为止

参数

sockfd

套接字描述符(服务器的套接字)

addr

用于保存连接的客户端的地址

addrlen

地址长度

返回值

成功

Linux

建立好连接的套接字描述符

Windows

建立好连接的套接字句柄

失败

Linux

-1

Windows

INVALID_SOCKET

accept()函数受理连接请求等待队列呆处理的客户端连接请求。函数调用成功时,accept()函数内部将产生用于数据I/O的套接字,并返回其文件描述符。需要强调的是,套接字是自动创建的,并自动与发起连接请求的客户端建立连接

它的参数与 listen() 和 connect() 是相同的:sock 为服务器端套接字,addr 为 sockaddr_in 结构体变量,addrlen 为参数 addr 的长度,可由 sizeof() 求得。

accept() 返回一个新的套接字来和客户端通信,addr 保存了客户端的IP地址和端口号,而 sock 是服务器端的套接字,大家注意区分。后面和客户端通信时,要使用这个新生成的套接字,而不是原来服务器端的套接字。

最后需要说明的是:listen() 只是让套接字进入监听状态,并没有真正接收客户端请求,listen() 后面的代码会继续执行,直到遇到 accept()。accept() 会阻塞程序执行(后面代码不能被执行),直到有新的请求到来。

2.6 connect()

客户端通过该函数向服务器端的监听套接字发送连接请求,直到服务器传回数据后,connect() 才运行结束。

客户端调用connect()函数后,发生以下情况之一才会返回:服务器端接受连接请求、发生断网等异常情况而中断连接请求。

需要注意,所谓的“接受连接请求”并不意味着服务器端调用accept()函数,其实是服务器端用listen()把客户端连接请求信息记录到等待队列。因此connect()函数返回后并不立即进行数据交换。

客户端在调用connect()函数时会自动给套接字分配IP地址和端口号,不需要调用bind()函数进行分配。

头文件

Linux

#include <sys/socket.h>

Windows

#include <winsock2.h>

Linux

int connect(int sockfd, struct sockaddr *serv_addr, socklen_t addrlen); 

Windows

int connect(SOCKET sockfd, const struct sockaddr *serv_addr, int addrlen); 

作用

该函数用来向服务器发送连接请求

参数

sockfd

套接字描述符(客户端的套接字)

serv_addr

要连接的服务器端的IP地址信息

addrlen

地址长度

返回值

成功

Linux

0

Windows

0

失败

Linux

-1

Windows

SOCK_ERROR

2.7 send()和recv()

头文件

Linux

#include <sys/socket.h>

Windows

#include <winsock2.h>

函数原型

Linux

int send(int sockfd,const void *buf,int len,int flags);

Windows

int send(SOCKET sockfd, const char *buf, int len, int flags);

作用

该函数用来发送数据

参数

sockfd

套接字描述符(客户端的套接字)

buf

发送缓冲区的地址

len

发送数据的长度

flags

一般为0

返回值

成功

Linux

实际发送的字节数

Windows

实际发送的字节数

失败

Linux

-1

Windows

SOCKET_ERROR

头文件

Linux

#include <sys/socket.h>

Windows

#include <winsock2.h>

函数原型

Linux

int recv(int sockfd,void *buf,int len,unsigned int flags);

Windows

int recv(SOCKET sockfd, char *buf, int len, int flags);

作用

该函数用来接收数据

参数

sockfd

套接字描述符(客户端的套接字描述符)

buf

存放接收数据的缓冲区地址

len

接收数据的长度

flags

一般为0

返回值

成功

Linux

实际接收到的字节数(收到EOF时为0)

Windows

实际接收到的字节数(收到EOF时为0)

失败

Linux

-1

Windows

SOCKET_ERROR

2.8 sendto()和recvfrom()

这两个函数一般在UDP通信过程中用于发送和接收数据。当用在TCP时,后面的几个与地址有关的参数不起作用,函数作用等同于send()和recv()**

头文件

#include <sys/socket.h>

函数原型

int sendto(int sockfd,const void *buf,int len, unsigned int flags,const struct sockaddr *to,int tolen);

作用

该函数用来发送数据

参数

sockfd

套接字描述符

buf

发送缓冲区的地址

len

发送数据的长度

flags

一般为0

to

接收方的套接字的IP地址和端口号

tolen

地址长度

返回值

成功

实际发送的字节数

失败

-1

头文件

#include <sys/socket.h>

函数原型

int recvfrom(int sockfd,void *buf,int len,unsigned int flags,struct sockaddr *from,int *fromlen);

作用

该函数用来接收数据

参数

sockfd

套接字描述符

buf

存放接收数据的缓冲区地址

len

接收数据的长度

flags

一般为0

from

发送方的IP地址和端口号信息

Fromlen

地址长度

返回值

成功

实际接收到的字节数

失败

-1

2.9 close()

头文件

Linux

#include <sys/socket.h>

Windows

#include <winsock2.h>

函数原型

Linux

int close(int sockfd);

Windows

int closesocket(SOCKET sockfd);

作用

关闭套接字

参数

sockfd

套接字描述符

返回值

成功

Linux

0

Windows

0

失败

Linux

-1

Windows

SOCKET_ERROR

3.代码实现

3.1 server.cpp

#include<WINSOCK2.H>
#include<stdio.h>
#pragma comment(lib,"WS2_32.lib")
#define   BUFFER_SIZE 1024 //缓冲区大小
int main()
{
    WSADATA WSAData;
    SOCKET sClient;    //用于和客户端socket进行通信
    SOCKET sServer; //用于和本地地址绑定的socket
    int err_code; //存储返回的错误代码
    char buffer[BUFFER_SIZE]; //缓冲区
    if(WSAStartup(MAKEWORD(2,2),&WSAData)!=0)
    {
        printf("WSAStartup failed,错误代码:%d\n",WSAGetLastError());
       return -1;
    }      //初始化winsock

    sServer=socket(AF_INET,SOCK_STREAM,IPPROTO_TCP); //创建监听的socket

    if(sServer==INVALID_SOCKET)
    {
        printf("创建Socket失败,错误代码:%d\n",WSAGetLastError());
       WSACleanup();//清除初始化的Winsock
     return -1;
    }  

    SOCKADDR_IN addrServ;  //在监听的SOCKET绑定到本地之前,需要设置服务器Socket的地址
    addrServ.sin_family=AF_INET;
    addrServ.sin_port=htons(9990);//这里为什么不能用htonl()函数来转换呢,因为SOCKADDR_IN里面声明的端口号为u_shortk类型
    addrServ.sin_addr.S_un.S_addr=htons(INADDR_ANY);//服务器监听端口为INADDR_ANY,即在任意本地地址(0.0.0.0)上进行监听

    err_code=bind(sServer,(const sockaddr *)&addrServ,sizeof(SOCKADDR_IN));    //将用于绑定的sService绑定到本地地址

    if(err_code==SOCKET_ERROR){
        printf("bind failed,错误代码:%d\n",WSAGetLastError());
        closesocket(sServer);
        WSACleanup();
        return -1;


}
    err_code=listen(sServer,1);  //监听客户端socket,第一个参数为与本地地址绑定的socket,第二个参数表示等待连接队列的最大长度
    if(err_code==SOCKET_ERROR){
        printf("listener failed,错误代码:%d\n",WSAGetLastError());
        closesocket(sServer);
        WSACleanup();
        return -1;
    }
    printf("TCP Server start...\n");
    sockaddr_in addrClient;
    int addrClientlen=sizeof(addrClient);
    sClient=accept(sServer,(sockaddr *)&addrClient,&addrClientlen);

    if(INVALID_SOCKET==sClient){
        printf("accept failed!,错误代码:%d\n",WSAGetLastError());
        closesocket(sServer);      
        WSACleanup();
        return -1;
    }

    //循环接收客户端的数据
    while(true){
        ZeroMemory(buffer,BUFFER_SIZE);//初始化缓冲区,把缓冲区置0
        err_code=recv(sClient,buffer,sizeof(buffer),0);
        if(err_code==SOCKET_ERROR){
            printf("Recv failed !,错误代码:%d\n",WSAGetLastError());
                closesocket(sClient);
                closesocket(sServer);
                WSACleanup();
                return -1;
        }
        if(strcmp(buffer,"quit")==0){ //当客户端发来quit时,服务器就关闭
            send(sClient,"quit",strlen("quit"),0);
            break;
        }else{
            char msg[BUFFER_SIZE]="我是服务器,我已收到:";
            printf("接收来自客户端[%s:%d]的消息 :%s\n",inet_ntoa(addrClient.sin_addr),addrClient.sin_port,buffer);
            strcat(msg,buffer);//拼接起来发送给主机,表示服务器已收到消息
            err_code=send(sClient,msg,strlen(msg),0);
            if(err_code==SOCKET_ERROR){
                printf("send failed !错误代码:%d\n",WSAGetLastError());
            closesocket(sServer);
            closesocket(sClient);
            WSACleanup();
            return -1;
            }

        }


    }
    closesocket(sClient); //关闭用于通信的socket
     closesocket(sServer);//关闭与本地地址绑定的socket
    WSACleanup();//释放资源
    system("pause");
    return 0;
}

3.2 Client.cpp

#include<stdio.h>
#include<WINSOCK2.H>
#include<string.h>
#include<iphlpapi.h>
#pragma comment(lib,"WS2_32.lib")
#define BUFFER_SIZE 1024 //缓冲区大小
int main(){
    WSADATA WSAData;
    SOCKET s_Host;//本机socket
    sockaddr_in addrServer ;//服务器地址 
    char buf[BUFFER_SIZE]; //缓冲区字符数组
    int return_info;//存储返回的错误代码

          if(WSAStartup(MAKEWORD(2,2),&WSAData)!=0){ //初始化Winsock2.2
        printf("无法完成初始化,错误代码:%d",WSAGetLastError());
        WSACleanup();
          return 0;
    }
    s_Host=socket(AF_INET,SOCK_STREAM,IPPROTO_TCP);
    if(s_Host==INVALID_SOCKET){
        printf("创建sockets失败,错误代码:%d\n",WSAGetLastError());
        WSACleanup();
        return -1;
    }

    addrServer.sin_family=AF_INET;
    addrServer.sin_port=htons(9990);
    addrServer.sin_addr.S_un.S_addr=inet_addr("127.0.0.1");

    return_info=connect(s_Host,(sockaddr*)&addrServer,sizeof(addrServer));
    if(SOCKET_ERROR==return_info){
        printf("连接服务器失败,错误代码:%d",WSAGetLastError());
        closesocket(s_Host);
        WSACleanup();
        return -1;
    }

    //循环给服务器发送消息
    while(1){
    printf("请输入要发送的消息:");
    gets(buf);
    return_info=send(s_Host,buf,strlen(buf),0);//这里用strlen()哦,用sizeof()就吧缓冲区那么大的数据传过去了!!!
    if(return_info==SOCKET_ERROR){
        printf("发送消息失败,错误代码:%d",WSAGetLastError());
        closesocket(s_Host);
        WSACleanup();
        return -1;
    }
    return_info= recv(s_Host,buf,sizeof(buf),0);    //recv()函数返回接收到的字节数
       if(return_info==SOCKET_ERROR){
               printf("接受服务器消息失败, 错误代码:%d",WSAGetLastError());
                closesocket(s_Host);
               WSACleanup();
                return -1;
       }else{
        buf[return_info]='\0';
    }
           if(strcmp(buf,"quit")==0){//当收到"quit"退出
              printf("退出...\n");
                     break;
           }else{
                printf("%s\n",buf);
           }
    }

    if(WSACleanup()==SOCKET_ERROR){
           printf("WSACleanUp出错!!!");
    }  //做一些清除工作
    system("pause");
    return 0;
}
/*
     乱码解决方案:
大部分编译程序 在编译的时候就把sizeof计算过了 是类型或是变量的长度这就是sizeof(x)可以用来定义数组维数的原因 
char str[20]="0123456789";
int a=strlen(str); //a=10;
int b=sizeof(str); //而b=20;

1.所以,在调用recv()函数时,用sizeof(),因为recv函数把接收缓冲中的数据copy到buf中
(注意协议接收到的数据可能大于buf的长度所以在这种情况下要调用几次recv函数才能把s的接收缓冲中的数据copy完。
recv函数仅仅是copy数据,真正的接收数据是协议来完成的),
recv函数返回其实际copy的字节数。如果recv在copy时出错,
那么它返回SOCKET_ERROR;
如果recv函数在等待协议接收数据时网络中断了,那么它返回0。
2.在调用send()函数时,用strlen(),因为这样就会将输入多少数据,转换为字节直接传过去。而接受就不一样了,接收的buf是缓冲区

*/
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

知来者逆

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值