C++ I/O 重定向方法(定向到串口或Socket)

C++ 标准输入输出模块,为字符流操作提供了便捷的途径,软件开发当中,尤其是嵌入式系统开发当中,有时候需要把流信息重新定向到特定的端口,如串口,以太网,USB等。如标准输入输出cout cin默认将字符流定向到屏幕或控制台。本文介绍了如何重载streambuf使得使用ostream istream 将字符流定向到特定的外设。

本文所演示的代码:http://download.csdn.net/detail/besidemyself/6917955

本文来自:http://blog.csdn.net/turkeyzhou/article/details/8983379 在此基础上修改为一般的通用接口。

 

首先来看一下标准库中有关IO的类体系结构:

 

除了ios_base之外,其它类都定义为模板,这是因为C++中有两种字符类型:charwchar_tios_base定义了同字符类型无关的属性和操作,basic_ios则定义了同字符类型相关的属性和操作,basic_istreambasic_ostream分别定义了同输入和输出相关的操作,basic_iostream同时支持输入和输出。

 

在整个类体系结构中,最重要的的是basic_streambuf,它提供了缓冲功能以及真正地操作外部设备,其它类则只负责字符串的格式化操作。这体现了职责分离的设计原则,basic_streambuf和其它类之间是松耦合关系,对其中一方进行修改不会影响到另一方,因此,我们只需要继承basic_streambuf,定义出一个使用套接字进行IO操作的类即可。

 

basic_streambuf是一个模板,IO库根据它分别定义了两个类(真正的定义语句并不是这样的,模板参数不仅仅是一个,这里只是为了方便说明):

?

1

2

typedef basic_streambuf<char> streambuf;

typedef basic_streambuf<wchar_t> wstreambuf;

 

我们可以根据字符的实际类型选择继承streambufwstreambuf。当然,也可以将自己的类定义为模板,继承basic_streambuf,不过这样的话需要多写一些代码,具体操作可以参考《C++标准程序库》,本文的例子直接继承streambuf

 

basic_streambuf既定义了输出相关操作,也定义了输入相关操作,这意味它同时支持输入和输出。我们也可以只实现输出或者输入,让它只支持某种操作。首先来看下如何实现输出。

 

用于输出的streambuf

basic_streambuf中输出相关的操作主要有sputcsputn,前者输出一个字符,后者输出多个字符。如果提供了缓冲区,那么sputc将字符复制到缓冲区内,如果缓冲区已经满了或者没有提供缓冲区,sputc会调用overflow,将数据写入外部设备并清空缓冲区。sputn会调用xsputn,而xsputn的默认操作是对每个字符调用sputc。由此可见,实现输出要做的事情很简单,只要重写overflow方法即可。另外也可以重写xsputn方法,以优化多个字符的输出。

 

无缓冲方式

下面是不使用缓冲区的实现方式:

?

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

#include <streambuf>

#include <WinSock2.h>

 

class SocketOutStreamBuf : public std::streambuf {

public:

    SocketOutStreamBuf(SOCKET socket) : m_socket(socket) {

    }

     

protected:

    int_type overflow(int_type c) {

 

        if (c != EOF) {

 

            if (send(m_socket, (char*)&c, 1, 0) <= 0) {

                return EOF;

            }

        }

 

        return c;

    }

 

private:

    SOCKET m_socket;

};

 

可以看到,无缓冲方式的实现非常简单,只要将参数直接写入到套接字中就可以了,如果写入成功,返回刚写入的那个字符;如果失败,返回EOF,也可以抛出异常——这个由你决定。int_type是在字符特性类(traits)中定义的类型,表示能容纳所有字符的类型,这个类型肯定不是charwchar_t,因为EOFWEOF超出了这些类型的范围。

 

有缓冲方式

把字符一个一个地写入套接字是非常低效的,因此我们希望SocketOutStreamBuf能提供缓冲功能,有缓冲方式的实现如下所示:

?

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

#include <streambuf>

#include <WinSock2.h>

 

class SocketOutStreamBuf : public std::streambuf {

public:

    SocketOutStreamBuf(SOCKET socket) : m_socket(socket) {

        setp(m_buffer, m_buffer + BufferSize - 1);

    }

     

    ~SocketOutStreamBuf() {

        sync();

    }

 

protected:

    int_type overflow(int_type c) {

 

        if (c != EOF) {

            *pptr() = c;

            pbump(1);

        }

 

        if (FlushBuffer() == EOF) {

            return EOF;

        }

 

        return c;

    }

 

    int sync() {

 

        if (FlushBuffer() == EOF) {

            return -1;

        }

 

        return 0;

    }

 

private:

    int FlushBuffer() {

 

        int len = pptr() - pbase();

 

        if (send(m_socket, m_buffer, len, 0) <= 0) {

            return EOF;

        }

 

        pbump(-len);

 

        return len;

    }

 

    SOCKET m_socket;

    static const int BufferSize = 512;

    char m_buffer[BufferSize];

};

 

首先我们需要自己定义一个缓冲区,然后在构造方法中通过setp方法把缓冲区的头尾指针告诉basic_streambuf,这样一来就具有了缓冲功能。有三个方法可以获取与缓冲区相关的指针:pbasepptrepptr,它们分别获取的是缓冲区的头指针,当前写入位置的指针以及缓冲区尾部下一个位置的指针,如下图所示:

 

