网络编程

最新推荐文章于 2022-09-04 17:30:08 发布
原创 最新推荐文章于 2022-09-04 17:30:08 发布 · 296 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

asource insight.f7搜函数

一、网络介绍    
协议：规则
tcp/ip模型4层: 
应用层{http超文本传输协议 ftp文件传输协议 telnet远程登录ssh安全外壳协议stmp简单邮件发送 pop3收邮件} 
传输层{tcp传输控制协议,udp用户数据包协议} 
网络层{ip网际互联协议 icmp网络控制消息协议 igmp网络组管理协议} 
网络接口层{arp地址转换协议,rarp反向地址转换协议，mpls多协议标签交换}



IP协议：网络层。IP报文协议。包地址，校验。
ping:ICMP协议。

传输层：你想以什么方式把数据给对方。

应用层：浏览器走的http协议。
ssh协议。

XMPP协议 即时通信协议  腾讯没有用

QICQ：
国外的聊天用的开源的。
能够做协议

每一个计算机有一个ip。端口的背后是进程。

用户自己定义的端口通常大于1024.
牛逼的留给1024以下。

必须要学会TCP、UDP。用来实现上层协议。

需要进行三次握手的协议。tcp
每次我都把数据丢给你。upd

积极确认重传：积极的概念。
TCP：网络稳定不会重复建立连接
什么时候用UDP:优酷视频，不需要建立连接的情况。一般是视频，摄像头。

二、网络相关概念   
套接口，套接字(socket)
在一台计算机中，一个端口号一次只能分配给一个进程，也就是说，在一台计算机中，端口号和进程之间是一一对应关系。
short 短整形，2个字节；long 长整形，4个字节；unsigned short，无符号短整型，2个字节；unsigned long,无符号长整形，4个字节。

struct sockaddr_in {                          //旧的版本是struct sockaddr，这个版本可以兼容旧版本。
  short int sa_family;                    //地址族。如果是IPv4协议,就写:AF_INET；如果是IPv6协议，就写：AF_INET6。    
  unsigned short int sin_port;        //端口号。如果端口是2000，不能直接赋2000的，因为网络字节序的问题。         
  struct in_addr sin_addr;              //IP地址 
  unsigned char sin_zero[8];         //填充0 以保持与struct sockaddr同样大小
};

struct in_addr {                 
  unsigned long int  s_addr;         //32位IPv4地址，网络字节序的。无符号长整形，4个字节。
}; 
 
数据存储优先顺序的转换(大小端的问题)：
网络字节序：在网络上是大端存储的，但是在自己的计算机上大小端都有可能，如Intel是小端存储的。
如数据实际是0x12345678,则在网络中存储的是0x12345678,Intel内存中是：0x78563412。
要把主机字节序和网络字节序相互对应起来，需要对这两个字节存储优先顺序进行相互转化。这里用到四个数：
htons()  host to net short   //如果主机是大端存储的，就不变，如果主机是小端存储的，就反过来
ntohs()  net to host short
htonl()  host to net long
ntohl()  net to host long

例：
int main(){
        unsigned short i=0x1234;              //定义i=0x1234,在主机上存的是：0x3412
        unsigned short j;
        unsigned short k;
        j=htons(i);                                   //host to net short 把主机转成网络格式。
        printf("j=%x\n",j);                       //
        k=ntohs(j);                                  //net to host short 把网络转成主机格式。
        printf("k=%x\n",k);
        return 0;
}

地址格式转换：
a:点分十进制
n:net
int inet_aton(const char *straddr, struct in_addr *addrptr);    //将点分十进制的straddr 转化为：32位的IPV4的网络字节序,保存到addrptr中 
char *inet_ntoa(struct in_addr inaddr);                                //将32位的网络字节序，转化为点分十进制字符串。
in_addr_t inet_addr(const char *straddr);                             //in_addr_t 就是unsigned long int ,代表s_addr，即struct in_addr结构体中的参                                                                                                数。所以该句直接把点分十进制转换为32位网络字节序的IP地址。
const char *inet_ntop(int family, const void *src, char *dst, socklen_t len); //family参数为AF_INET，表示是IPv4协议;为AF_INET6，表示                                                                                             IPv6协议。把网络字节序转换为点分十进制字符串。与inet_ntoa类似。但是                                                                                              inet_ntoa()只能转换成32位的网络字节序(即IPV4地址)，而这个函数可以转换                                                                                            IPV4或IPV6.
int inet_pton(int family, const char *src, void *dst); 


