用流来封装SOCKET通信的一种方法

最新推荐文章于 2022-07-31 16:14:52 发布
最新推荐文章于 2022-07-31 16:14:52 发布
阅读量3.7k 收藏 1
点赞数
文章标签： socket basic stream class ios interface
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/h8135/article/details/305989
版权

1.1 需求来源目前XXXXX软件的维护控制工具是命令行输入的，后来因为用户需求变化，还要支持提供一个远程TELNET端口，从而实现远程多用户同时维护功能。因为目前就是通过流来读取命令行上的输入，如果能够将TELNET端口的输入也通过流来读取，目前的实现基本上不做修改。另外，如果真的实现这个功能，原来实现的，将来要实现的所有工具都可以同等对待文件输入，标准输入，网络数据；可以用同样的方式输出到文件，标准输出，网络上去，应用将非常广泛。

1.1       C++流

C++流的输入输出总是要通过一个缓冲区来实现的。见下图

流与缓冲区之间的关系是通过basic_ios来维护的：

template<class Ch, class Tr = char_traits<Ch> >

class basic_ios: public ios_base{

public:

       。。。

       basic_streambuf<Ch,Tr>* rdbuf() const;  //获取缓冲区

       basic_streambuf<Ch,Tr>* rdbuf(basic_streambuf<Ch,Tr>* b); //设置新缓冲区，返回原来的缓冲区

};

各种不同类型的缓冲区都是从basic_streambuf继承来的，basic­_streambuf在出现不同缓冲区策略的地方提供了一些虚函数，例如处理缓冲区上溢和下溢的函数，清除缓冲区的函数。如果我们要提供新的缓冲策略和新的输入目标或输出目标，一个正确的起点就是从basic­_streambuf继承实现自己的新类，重载必要的虚函数。然后这个新的streambuf就可以和任何一种已有的流，比如stringstream，strstream等一起使用了。

最简单的情况下，如果我们要求I/O操作是非缓冲的，只需要重载basic­_streambuf的上溢和下溢的虚函数，如果我们有自己的缓冲区，一般还要重载一个清除缓冲区的虚函数，它在流关闭的时候或显示调用flush操作的时候将缓冲区的内容发送实际目的地并清空它。

1.2       我们的封装方式

我们需要的缓冲区应该从SOCKET上读取数据和将输入通过SOCKET发送出去。为了我们实现缓冲区的通用性，不能将我们实现的缓冲区和SOCKET的接口调用绑定在一起分开。稍微抽象一下，我们需要的缓冲区依赖一个这样的接口：

struct readwriter{

int read(char* s, int len);  //完成从实际目的地读取数据的功能，传入保存数据的缓冲区，缓冲区长度为len，返回实际读取的数据长度

int write(const char* s, int len); //完成发送数据到实际目的地的功能，需要发送的数据在长度为len的缓冲区中，返回发送成功的数据的长度。

}

想实现SOCKET的读写操作，做一个简单的适配处理就可以完成，这个适配处理的过程就不在本文提及了。我们的缓冲区依赖上面这个接口，当然因为标准库中的streambuf都是利用模板来实现的，因此上面的接口就作为一个模板参数输入。

另外，写入我们streambuf的数据不应该从streambuf中读出来，这一点是和标准库中的其他streambuf输入输出共用一个字符缓冲区不一样。这就意味着我们需要维护读写两个缓冲区，读缓冲区保存从readwriter获取的数据，写缓冲区保存写往readwriter的数据。这样前面说的缓冲区的上溢应该是指写缓冲区满的情况；缓冲区的下溢应该是指读缓冲区数据为空的情况；清空缓冲区(sync)的操作应该是针对写缓冲区而言。

根据前面的分析，我们可以得出下面的定义：

template<class RW, class charT, class traits = char_traits<chart> >

class streambufadaptor: public basic_stringbuf<charT, traits>

{

       RW& _rw;

Public:

       typedef charT                   char_type;

    typedef traits::int_type        int_type;

    typedef traits::pos_type        pos_type;

    typedef traits::off_type        off_type;

    typedef traits                  traits_type;

       streambufadaptor(RW& rw): _rw(rw){}

protected:

       virtual int sync()

       {

              计算缓冲区中的数据量，将这些数据写入 _rw 中

              重新设置写指针到缓冲区的首部

       }

       virtual int_type overflow(charT c)

       {

              首先调用sync虚函数，将缓冲区中的内容清空，并重新设置写指针

              保存输入的c到缓冲区

       }

