程序员经验分享-hwhale

c++ socket简单封装

2023-05-16

简单封装 并不实际应用

框架图

Mysocket 主要是定义TCP和UDP的一些相同的操作，需要的他们各自去实现。

 Mysocket.h

#ifndef MYSOCKET_H
#define MYSOCKET_H


class MySocket
{
public:
	MySocket();
	~MySocket();
	// 创建一个套接字
	virtual int Create(){};

	// IO操作
	virtual int Send(){};
	virtual int Recvice(){};

	// 关闭
	virtual void Close(){};

     

};

MySocket::MySocket()
{
    
}

MySocket::~MySocket()
{


}


#endif // !MYSOCKET

TcpSocket 首先实现一些客户端和服务端公用的接口，然后利用虚函数定义一些他们各自需要实现的接口。

TcpSocket.h

#ifndef TCPSOCKET_H
#define TCPSOCKET_H

#include <sys/types.h>
#include <sys/socket.h>
#include "MySocket.h"

#include <stdlib.h>

class TcpSocket 
	: public MySocket
{

   public:

	TcpSocket();
	~TcpSocket();

	// 重写覆盖
	int Create() override;
	int Send() override;
	int Recvice() override;
	void Close() override;



	// server端操作
	virtual int Bind(char *IP,int PORT){};
	virtual int Listen(){};
	virtual int Accept(){};


	// client操作
	virtual int Connect(char *IP,int PORT){};


	int fd; // socket描述符
	int fd1; // aceept接受描述符
	char rbuf[1024];
	char sbuf[1024];

};



#endif // !TCPSOCKET_H

TcpSocket.cpp

#include "TcpSocket.h"

#include <iostream>
#include <unistd.h>
using namespace std;


TcpSocket::TcpSocket()
{

}

TcpSocket::~TcpSocket()
{
	Close(); 
}




int TcpSocket::Create()
{
	int f = socket(AF_INET, SOCK_STREAM, 0);
	if(f != -1){
		cout << "socke创建成功:" << f << endl;
	}
	return f;

}



int TcpSocket::Send()
{

	write(fd, sbuf, sizeof(sbuf) - 1);

	return 0;
}

int TcpSocket::Recvice()
{
	
		int s = read(fd1, rbuf, sizeof(rbuf) - 1);
		if(s > 0){

			cout << "client:" << rbuf << endl;
		}
		// if(s == -1){
		// 	// cout << "连接中断" << endl;
		// 	break;
		// }
    
	return s;
}
void TcpSocket::Close()
{
	shutdown(fd, 2);
	shutdown(fd1, 2);

}

 TcpServerSocket实现服务端特有的功能

  TcpServerSocket.h

#ifndef TCPSERVERSOCKET_H
#define TCPSERVERSOCKET_H
#include <sys/types.h>
#include <sys/socket.h>

#include "TcpSocket.h"



class TcpServerSocket : public TcpSocket
{
public:
    TcpServerSocket();
    ~TcpServerSocket();

    int Bind(char *IP,int PORT) override;
    int Listen() override;
    int Accept() override;


};






#endif // !TCPSERVERSOCKET_H

 TcpServerSocket.cpp

#include "TcpServerSocket.h"
#include <iostream>
#include <sys/types.h>
#include <sys/socket.h>
#include<stdlib.h>
#include<unistd.h>
#include <netinet/in.h>
#include <arpa/inet.h>

using namespace std;
TcpServerSocket::TcpServerSocket()
{
}

TcpServerSocket::~TcpServerSocket()
{
    
}

int TcpServerSocket::Bind(char *IP,int PORT)
{
    cout << "+++++++++" << endl;
    struct sockaddr_in sin;

    cout << "addr1:" << IP << endl;
    cout << "PORT1:"<< PORT << endl;
    sin.sin_family=AF_INET;
    sin.sin_port=htons(PORT);
    sin.sin_addr.s_addr = inet_addr(IP);
    // cout << "addr:" << sin.sin_addr.s_addr << endl;
    // cout << "PORT:"<< sin.sin_port << endl;


    if(bind(fd, (struct sockaddr *)&sin, sizeof(sin)) < 0){
        cout << "绑定失败" << endl;
        return -1;
    }
    else
    {
        cout << "绑定成功" << endl;
        
    }
    return 0;

}

int TcpServerSocket::Listen()
{
  
    if(listen(fd, 50) < 0){
        cout << "监听失败" << endl;
        return -1;
    }
    else{
        cout << "listening。。。。。。" <<endl;
    }
    return 0;

}

int TcpServerSocket::Accept()
{
    struct sockaddr_in sin;

    socklen_t len = sizeof(struct sockaddr);
    
    fd1 = accept(fd, (sockaddr *)&sin, &len);

    if(fd1 != -1){
        cout << "accepting...."<<endl;
        return fd1;
    }
    else{
        cout << "accept失败" << endl;
       
    }
    return -1;
}

 TcpClientSocket.h