例：
int main(int argc,char* argv[]){
        if(argc!=2){
                printf("error args\n");
                return -1;
        }
        struct in_addr addr;          
        int ret;
        ret=inet_aton(argv[1],&addr);                                    //将argv[1]转化为网络字节序，存到结构体addr中。如：192.168.4.155  
        if(ret!=1){                                                                //成功返回1   
                perror("inet_aton");
                return -1;
        }
        printf("%x\n",addr.s_addr);                                       //打印出：9b04a8c0.  c0就是192，a8就是168，9b就是155。因为是网络是大端                                                                                         存储的，所以这么存。
        printf("%s\n",inet_ntoa(addr));
        printf("inet_addr=%x\n",inet_addr(argv[1]));              //点分十进制转换为32位网络字节序的IP地址
        return 0;
}

点分十进制转换为IPV6的


域名地址转换  
域名,如：www.baidu.com。域名解析服务器。买域名，需要花钱。一个域名可以对应多个IP地址。

struct hostent* gethostbyname(const char* hostname);         //通过域名得到地址   

struct hostent{
  char *h_name;            //正式主机名。 域名也有别名，www.a.shifen.com是百度的真实域名。                         
  char **h_aliases;        //主机别名。二级指针，常用于char * buf[],是一个指针数组                         
  int h_addrtype;           //主机IP地址类型，IPv4为AF_INET。                           
  int h_length;               //主机IP地址字节长度，对于IPv4是4字节，即32位。              
  char **h_addr_list;     //主机的IP地址列表，因为一个域名可以有多个IP地址。二级指针，常用语字符指针数组。                 
} 

例：通过域名得到地址
int main(int argc,char* argv[]){
        if(argc !=2){
                printf("error args\n");
                return -1;
        }
        struct hostent *p;
        p=gethostbyname(argv[1]);                        //输入域名，通过域名对应域名的IP地址等信息，返回给指针p。    
        if(p==NULL){
                perror("gethostbyname");
                return -1;
        }
        printf("h_name=%s\n",p->h_name);           //打印出正式主机名。
        char str[32]={0};
        char *ptr;
        for(ptr=*(p->h_aliases);ptr!=NULL;){       //p->h_aliases是二级指针。*(p->h_aliases)等于*((p->h_aliases)+0)等于(p->h_aliases)[0]。   
                printf("ptr=%s\n",ptr);                      //打印出主机别名。
                (p->h_aliases)++;                             //(p->h_aliases)+n 指向一维数组(p->h_aliases)[n]
                ptr=*(p->h_aliases);
        }
        ptr=*(p->h_addr_list);
        while(ptr!=NULL){
                memset(str,0,sizeof(str));
                inet_ntop(p->h_addrtype,ptr,str,sizeof(str));    //p->h_addrtype为IP地址的类型。将网络字节序转换为点分十进制。ptr是要转换的                                                                                   字符串，str存储转化后的点分十进制。
                printf("str=%s\n",str);
                (p->h_addr_list)++;
                ptr=*(p->h_addr_list);
        }
        return 0;
}

标准C：是一个标准，需要代码实现。
glibc：linux下，开源的实现了标准C的代码。libc.so是glibc使用的库。
操作系统提供系统调用。
中间层使用系统调用。

SOCKET编程:TCP通信      
通过socket接口TCP及UDP通信。TCP/UDP是协议。

                                 
int socket(int domain,int type,int protocol);   //生成一个套接口描述符。domain:为AF_INET表示Ipv4网络协议,为AF_INET6表示IPv6协议                                                                      type为tcp表示SOCK_STREAM，为udp表示SOCK_DGRAM。protocol指定socket所使用的传                                                                     输协议编号。通常为0.
sockaddr结构体：
struct sockaddr_in{                                    //常用的结构体。sockaddr结构会因使用不同的socket domain而有不同结构定义  
  unsigned short int sin_family;              //地址族。IPV4为：AF_INET 
  uint16_t sin_port;                               //为使用的port编号。一般1024以上自己使用。
  struct in_addr sin_addr;                       //为IP地址 
  unsigned char sin_zero[8];                   //未使用
}; 
struct in_addr { 
  uint32_t s_addr;                                  //32位IPv4地址，网络字节序的。无符号长整形，4个字节。
};