       virtual int_type underflow()

       {

              根据读缓冲区的大小调用 _rw.read 函数读取数据

       }

};

       完整的实现参见附件中的定义

1.3       streambufadaptor的使用方式

前面提到过，streambuf和stream是在basic_ios中连接在一起的。因为很多流，比如strstream,stringstream等的实现都隐藏了basic_ios<>::rdbuf(streambuf*)的实现，我们必须将一个实际的流上溯为一个basic_ios进行替换操作。见下面的例子：

stringstream strout;

RW rw；//RW是自己实现的一个读写类

streambufadaptor<RW,char> mybuf(rw);

iostream& streamref = strout;

streamref.rdbuf(&mybuf);

strout << “this is a test” << …

string s;

strout >> s;

….

上面的使用方式比较繁琐，希望有个简单易用的方式来替换它。借鉴 scopeguard 的实现和使用方式，有下面的方案：

1． 定义一个streamadaptor类，在其构造函数中完成rdbuf的调用，析构函数中恢复

2． 因为我们不直接操作streamadaptor类，利用scopeguard定义宏的技巧。

3． 因为使用人员只应该看到两个界面，一个是输入输出界面的stream，一个是底层数据的实际读写类，至于中间的streambufadaptor可以被隐藏起来。

具体的实现细节参见附件。

最后我们的调用方式如下：

stringstream strout;

RW rw；//RW是自己实现的一个读写类

//streambufadaptor<RW,char> mybuf(rw);

//iostream& streamref = strout;

//streamref.rdbuf(&mybuf);

STREAM_ADPATOR(strout,rw); //这是我们实现流和SOCKET连接的全部语句

strout << “this is a test” << …

string s;

strout >> s;

….

 

1.4       附件（完整的实现）


/**************************
***
*** dept: test
*** author: htj
***
*************************/

#include <streambuf>

namespace std{

/** Rw have the following interface:
 interface Rw
 {
  int write(const charT* s, streamsize size);
  int read(charT* s, streamsize size);
 };
**/

template<class Rw ,class charT,class traits = char_traits<charT> >
class streambufadaptor: public basic_streambuf<charT,traits>
{
 Rw& _rw;
 charT *_out;
 streamsize _out_len;
 charT *_in;
 streamsize _in_len;
 streambufadaptor(const streambufadaptor&);
 streambufadaptor& operator=(const streambufadaptor&);
public:
 typedef charT   char_type;
     typedef traits::int_type        int_type;
     typedef traits::pos_type        pos_type;
     typedef traits::off_type        off_type;
     typedef traits                  traits_type;

 streambufadaptor(Rw& rw,ios_base::openmode mode = ios_base::in | ios_base::out | ios_base::binary): _rw(rw),_out(0),_out_len(0),_in(0),_in_len(0){
  setg(_in,_in,_in);
  setp(_out,_out + _out_len);
  basic_streambuf<charT,traits>::mode_ = mode;
 }
 ~streambufadaptor()
 {
  if(_out) free_out_buf();
  if(_in) free_in_buf();
 }
private:
 void init_out_buf()
 {
  _out_len = 512;
  _out = new charT[_out_len];
  setp(_out,_out + _out_len);
 }
 void free_out_buf()
 {
  delete [] _out;
  _out = 0;
  _out_len = 0;
  setp(0,0);
 }
 void init_in_buf()
 {
  _in_len = 512;
  _in = new charT[_in_len];
  setg(_in,_in,_in);
 }

 void free_in_buf()
 {
  delete [] _in;
  _in = 0;
  _in_len = 0;
  setg(_in,_in,_in);
 }
protected:
 virtual int_type overflow(int_type c)
 {
  if((basic_streambuf<charT,traits>::mode_ & ios_base::out) == 0) {
       return traits::eof();
      }
  sync();
  if(traits::eq_int_type(c,traits::eof()) )
   return traits::not_eof(c);
  else
  {
   if(pptr() == 0) init_out_buf();
   return sputc(c);
  }
 }