#ifndef TCPCLIENTSOCKET_H
#define TCPCLIENTSOCKET_H

#include "TcpSocket.h"
#include <sys/types.h>
#include <sys/socket.h>


class TcpClientSocket :
	public TcpSocket
{
public:

	TcpClientSocket();
	~TcpClientSocket();
	

	int Connect(char *IP,int PORT) override;



};


#endif

 TcpClientSocket.cpp

#include "TcpClientSocket.h"
#include <iostream>
#include <sys/types.h>
#include <sys/socket.h>
#include<stdlib.h>
#include<unistd.h>
#include <netinet/in.h>
#include <arpa/inet.h>

using namespace std;
TcpClientSocket::TcpClientSocket()
{
}

TcpClientSocket::~TcpClientSocket()
{
}

int TcpClientSocket::Connect(char *IP,int PORT)
{

    struct sockaddr_in sin;

    sin.sin_family=AF_INET;
    sin.sin_port=htons(PORT);
    sin.sin_addr.s_addr = inet_addr(IP);

    int e = connect(fd, (sockaddr *)&sin, sizeof(sin));
    if(e!= -1){
        std::cout << "连接成功" << std::endl;
    }
    else
    {
        std::cout << "连接失败" << std::endl;
        return -1;
    }
	return 0;
}

测试代码

server.cpp

#include <iostream>
#include "TcpSocket.h"
#include "TcpServerSocket.h"

#include<sys/types.h>
#include<sys/socket.h>
#include<stdlib.h>
#include<unistd.h>
#include <netinet/in.h>
#include <arpa/inet.h>

using namespace std;

int main(int argc, const char** argv) {



    TcpSocket *socket = new TcpServerSocket();

    socket->fd = socket->Create();


    // cout << "+++++++++" << endl;
    socket->Bind("127.0.0.1",1477);
    socket->Listen();
    socket->Accept();


    while (1)
    {
        socket -> Recvice();
        
    }

    return 0;
}

 client.cpp

#include <iostream>
#include "TcpSocket.h"
#include "TcpClientSocket.h"

#include<sys/types.h>
#include<sys/socket.h>
#include<stdlib.h>
#include<unistd.h>
#include <netinet/in.h>
#include <arpa/inet.h>

using namespace std;

int main(int argc, const char** argv) {




    TcpSocket *socket = new TcpClientSocket();

    socket->fd = socket->Create();


    int e = socket->Connect("127.0.0.1",1477);

    if(e != -1)
        {
            while (1)
            {
                cin >> socket -> sbuf;
                cout << "sbuf:" << socket -> sbuf <<endl;
                socket -> Send();
            }
        }



    cout << "111";
    return 0;
}

UDP的代码直接放一块了

// UdpSocket.h
#ifndef UDPSOCKET_H
#define UDPSOCKET_H

#include "MySocket.h"

class UdpSocket
     : public MySocket
{

public:
    UdpSocket();
    ~UdpSocket();

    int Create() override;



	// IO操作
	virtual int Sendto(char *IP, int PORT){};
	virtual int Recvfrom(){};


	virtual int Bind(char *IP,int PORT){};

	// 关闭
    void Close() override;

	int fd; // socket描述符
	// int fd1; // aceept接受描述符
    char sbuf[1024];

};




#endif // !UDPSOCKET_H



//UdpSocket.cpp
#include "UdpSocket.h"
#include <sys/socket.h>
#include <iostream>
#include <unistd.h>
using namespace std;


UdpSocket::UdpSocket()
{

}

UdpSocket::~UdpSocket()
{
	Close(); 
}




int UdpSocket::Create()
{
	int f = socket(AF_INET, SOCK_DGRAM, 0);
	if(f != -1){
		cout << "socke创建成功:" << f << endl;
	}
	return f;

}


void UdpSocket::Close()
{
	shutdown(fd, 2);
	// shutdown(fd1, 2);

}

// UdpServerSocket.h
#include "UdpSocket.h"


class UdpServerSocket
    : public UdpSocket
{
public:
    UdpServerSocket();
    ~UdpServerSocket();


    int Bind(char *IP,int PORT) override;
    int Recvfrom() override;

    char rbuf[1024];


};


//UdpServerSocket.cpp

#include "UdpServerSocket.h"
#include <iostream>
#include <sys/types.h>
#include <sys/socket.h>
#include<stdlib.h>
#include<unistd.h>
#include <netinet/in.h>
#include <arpa/inet.h>
using namespace std;
UdpServerSocket::UdpServerSocket()
{
    
}

UdpServerSocket::~UdpServerSocket()
{


}