int bind(int sockfd,struct sockaddr * my_addr,int addrlen); //my_addr为结构体指针变量。addrlen是sockaddr的结构体长度。通常是计                                                                                                算sizeof(struct sockaddr) 。
int listen(int sockfd,int backlog);                 //backlog为同时能处理的最大连接要求。一个端口可以同时有多个客户端来连接。
int accept(int s,struct sockaddr * addr,int * addrlen);    //s即sfd。addr为结构体指针变量，和bind的结构体是同种类型的，系统会把远程                                                                                      主机的信息(远程主机的地址和端口号信息)保存到这个指针所指的结构体中。成                                                                                      功则返回新的socket处理代码new_fd,失败返回-1回值。之后客户端通过new_fd来通                                                                                  信。
int recv(int sockfd,void *buf,int len,unsigned int flags);     //sockfd为前面accept的返回值.即new_fd，也就是新的套接字。buf表示缓冲区,                                                                                         len表示缓冲区的长度.
int send(int s,const void * msg,int len,unsigned int flags); //用新的套接字发送数据给指定的远端主机.s为前面accept的返回值.即new_fd.                                                                                           msg一般为常量字符串，len表示长度。
int close(int fd);
int connect(int sockfd,struct sockaddr * serv_addr,int addrlen);   //sockfd为前面socket的返回值，即sfd。serv_addr为结构体指针变量，存储                                                                                                着远程服务器的IP与端口号信息。addrlen表示结构体变量的长度。
例一：使用socket接口实现TCP通信  
//使用socket接口实现tcp通信的服务器端  
int main(int argc,char** argv){
        if(argc!=3){
                printf("error args\n");
                return -1;
        }
        int sfd=socket(AF_INET,SOCK_STREAM,0);   //生成套接口描述符sfd。
        if(-1==sfd){
                perror("socket");
                return -1;
        }      
        printf("sfd=%d\n",sfd);                             //新建的从3开始  
        struct sockaddr_in ser;                              //socket信息数据结构
        memset(&ser,0,sizeof(ser));
        ser.sin_family=AF_INET;                       //IPV4.
        ser.sin_port=htons(atoi(argv[2]));            //主机转网络，端口。先转成数字。
        ser.sin_addr.s_addr=inet_addr(argv[1]);  //IP地址。
        int ret;
        ret=bind(sfd,(struct sockaddr*)&ser,sizeof(struct sockaddr)); //给sfd绑定IP地址和端口                                                                                                         号,&ser为结构体指针。
        if(-1==ret){
                perror("bind");
                return -1;
        }
        ret=listen(sfd,10);                                     //监听。最大连接数为10.
        if(-1==ret){
                perror("listen");
                return -1;
        }
        printf("listen success\n");
        struct sockaddr_in client;
        memset(&client,0,sizeof(client));
        int addrlen=sizeof(struct sockaddr);
        int new_fd=accept(sfd,(struct sockaddr*)&client,&addrlen); //接受连接请求 
        if(-1==new_fd){
                perror("accept");
                return -1;
        }
        printf("new_fd=%d\n",new_fd);
        printf("client IP=%s,client port=%d\n",inet_ntoa(client.sin_addr),ntohs(client.sin_port));
        char buf[128]={0}; 
        ret=recv(new_fd,buf,sizeof(buf),0);       //接收 
        if(-1==ret){
                perror("recv");
                return -1;
        }
        printf("%s\n",buf);
        ret=send(new_fd,"I am server",11,0);    //发送 
        if(-1==ret){
                perror("send");
                return -1;
        }
        return 0;
}
//使用socket接口实现tcp通信的客户端  
int main(int argc,char** argv){ //argv[1,2]存放服务器的地址和端口
        if(argc !=3){
                printf("error args\n");
                return -1;
        }
        int sfd=socket(AF_INET,SOCK_STREAM,0);
        if(-1==sfd){
                perror("socket");
                return -1;
        }
        struct sockaddr_in ser;                  //保存服务器端的信息 
        memset(&ser,0,sizeof(ser));
        ser.sin_family=AF_INET;
        ser.sin_port=htons(atoi(argv[2]));                
        ser.sin_addr.s_addr=inet_addr(argv[1]);
        int ret;
        ret=connect(sfd,(struct sockaddr*)&ser,sizeof(struct sockaddr));
        if(-1==ret){
                perror("connect");
                return -1;
        }
        char buf[128]={0};
        ret=send(sfd,"I am client",11,0);  //客户端通信的时候用一个
        if(-1==ret){
                perror("send");
                return -1;
        }
        ret=recv(sfd,buf,sizeof(buf),0);
        if(-1==ret){
                perror("recv");
                return -1;
        }
        printf("%s\n",buf);
        return 0;
}


