 virtual int_type underflow()
 {
  if((basic_streambuf<charT,traits>::mode_ & ios_base::in) == 0) {
       return traits::eof();
      }
  if(egptr() == 0)
   init_in_buf();
  if(egptr() == _in + _in_len)
   setg(_in,_in,_in);
  int tmp = _rw.read(egptr(),_in + _in_len - egptr());
  if(tmp < 1) return traits::eof();
  setg(eback(),egptr(),egptr() + tmp);
  return traits::to_int_type(*gptr());
 }
 virtual int sync()
 {
  if(pptr() > pbase()){
   int tmp = pptr() - pbase();
   int tmp1 = _rw.write(pbase(),tmp);
   if(tmp1 < 1)
    return -1;
   if(tmp1 < tmp)
   {
    memcpy(pbase(),pbase() + tmp1, tmp - tmp1);
    setp(pbase(),epptr());
    pbump(tmp1);
   }else
    setp(pbase(),epptr());  
  }
  return 0;
 }
};

class streamadaptor_base{};
typedef const streamadaptor_base& StreamAdaptor;

template<class stream,class Rw>
class streamadaptor: public streamadaptor_base
{
public:
 typedef typename stream::char_type char_type;
 typedef typename stream::traits_type traits_type;
private:
 basic_ios<char_type,traits_type>& _stream ;
 streambufadaptor<Rw,char_type,traits_type> _buff; 
 basic_streambuf<char_type,traits_type>* _oldbuf;
public:
 streamadaptor(stream& s,Rw& rw):_stream(s),_buff(rw){
  _oldbuf = _stream.rdbuf(&_buff);
 }
 ~streamadaptor(){
  _stream.rdbuf(_oldbuf);
 }
 operator stream&(){ return _stream; }
 stream& get() { return _stream; }
};

template<class Stream, class Rw>
streamadaptor<Stream,Rw> MakeStreamAdaptor(Stream& s,Rw& rw)
{
 return streamadaptor<Stream,Rw>(s,rw);
}

#define CONCATENATE_DIRECT(s1, s2) s1##s2
#define CONCATENATE(s1, s2) CONCATENATE_DIRECT(s1, s2)
#define ANONYMOUS_VARIABLE(str) CONCATENATE(str, __LINE__)

#define STREAM_ADAPTOR StreamAdaptor ANONYMOUS_VARIABLE(streamAdaptor) = MakeStreamAdaptor


}

h8135
关注
中国移动联手多家通信巨头推行“绿色包装”
从头再来
11-08 843
                              2008年7月30日，在北京2008年奥运会开幕倒计时8天之日，中国移动联手11家通信行业设备厂商，在采购、物流、工程建设等重要环节推行“绿色包装”，为通信行业践行绿色奥运做出了新的贡献。  在中国移动“绿色包装”启动仪式上，中国移动邀请华为、上海贝尔阿尔卡特、大唐电信、爱立信、烽火通信、摩托罗拉、诺基亚西门子通信、北电网络、中国