pptr() != epptr()时,缓冲区是未满的,此时sputc只是把字符复制到pptr所在位置,然后把pptr移动到下一个位置,不会调用overflow;当pptr() == epptr()时,缓冲区是满的,此时sputc会调用overflow,并把放不进缓冲区内的字符作为overflow的参数。在上面代码的构造方法中,之所以把缓冲区的最后一个位置作为尾指针(用m_buffer +BufferSize - 1作为第二个参数,而不是m_buffer + BufferSize),是因为这样可以在overflow中手动将参数放到最后一个位置,然后将整个缓冲区的数据一起发送出去。pbump方法用来移动当前写入位置的指针,参数的值是相对位置,在发送完数据之后需要用pbump将指针移回到缓冲区头部。

 

另外,提供了缓冲功能的话还需要重写sync方法,该方法用于同步缓冲区同外部设备的数据,意思就是将缓冲区的数据写入到外部设备中,不管它有没有满。如果该方法成功的话,返回0,否则返回-1。在析构方法中也要调用sync,确保数据被写入到外部设备中。

 

使用自定义的输出streambuf

定义好了我们自己的SocketOutStreamBuf之后,只要将它与ostream组合在一起就能在套接字上使用IO库的强大功能,如下所示:

?

1

2

3

4

5

6

7

8

9

SOCKET socket;

SocketOutStreamBuf outBuf(socket);

std::ostream outStream(&outBuf);

 

std::string line;

while (std::getline(std::cin, line)) {

    outStream << line << std::endl;

}

上面的代码用于将控制台上的输入写入到套接字中。

 

用于输入的streambuf

basic_streambuf中输入相关的操作有sgetcsbumpcsgetnsungetcsputbackc。其中sungetcsputbackc用于回退字符,这个功能不常用到,而且也不太可能在套接字上回退字符,因此这里省略对回退字符的介绍,关于这方面的内容可以参考《C++标准程序库》。

 

sgetcsbumpc都用于读取一个字符,区别是后者会将读取位置向后移动一个位置,而前者不会改变读取位置。如果没有提供缓冲区,或者缓冲区的内容已经读完,那么sgetc会调用underflow方法,而sbumpc会调用uflow方法,从外部设备读取更多数据。uflow的默认行为是调用underflow,然后移动缓冲区的读取指针,如果没有提供缓冲区,则必须同时重写underflowuflowsgetn用于读取多个字符,它会调用xsgetn,而xsgetn的默认行为是依次调用sbumpc,如果为了改善读取多个字符的性能,可以重写xsgetn方法。

 

无缓冲方式

首先来看下无缓冲方式的输入实现,如下所示:

?

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

#include <streambuf>

#include <WinSock2.h>

 

class SocketInStreamBuf : public std::streambuf {

public:

    SocketInStreamBuf(SOCKET socket) : m_socket(socket) {

    }

     

    int_type underflow() {

 

        char c;

        if (recv(m_socket, &c, 1, MSG_PEEK) <= 0) {

            return EOF;

        }

 

        return c;

    }

 

    int_type uflow() {

 

        char c;

        if (recv(m_socket, &c, 1, 0) <= 0) {

            return EOF;

        }

 

        return c;

    }

 

private:

    SOCKET m_socket;

};

 

无缓冲的实现需要同时重写underflowuflow,根据这两个方法的定义,前者不移动读取位置,后者反之,而recv函数的MSG_PEEK选项刚好可以对应这两种行为。

 

有缓冲方式

从套接字逐个读取字符也是非常低效的过程,添加缓冲功能是再自然不过的事情,如下所示:

?

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

#include <streambuf>

#include <WinSock2.h>

 

class SocketInStreamBuf : public std::streambuf {

public:

    SocketInStreamBuf(SOCKET socket) : m_socket(socket) {

        setg(m_buffer, m_buffer, m_buffer);

    }

     

    int_type underflow() {

 

        int recvLen = recv(m_socket, m_buffer, BufferSize, 0);

 

        if (recvLen <= 0) {

            return EOF;

        }

 

        setg(m_buffer, m_buffer, m_buffer + recvLen);

 

        return *gptr();

    }

 

private:

    SOCKET m_socket;

    static const int BufferSize = 512;

    char m_buffer[BufferSize];

};

 

跟输出的实现一样,我们也需要自己定义一个缓冲区,然后用setg方法设置缓冲区的指针。与setp不同,setg方法需要设置三个指针,分别是缓冲区头指针,当前读取位置指针以及缓冲区尾部下一个位置指针,这些指针可通过eback()gptr()egptr()方法获取。这比输出缓冲区复杂,因为输入缓冲区需要支持回退功能。输入缓冲区图示如下:

 

当读取字符时,gptr向右移动,直到gptr() == egptr()时,调用underflow从外部设备补充数据。当回退字符时,gptr向左移动,直到gptr() == gback()时,就不能再回退字符了。

 

在上面代码的构造方法中,用setg把三个指针都设置到缓冲区头部,这样一来,就不支持回退了,而且第一次读取会导致underflow被调用。在underflow中,将数据读取到缓冲区之后还要调用setg重新设置一下缓冲区指针,由于是gptr() == eback(),所以仍然不支持回退。

 

上文说过,如果提供了缓冲区,那么就不需要重写uflow了,所以提供了缓冲功能的SocketInStreamBuf看上去比无缓冲功能的还要简单。

 

使用自定义的输入streambuf

跟输出的一样,只要将SocketInStreamBufistream组合在一起,就可以利用强大的IO功能了:

?

1

2

3

4

5

6

7

8

9

SOCKET socket;

SocketInStreamBuf inBuf(socket);

std::istream socketStream(&inBuf);

 

std::string line;

while (std::getline(socketStream, line)) {

    std::cout << line << std::endl;

}

上面的代码从套接字读取数据,然后输出到控制台上。

 


你可能感兴趣的:(C++,IO,串口,tcpip)