int UdpServerSocket::Bind(char *IP,int PORT)
{
    cout << "+++++++++" << endl;
    struct sockaddr_in sin;

    cout << "addr1:" << IP << endl;
    cout << "PORT1:"<< PORT << endl;
    sin.sin_family=AF_INET;
    sin.sin_port=htons(PORT);
    sin.sin_addr.s_addr = inet_addr(IP);
    // cout << "addr:" << sin.sin_addr.s_addr << endl;
    // cout << "PORT:"<< sin.sin_port << endl;

    if(bind(fd, (struct sockaddr *)&sin, sizeof(sin)) < 0){
        cout << "绑定失败" << endl;
        return -1;
    }
    else
    {
        cout << "绑定成功" << endl;
        
    }
    return 0;

}

int UdpServerSocket::Recvfrom()
{

        struct sockaddr_in clientaddr;
        socklen_t len = sizeof(sockaddr_in);
		int s = recvfrom(fd, rbuf, sizeof(rbuf) - 1, 0, (struct sockaddr *) &clientaddr, &len);
		if(s > 0){

			cout << "client:" << rbuf << endl;
		}
		// if(s == -1){
		// 	// cout << "连接中断" << endl;
		// 	break;
		// }
    
	return s;
}

// UdpClientSocket.h
#include "UdpSocket.h"


class UdpClientSocket
    : public UdpSocket
{
public:
    UdpClientSocket();
    ~UdpClientSocket();

    int Sendto(char *IP, int PORT) override;

    


};

// UdpClientSocket.cpp

#include "UdpClientSocket.h"
#include <iostream>
#include <sys/types.h>
#include <sys/socket.h>
#include<stdlib.h>
#include<unistd.h>
#include <netinet/in.h>
#include <arpa/inet.h>

using namespace std;
UdpClientSocket::UdpClientSocket()
{
    
}

UdpClientSocket::~UdpClientSocket()
{


}
int UdpClientSocket::Sendto(char *IP, int PORT)
{
    struct sockaddr_in serveraddr;
    serveraddr.sin_family = AF_INET;
    serveraddr.sin_addr.s_addr = inet_addr(IP);
    serveraddr.sin_port = htons(PORT);
    socklen_t  len = sizeof(sockaddr_in);
	sendto(fd, sbuf, sizeof(sbuf) - 1, 0, (struct sockaddr *) &serveraddr, len);

	return 0;
}

// server.cpp

#include <iostream>
#include "UdpSocket.h"
#include "UdpServerSocket.h"

#include<sys/types.h>
#include<sys/socket.h>
#include<stdlib.h>
#include<unistd.h>
#include <netinet/in.h>
#include <arpa/inet.h>

using namespace std;

int main(int argc, const char** argv) {



    UdpSocket *socket = new UdpServerSocket();

    socket->fd = socket->Create();


    // cout << "+++++++++" << endl;
    socket->Bind("127.0.0.1",1221);


    while (1)
    {
        socket -> Recvfrom();
        
    }
    

    cout << "asd";
    return 0;
}


//client.cpp

#include <iostream>
#include "UdpSocket.h"
#include "UdpClientSocket.h"

#include<sys/types.h>
#include<sys/socket.h>
#include<stdlib.h>
#include<unistd.h>
#include <netinet/in.h>
#include <arpa/inet.h>

using namespace std;

int main(int argc, const char** argv) {




    UdpSocket *socket = new UdpClientSocket();

    socket->fd = socket->Create();

    while (1)
    {
        cin >> socket -> sbuf;
        socket->Sendto("127.0.0.1",1221);

    }

    cout << "111";
    return 0;
}

 

本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容，请联系:hwhale#tublm.com(使用前将#替换为@)

c++ socket简单封装 的相关文章