#include＜ostream＞源代码
cz123_的博客
05-06 465
#include<ostream>源代码
PB 封装的SOCKET通讯组件
06-21
PB封装API制作的SOCKET组件，借用网上资源做了修改，使用比MSWinsock控件稳定。
IO流 Socket通信入门
ଳxin的博客
08-11 198
package com.tencent.network; import java.io.IOException; import java.io.OutputStream; import java.net.InetAddress; import java.net.Socket; import java.net.UnknownHostException; public class Client { public static void main(String[] args) { Ine.
在socket数据传输下 的缓冲流和数据流
m0_57265087的博客
08-13 874
昨天看了篇写的很棒的关于socket缓冲区的讲解。 socket套接字及缓冲区详解@lx青萍之末 引自其博客。 上图反应的是客户端和服务端数据传输的模式图，主要说明的是，客户端 socket 通过write()方法写出去后，并不是直接在网络中传输数据，而是将数据写入缓冲区。然后内核协栈将缓冲区的数据通过TCP协议发送到对端主机的输入缓冲区（注意这个过程不受程序控制，因为将数据写入输出缓冲区时，函数已经返回）。数据从接收端的缓冲区输入程序缓冲区，这个过程由类似read的方法完成。 ...
Android安卓使用iosocket进行Socket通信简单封装优雅写代码
01-13
`io.socket`库是Android开发者常用来实现WebSocket和TCP/IP Socket通信的一个优秀框架，它提供了一种优雅的方式来处理网络连接。本文将详细介绍如何使用`io.socket`进行Socket通信的简单封装，以便在迭代开发中提高...
Android TCP Socket通信封装
03-14
在Android开发中，TCP Socket通信是移动应用与服务器进行数据交互的一种常见方式。TCP（Transmission Control Protocol）是一种面向连接的、可靠的、基于字节流的传输层通信协议，确保了数据的顺序传输和数据完整性...
Android中使用socket使底层和framework通信的实现方法
01-20
android中GSP模块提供一种解决思路，但是实现有些复杂，这里介绍一种使用socket通信的方法可以使native和framework自 由通信，具体实现如下： android中使用jni对linux中的socket进行了封装。使用起来十分的方便。 ...
unity与winform 使用socket通信.rar
08-07
在Unity与Winform之间使用Socket通信时，通常会创建一个服务器端（通常是Winform应用）来监听特定的端口，等待客户端（Unity应用）的连接请求。一旦连接建立，双方就可以通过发送和接收数据进行通信。 在Winform中...
C/C++封装socket通信类
ymxyld的博客
05-17 3967
不管是socket通信程序的客户端还是服务端，准备工作的代码又长又难看占地方，影响了主程序的结构，必须分离出来。 一、C的封装方法 C语言只能把程序代码封装成函数。 1、客户端 把客户端连接服务端的socket操作封装到connecttoserver函数中，主程序的代码更简洁。 // TCP客户端连服务端的函数，serverip-服务端ip，port通信端口 // 返回值：成功返回已连接socket，失败返回-1。 int connecttoserver(const char *serverip,const
进程间的六种通信方式之socket
ZHENYU的博客
07-31 7339
对于UDP来说，不需要要维护连接，那么也就没有所谓的发送方和接收方，甚至都不存在客户端和服务端的概念，只要有一个socket多台机器就可以任意通信，因此每一个UDP的socket都需要bind。UDP是没有连接的，所以不需要三次握手，也就不需要像TCP调用listen和connect，但是UDP的交互仍然需要IP地址和端口号，因此也需要bind。所以，监听的socket和真正用来传送数据的socket，是「这里需要注意的是，服务端调用。...
一个简单的socket封装
wtyqm的专栏
05-05 3494
SSSocket, 意思是simple stupid socket interface 目的： 编写一个易于消息数据读写、非阻塞、跨平台的socket封装。目前用于手机网游客户端 优点: 1.采用非阻塞的连接和IO，即使是单线程也不会阻塞UI 2.提供读写buffer 3.对完整消息读取友好的API 缺点： 1.单线程使用方式，目前考虑是游戏的每一帧，非阻塞
通过Socket套接字和NetWorkStream流进行网络传输
herocao的专栏
12-30 1470
 通过Socket套接字和NetWorkStream流进行网络传输，通过NetWork流来发出链接的要求字符串得到Google主页网站的源代码，利用Socket套接字来链接Google的服务器发送请求和接收数据完成网络传输功能，主要利用了Dns类获取IPAddress来建立链接，以后还有讲到利用TCP和UDP进行通信在封装了Socket类的基础上能够更容易的实现网络的通信。源代码如下：usin
七、输入/输出流--streambuffer类介绍--自定义缓冲区
jingza的博客
08-21 1268
【基本上没看懂，那个大神如果可以的话，推荐一点相关资料，真的不太明白这个缓冲区的内部原理】3 自定义缓冲区 缓冲区有basic_streambuf定义，针对字型为char和wchar 标准库提供了预定义的streambuf和wstreambuf 缓冲区的主要接口由函数返回的三个指针构成：(1) read(input)缓冲区的接口由： eback() gptr() egptr() (2) write
C++流的streambuf详解及TCP流的实现
weixin_34357436的博客
06-20 576
前言 streambuf是C++流(iostream)与流实体(或者叫原始流，文件、标准输入输出等)交互的桥梁 # 文件流 fstream <--> filebuf <--> file # 字符串流 stringstream <--> stringbuf <--> string 文件流和字符串流是C++标准库已经提供了的，现在我的目标是实现一个使用T...
C++访问类的私有成员变量的方法(友元函数、友元类)
热门推荐
$firecat利白的代码足迹$
03-06 2万+
// win32Test.cpp : Defines the entry point for the console application. // #include "stdafx.h" class A { public: A(){;} ~A(){;} public: int fun(A& one) { //表达式1:错误 //return one.fun
简单的stream socket例子
nice_wen的博客
09-24 1630
服务器端： #include #include #include #include int main(){ int sock_server, sock_client; struct sockaddr_in server_addr, client_addr; server_addr.sin_family = AF_INET; server_addr.sin_port = htons(666
封装的Socket通信类库
在C++编程中，封装Socket类是将底层的网络通信接口包装成易于使用的对象，便于管理和操作。在给定的代码中，我们看到一些关键的定义和函数，这有助于理解Socket编程的基本元素： 1. **头文件引用**：`#include ...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值