注意：1.客户端只有一个sfd.clint的端口是系统随机打开的一个端口。
           2.自己的机子上的两个进程通信还是用之前学的共享内存，管道什么的。
   3.客户端的端口是系统自动分配的。

例子二：如何实现多个客户端连接服务器  
要求：服务器只有一个线程：
     1.主线程能够监听客户端的连接请求；
     2.能够接受已经连接的客户端发送来的数据。
     3.已经连接的客户端发送某个数据，回复相同数据给它。
客户端：
     1.不断开
     2.可以说话给服务端
//服务器端：一个服务器能够同时监听多个客户端请求
#define NUM 10
int main(int argc,char** argv){
        if(argc!=3){
                printf("error args\n");
                return -1;
        }
        int sfd=socket(AF_INET,SOCK_STREAM,0);                      
        if(-1==sfd){
                perror("socket");
                return -1;
        }
        struct sockaddr_in ser;
        memset(&ser,0,sizeof(ser));
        ser.sin_family=AF_INET;
        ser.sin_port=htons(atoi(argv[2]));    
        ser.sin_addr.s_addr=inet_addr(argv[1]);
        int ret;
        ret=bind(sfd,(struct sockaddr*)&ser,sizeof(struct sockaddr));       //绑定端口和IP地址
        if(-1==ret){
                perror("bind");
                return -1;
        }
        ret=listen(sfd,NUM);
        if(-1==ret){
                perror("listen");
                return -1;
        }
        printf("listen success\n");
  
        int addrlen=sizeof(struct sockaddr);
        fd_set rdset;
        int new_fd[NUM]={0};
        int i=0;
        int j;
        fd_set tmpset;
        FD_SET(sfd,&tmpset);          //在tmpset中增加一个sfd  
        char buf[128]={0};
        while(1){
                FD_ZERO(&rdset);
                memcpy(&rdset,&tmpset,sizeof(rdset));
                ret=select(NUM+4,&rdset,NULL,NULL,NULL); //监听rdset中的元素，因为新 
                                                              建的第一个为sfd为3，listen最大的链接数为NUM.
                if(ret >0){
                       if(FD_ISSET(sfd,&rdset)){      //如果有新连接申请 
                                new_fd[i]=accept(sfd,(struct sockaddr*)&client,&addrlen);
                                if(-1==new_fd[i]){
                                        perror("accept");
                                        return -1;
                                }
                                printf("client IP=%s,client port=%d\n",inet_ntoa(client.sin_addr),
                                                                                              ntohs(client.sin_port));
                                FD_SET(new_fd[i],&tmpset);       //放到tmpset集合中 
                                i++;
                        }
                        j=0;
                        while(new_fd[j]!=0){
                                if(FD_ISSET(new_fd[j],&rdset)){  //如果有客户端说话
                                        memset(buf,0,sizeof(buf));
                                        ret=recv(new_fd[j],buf,sizeof(buf),0);
                                        if(ret >0){
                                                printf("%d=%s\n",new_fd[j],buf);
                                                int ret1=send(new_fd[j],buf,strlen(buf),0);
                                                if(-1==ret1){
                                                        perror("send");
                                                        return -1;
                                                }
                                        }else if(ret ==0){                     //如果客户端断开连接
                                                close(new_fd[j]);
                                                FD_CLR(new_fd[j],&tmpset);  //把该客户移除集合中 
                                        }else{
                                                exit(-1);
                                        }
                                }      
                                j++;
                        }
                }
        }              
        return 0;
}
//客户端   
int main(int argc,char** argv){
        if(argc !=3){
                printf("error args\n");
                return -1;
        }
        int sfd=socket(AF_INET,SOCK_STREAM,0);
        if(-1==sfd){
                perror("socket");
                return -1;
        }
        struct sockaddr_in ser;
        memset(&ser,0,sizeof(ser));
        ser.sin_family=AF_INET;
        ser.sin_port=htons(atoi(argv[2]));//一定要用htons
        ser.sin_addr.s_addr=inet_addr(argv[1]);
        int ret;
        ret=connect(sfd,(struct sockaddr*)&ser,sizeof(struct sockaddr));
        if(-1==ret){
                perror("connect");
                return -1;
        }
        char buf[128]={0};
        while(1){
                memset(buf,0,sizeof(buf));
                ret=read(0,buf,sizeof(buf));           //读标准输入 
                if(ret <=0){
                        break;
                }
                ret=send(sfd,buf,strlen(buf)-1,0);
                if(-1==ret){
                        perror("send");
                        return -1;
                }
                memset(buf,0,sizeof(buf));
                ret=recv(sfd,buf,sizeof(buf),0);
                if(-1==ret){
                        perror("recv");
                        return -1;
                }
                printf("%s\n",buf);
        }
        return 0;
}