随机推荐

  • C语言实现任意栈之间的进制转换

    题目 xff1a 利用栈 xff0c 将十进制数字N转换为D进制 xff08 D 61 2 8 16 xff09 xff0c 其中16进制对应的符号是0 9 xff0c A F 要求 xff1a 十进制数字和N进制从键盘输入获得 xff0c

  • 防止C语言头文件被重复包含

    文章目录 方法一 xff1a 使用宏保护防止C语言头文件被重复包含 xff08 很常用 xff09 方法二 xff1a pragma once 在头文件的最开始加入 比较常用 xff09 参考链接 xff1a https blog csdn

  • 栈的应用之括号匹配算法

    算法思路 xff1a 初始化一个栈 xff0c 命名为s 依次遍历待匹配的字符串 如果当前字符为左括号 xff08 即 39 39 39 39 39 39 中的任意一个 xff09 xff0c 则将其入栈 如果当前字符为右括号 xff08

  • jsp页面在浏览器中显示乱码（ 没有账号？）

    错误 xff1a jsp页面在浏览器显示乱码 xff0c 如下图所示 xff1a 解决方法 xff1a 主要是因为浏览器使用的编码格式与自己开发文件存储内容的编码不一致导致的 xff0c 所以需要在jsp页面中添加如下代码 xff0c 问题

  • 队列的应用之打印杨辉三角形

    题目 xff1a 利用队列打印杨辉三角形 特点 xff1a 杨辉三角除第一行为两个1以外 xff0c 从第二行开始 xff0c 每一行的首尾都为1 xff0c 中间位置的数为上一行中与之相邻的两个数之和 xff0c 可以使用我们学过的队列问

  • 栈和队列的应用之停车问题

    题目 xff1a 设停车场是一个可停放n辆汽车的狭长通道 xff0c 且只有一个大门可供汽车进出 汽车在停车场内按车辆到达时间的先后顺序 xff0c 依次由北向南排列 xff08 大门在最南端 xff0c 最先到达的第一辆车停放在停车场的最

  • Jupyter Notebook 安装与使用教程

    一 什么是Jupyter Notebook xff1f 1 简介 Jupyter Notebook是基于网页的用于交互计算的应用程序 其可被应用于全过程计算 xff1a 开发 文档编写 运行代码和展示结果 Jupyter Notebook官

  • java.lang.NoSuchMethodError: org.springframework.core.type.AnnotationMetadata.introspect之解决方法

    错误 xff1a idea中使用spring整合mybatis报错 xff1a java lang NoSuchMethodError org springframework core type AnnotationMetadata int

  • 栈和队列的应用之回文数判断

    题目 xff1a 采用栈和队列的方法检测并输出一个单词是否为回文 代码 xff1a include lt stdio h gt include lt malloc h gt define SIZE 20 using namespace st

  • 二叉链表树的遍历

    题目 xff1a 使用二叉链表树创建算法Status CreatBiTree BiTree amp T 和其他代码 二叉树的遍历有三种 xff1a 前序遍历 xff1a 先访问根节点 xff0c 再遍历左子树 xff0c 最后遍历右子树 x

  • opencv的框架与各模块功能介绍

    记录一下自己的所学知识 xff0c 便于日后回顾与整理 文中内容多为摘录 xff0c 具体链接如下 xff1a 摘录自 xff1a https zhuanlan zhihu com p 33008701 xff08 框架介绍 xff09 h

  • Android调用C/C++库

    AndroidStudio版本2021 1 1 一 AndroidStudio将C C 43 43 库打包成so库过程 AndroidStudio新建NativeC 43 43 工程 xff1b 在Tools gt SDK Manager里

  • SocketCan 应用编程

    SocketCan 应用编程 由于 Linux 系统将 CAN 设备作为网络设备进行管理 xff0c 因此在 CAN 总线应用开发方面 xff0c Linux 提供了SocketCAN 应用编程接口 xff0c 使得 CAN 总线通信近似于

  • QT开发笔记（继承 QObject 的线程 ）

    继承 QObject 的线程 在第 10 章章节开头已经说过 xff0c 继承 QThread 类是创建线程的一种方法 xff0c 另一种就是继承 QObject 类 继承 QObject 类更加灵活 它通过 QObject moveToT

  • CoppeliaSim：视觉传感器的使用与属性参数

    视觉传感器类型 http www coppeliarobotics com helpFiles index html Orthographic projection type the field of view of orthographi

  • 华为Atlas200DK环境配置指南(版本20.0.0)

    官方参考文档 https support huaweicloud com usermanual A200dk 3000 atlas200dk 02 0024 html 务必保证配置时版本 20 0 0 一致 1 配置开发环境 自己电脑 若不

  • PX4 QGC地面站自定义参数

    QGC地面站自定义参数 xff08 新手操作 xff09 v1 8 2 QGC以往版本下载地址 htps github com mavlink qgroundcontrol tags 最终的添加结果如下 xff1a 具体步骤如下 xff1a

  • Linux网络编程----UDP编程基础知识

    UDP概述 UDP 是 User Datagram Protocol 的简称 xff0c 中文名是用户数据报协议 xff0c 是一个简单的面向数据报的传输层协议 xff0c 在网络中用于处理数据包 xff0c 是一种无连接的协议 UDP 不

  • get 命令汇总

    get 命令汇总 git config 配置 Git 的相关参数 Git 一共有3个配置文件 xff1a 1 仓库级的配置文件 xff1a 在仓库的 git gitconfig xff0c 该配置文件只对所在的仓库有效 2 全局配置文件 x

  • c++ socket简单封装

    简单封装 并不实际应用 框架图 Mysocket 主要是定义TCP和UDP的一些相同的操作 xff0c 需要的他们各自去实现 Mysocket h ifndef MYSOCKET H define MYSOCKET H class MySo

热门标签