c++ socket 网络通信

1.服务端

流程：

1、创建套接字，即调用socket(),根据需要选择参数类型

2、根据地址和端口号，绑定服务端，即调用bind()

3、将套接字设为监听套接字，并设置监听数，即调用listen()

4、阻塞等待等待客户端连接请求，即调用accept()

5、接受发送消息，即调用recv(),send()函数

6、关闭套接字，即调用close()

#include <iostream>
#include <string>
#include <sys/types.h>          
#include <sys/socket.h>
#include <arpa/inet.h>
#include <cstring>
#include <unistd.h>
#include <cstdio>
using namespace std;

class Server
{
        private:
                int port;   // 设置端口号
                int serverfd;  // 定义服务端套接字
                int clientfd;    // 定义客户端套接字
                int backlog;    //  设置客户端最大连接数
                struct sockaddr_in serveraddr;  // 定义服务端socket地址结构体
                struct sockaddr_in clientaddr;    //定义客户端socket地址结构体
                socklen_t clientlen;    // 定义客户端地址字节数，所以是int型
        public:
                Server(int port = 10000):port(port),serverfd(-1),clientfd(-1),backlog(10)
                // 这里的port(port),表示用10000初始化Port，其他同理，完成初始化赋值
                {
                        serverfd = socket(AF_INET, SOCK_STREAM, 0);  
                        // 创建套接字对象，参数为AF_INET协议族，流式套接字
                        if(serverfd == -1)
                        {
                                throw("create socket error");
                        }
                        // 这里初始化服务端地址的相关参数，参数的结构为sockaddr型
                        serveraddr.sin_family = AF_INET; // AF_INET协议族
                        serveraddr.sin_port = htons(port);   // 将端口号转换为网络字节型端口
                        serveraddr.sin_addr.s_addr = htonl(INADDR_ANY); // 获取本机地址，并转为网络字节型

                        bind(serverfd, (struct sockaddr*)&serveraddr, sizeof(serveraddr));
                        // 这里绑定服务端地址，注意第二个参数，必须传指针，类型为void*
                        listen(serverfd, backlog);
                        // 监听服务端，并设置最大监听数
                }
                void run()
                {
                        // 等待客户端的连接，阻塞式连接，注意参数类型
                        clientfd = accept(serverfd, (struct sockaddr*)&clientaddr, &clientlen);
                        char data[100];
                        int ret1;
                        // 接受客户端发来的消息
                        ret1 = recv(clientfd, data, sizeof(data), 0);
                        cout << "i receive data --> " << data << "\n";
                        int ret2;
                        // 发送消息给客户端
                        ret2 = send(clientfd, "i receive your data", strlen(data), 0);
                        //close(clientfd);
                }
                ~Server()
                {
                        cout << "close server...." << "\n";
                        if(clientfd != -1)
                        {
                            // 关闭套接字
                                close(clientfd);
                        }
                        if(serverfd != -1)
                        {
                                close(serverfd);
                        }
                }
int test()
{
        Server *s = NULL;
        // 定义指针
        try
        {
                s = new Server;
                // 为server分配内存空间
                s->run();
                // 使用指针运行run函数
        }catch(const char* e)
        {
                cout << e << "\n";
        }
        delete s;
        // 清理内存
}

int main(int argc, char *argv[])
{
        test();
}

2.客户端

流程：

1、创建套接字,即调用socket()

2、根据地址，端口号绑定地址，即调用bind()

3、发起连接服务端请求，即调用connect()

4、接收发消息，即recv(),send()

5、关闭套接字，close()

#include <iostream>
#include <string>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <fcntl.h>
#include <cstring>
#include <cstdio>
#include <signal.h>

using namespace std;

class Client
{
        private:
                int port;
                int serverfd;
                struct sockaddr_in serveraddr;
        public:
                Client(int port = 10000):port(port),serverfd(-1)
                {
                        serverfd = socket(AF_INET, SOCK_STREAM, 0);
                        if(serverfd == -1)
                        {
                                throw("create socket error");
                        }
                        serveraddr.sin_family = AF_INET;
                        serveraddr.sin_port = htons(port);
                        inet_pton(AF_INET, "127.0.0.1", &serveraddr.sin_addr.s_addr);
                        int ret1;
                        ret1 = connect(serverfd, (struct sockaddr*)&serveraddr, sizeof(serveraddr));

                }
                void run()
                {
                        char* data;
                        int ret2;
                        data = "hello";
                        ret2 = send(serverfd, data, strlen(data), 0);
                }
                ~Client()
                {
                        cout << "close client..." << "\n";
                        if (serverfd == -1)
                        {
                                close(serverfd);
                        }
                }
};
int test()
{
        try
        {
                Client *c = NULL;
                c = new Client;
                c->run();
                delete c;
        }catch(const char* e)
        {
                cout << e << "\n";
        }
}

int main(int argc, char *argv[])
{
        test();
}