注意：这是用select实现的，在epoll一节中，会用epoll实现。  

SOCKET编程:UDP通信      
udp都是一个sfd。tcp中的可以写NULL。upd必须要拿出来。
必须先客户端往服务器端发数据，这样服务器端才能拿到客户端的ip.   
                   
int recvfrom(int sockfd,void *buf,int len,unsigned int flags,struct sockaddr *from,int *fromlen); //读到buf中，读len个字节。flags=0.form保存                                                                                                                                发送过来一方的信息。fromlen=sizeof(struct sockaddr)
int sendto(int sockfd, const void *msg,int len,unsigned int flags,const struct sockaddr *to, int tolen);//发送msg,发送的长度为len,flags=0,to是                                                                                                                                    发送给谁。tolen=sizeof(struct sockaddr)   
例一：使用socket接口实现UDP通信  
//使用socket接口实现udp通信的服务器端    
int main(int argc,char** argv){
        if(argc!=3){
                printf("error args\n");
                return -1;
        }
        int sfd=socket(AF_INET,SOCK_DGRAM,0);   //UDP  
        if(-1==sfd){
                perror("socket");
                return -1;
        }      
        printf("sfd=%d\n",sfd);
        struct sockaddr_in ser;
        memset(&ser,0,sizeof(ser));
        ser.sin_family=AF_INET;
        ser.sin_port=htons(atoi(argv[2]));
        ser.sin_addr.s_addr=inet_addr(argv[1]);
        int ret;
        ret=bind(sfd,(struct sockaddr*)&ser,sizeof(struct sockaddr)); //绑定IP和端口  
        if(-1==ret){
                perror("bind");
                return -1;
        }
        struct sockaddr_in client;                                      //定义client用于保存客户端的信息 
        memset(&client,0,sizeof(client));
        int addrlen=sizeof(client);
        char buf[128]={0};
        ret=recvfrom(sfd,buf,sizeof(buf),0,(struct sockaddr*)&client,&addrlen); //服务器端必须先接收，放到buf中，读sizeof(buf)个字节，对方的信息放到client中 
        if(-1==ret){
                perror("recvfrom");
                return -1;
        }
        printf("IP=%s,PORT=%d\n",inet_ntoa(client.sin_addr),ntohs(client.sin_port));
        printf("%s\n",buf);
        ret=sendto(sfd,"Server",6,0,(struct sockaddr*)&client,sizeof(struct sockaddr));                                                                                       //往对方写"Server",6个字节,0,发送给client。
        if(-1==ret){
                perror("sendto");
                return -1;
        }
        close(sfd);
        return 0;
}
//使用socket接口实现udp通信的客户端    
int main(int argc,char** argv){
        if(argc!=3){
                printf("error args\n");
                return -1;
        }
        int sfd=socket(AF_INET,SOCK_DGRAM,0);
        if(-1==sfd){
                perror("socket");
                return -1;
        }      
        printf("sfd=%d\n",sfd);
        struct sockaddr_in ser;
        memset(&ser,0,sizeof(ser));
        ser.sin_family=AF_INET;
        ser.sin_port=htons(atoi(argv[2]));//一定要用htons
        ser.sin_addr.s_addr=inet_addr(argv[1]);
        int ret;
        ret=sendto(sfd,"I am client",11,0,(struct sockaddr*)&ser,sizeof(struct sockaddr));                           //先发送
        if(-1==ret){
                perror("sendto");
                return -1;
        }
        struct sockaddr_in client;
        memset(&client,0,sizeof(client));
        int addrlen=sizeof(client);
        char buf[128]={0};
        ret=recvfrom(sfd,buf,sizeof(buf),0,(struct sockaddr*)&client,&addrlen);
        if(-1==ret){
                perror("recvfrom");
                return -1;
        }
        printf("SERVER IP=%s,PORT=%d\n",inet_ntoa(client.sin_addr),ntohs(client.sin_port));
        printf("%s\n",buf);
        close(sfd);
        return 0;
}




注意：1.必须客户端先向服务器端发送数据，这样服务器端才能知道是谁发来的，以及向谁发。
   2.



单播、广播、多播(组播).

组播：分组。如192.168.4.10-192.168.4.20是一个组


Windows C语言 Socket编程 client端（客户端）--初级（简单版）
零一匠铺
11-04 6773
下面这段代码实现了最基本的client代码，只适用于初学者研究最基本的socket客户端的基本流程。 与本章配套的还有另外一篇文章“Windows C语言 Socket编程 server端（服务器）–初级（简单版）”
socket通信网络模型 ——Epoll、IOCP模型详解以及与select、kqueue等常见模型的区别特点
shaderdx的专栏
11-04 3863
什么是epoll epoll是什么？按照man手册的说法：是为处理大批量句柄而作了改进的poll。当然，这不是2.6内核才有的，它是在2.5.44内核中被引进的(epoll(4) is a new API introduced in Linux kernel 2.5.44)，它几乎具备了之前所说的一切优点，被公认为Linux2.6下性能最好的多路I/O就绪通知方法。  转自
socket实现服务器端和客户端的断线重连
m0_58821493的博客
07-07 947
“client.c” #include<func.h> #define N 10 int main(int argc,char*argv[]) { ARGS_CHECK(argc, 3); int sfd = socket(AF_INET, SOCK_STREAM, 0); printf("sfd=%d\n",sfd); struct sockaddr_in serAddr; serAddr.sin_family = AF_INET; serA...
socket网络编程套接字TCP/UDP两种方式详解
wtl666_6的博客
09-04 7322
socket网络编程套接字TCP/UDP两种方式详解
visual c++网络编程开发与实战 光盘
09-07
在网络编程领域，Visual C++是一种非常重要的开发工具，尤其对于Windows平台而言。它不仅支持传统的Winsock API编程，也适用于现代的网络编程接口和协议。在本书《visual c++网络编程开发与实战》中，读者可以深入...
Python网络编程(Linux)_网络编程_python_linux网络编程_
10-03
Python网络编程在Linux环境下是一个强大的工具，用于构建服务器端应用程序和服务。这个主题涵盖了多个关键知识点，包括基础概念、Python的网络库、套接字编程、并发处理以及在Linux系统中的应用。 1. **网络编程...
C-C++网络编程基础：从Socket到高性能网络库的选择.md
最新发布
09-08
C/C++ 网络编程的基础知识，从 Socket 编程到高性能网络库的选择。首先，文章解释了 Socket 的基本概念及其在网络通信中的作用，包括 TCP 和 UDP 两种主要协议的区别和用法。接着，文章描述了 Socket 编程的典型工作...
Windows网络编程.pdf
09-30
Windows 网络编程 概述 Windows 网络编程是指在 Windows 操作系统平台上进行网络编程的技术，涉及到 Windows Socket、网络协议、网络应用程序的开发等方面。 Windows 网络编程的主要目的是实现高性能的网络应用...
Boost.Asio C++ 网络编程.pdf
10-11
**Boost.Asio C++ 网络编程**是C++编程领域中专注于网络通信的一门技术，由Boost库提供支持。Boost.Asio是Boost库的一部分，它为C++程序员提供了低级和高级的网络API，使得开发高效、可扩展的网络应用程序变得简单。...
网络编程中遇到了argc argv
Tiu_Tiu的专栏
09-19 790
argc argv 　　argc,argv 用命令行编译程序时有用。 　　主函数main中变量(int argc,char *argv[ ])的含义 　　我们平时定义主函数时通常的写法为：int main( )或void main( ) 　　其实，int
网络编程基础知识03
神秘的火柴人的专栏
12-27 341
文章目录1.TCP通讯流程2.C/S模型2.1普通版2.2多进程服务器2.3多线程服务器 1.TCP通讯流程 2.C/S模型 2.1普通版 服务器端： #include &amp;amp;lt;stdio.h&amp;amp;gt; #include &amp;amp;lt;unistd.h&amp;amp;gt; #include &amp;amp;lt;sys/types.h&amp;amp;gt; #include &amp;amp;lt;s
oracle recv buf size,网络编程中send和recv的参数和强制类型转换问题
weixin_36017951的博客
04-11 415
在开始说一下字符问题。声明一个字符数组，若不对其初始化，其值是不确定的，系统为例防止这样的字符串过长，会在内存中相隔不远处置一个字节为0，或者在在申请的数组后不远处置一个0。如charstr[200];可以通过调试窗口观察数组中的值直到最后通过将字符输出的方式也可以看出，全是乱码。在数组后面不远处会有系统置的0，不至于输出太多。而一旦对一个数组初始化，不管用char str[200] = “abc...
linux 网络编程之最简单的tcp通信客户端
风叶
06-11 1502
编写一个最为简单的tcp通信客户端。代码如下： #include #include using namespace std; #include #include #include #include #include int main() { /*创建socket*/ int sd = socket(AF_INET, SOCK_STREAM, 0);
Winsock学习2:用winsock实现socket通讯的client端。
camel的blog
08-12 1586
编译环境：VC++6.0/* *File:client.cpp * */#include #include #include #define DEFAULT_PORT 5150#define DEFAULT_BUFFER 4096#define DEFAULT_MESSAGE "LOGIN"#define DEFAULT_COUNT 20int   iPort  = DEFAULT_PORT;ch
管道文件、select
liupc的学习笔记
05-29 2312
一、管道:mkfifo 1.pipe        //创建管道文件。通过ll可以看到管道文件的文件类型是"p".ll还可以看到管道文件的文件大小为0.因为管道文件不是用                              来存储数据的。管道的特点：1.管道式半双工的，一端读，另一端只能写。2.双方使用同一个管道(即一方读，另一方写)，一方打开管道之后，需要等待另一方打开，才能继续执行。3....
进程的创建、回收和终止
liupc的学习笔记
05-29 2088
一、进程的创建：       //内核里面只有fork 和exec两种可以创建进程。其他方式都是使用的这两种方式，如system()封装了exec。system()fork()exec()popen()二、进程的回收：孤儿进程僵尸进程wait()三、进程的终止：main函数的自热返回；调用exit函数；调用_exit函数；调用abort函数；接收能导致进程终止的信号Ctrl +c SSIGINT ...
linux中read,write与recv,send的区别
liupc的学习笔记
09-23 1264
linux中read,write和recv,send的区别： 1、recv和send函数提供了和read和write差不多的功能。但是他们提供了第四个参数来控制读写操作. int recv(int sockfd,void *buf,int len,int flags) int send(int sockfd,void *buf,int len,int flags) 前面的三个参数和read,write相同，第四个参数能够是0或是以下的组合： ______________...
Linux网络编程基础与协议解析
“Linux网络编程.pdf” 在深入探讨Linux网络编程之前，我们首先需要了解网络协议的基础知识。协议是网络通信的核心，它定义了数据如何在网络中传输以及如何被正确解读。协议可以被视为两台或多台计算机之间通信的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值