字符串操作类，主要用在808协议数据的处理方面

808协议数据处理类

直接上代码，头文件如下：

/* 
 * File:   ByteBuffer.h
 * Author: shaozg
 *
 * Created on 2013年11月19日, 上午10:04
 */

#ifndef BYTEBUFFER_H
#define	BYTEBUFFER_H

class ByteBuffer {
public:
    ByteBuffer();
    ByteBuffer(const ByteBuffer& orig);
    virtual ~ByteBuffer();
    
    void appendChar(const char ch);
    char getChar(const int index);
    
    void appendShort(const short sh);
    short getShort(const int index);
    
    void appendInt(const int i);
    int getInt(const int index);
    
    void appendStr(const char * str, const int count);
    char * subBytes(const int index, const int count);

    void insertFirstChar(const char ch);
    
    void reduce();
    void escapse();
private:
    char *m_data;
    int m_size;
};

#endif	/* BYTEBUFFER_H */

源文件内容如下：

/* 
 * File:   ByteBuffer.cpp
 * Author: shaozg
 * 
 * Created on 2013年11月19日, 上午10:04
 */


#include "ByteBuffer.h"


#include <string.h>
#include <stdio.h>
#include <stdlib.h>


#define DELETE_BUFFER(poi) if (poi != NULL) { \
                        delete poi; \
                        poi = NULL; \
                        }


ByteBuffer::ByteBuffer() {
    m_data = NULL;
    m_size = 0;
}


ByteBuffer::ByteBuffer(const ByteBuffer& orig) {
    if (orig.m_data != NULL && strlen(orig.m_data) > 0) {
        const int len = strlen(orig.m_data);
        m_size = len;
        m_data = (char *)malloc(len);
        memset(m_data, 0, len);
        memcpy(m_data, orig.m_data, len);
    }
}


ByteBuffer::~ByteBuffer() {
    fprintf(stdout, "Destructor");
    DELETE_BUFFER(m_data);
}


void ByteBuffer::appendChar(const char ch) {
    if (m_data == NULL) {
        m_data = (char *)malloc(1);
        *m_data = ch;
    } else {
        char *p = (char *)malloc(strlen(m_data) + 1);
        memcpy(p, m_data, strlen(m_data));
        p[strlen(m_data)] = ch;
        DELETE_BUFFER(m_data);
        m_data = p;
    }
    m_size += 1;
}


char ByteBuffer::getChar(const int index) {
    char ch = 0;
    if (m_data == NULL || m_size < index) {
        fprintf(stderr, "error index.");
        ch = 0;
    } else {
        ch = m_data[index];
    } 
    return ch;
}


void ByteBuffer::appendShort(const short sh) {
    if (m_data == NULL) {
        m_data = (char *)malloc(sizeof(short));
        m_data[0] = sh >> 8;
        m_data[1] = sh & 0xff;
    } else {
        const int len = m_size;
        char *p = (char *)malloc(len + 2);
        memcpy(p, m_data, len);
        p[len] = sh >> 8;
        p[len + 1] = sh & 0xff;
        DELETE_BUFFER(m_data);
        m_data = p;
    }
    m_size += 2;
}


short ByteBuffer::getShort(const int index) {
    short sh = 0;
    if (m_data == NULL || m_size < index + 1) {
        fprintf(stderr, "error index.");
        sh = 0;
    } else {
        sh = getChar(index) & 0xff;
        sh <<= 8;
        sh |= getChar(index + 1) & 0xff;
    }
    return sh;
}


void ByteBuffer::appendInt(const int i) {
     if (m_data == NULL) {
        m_data = (char *)malloc(sizeof(int));
        m_data[0] = i >> 24;
        m_data[1] = (i >> 16) & 0xff;
        m_data[2] = (i >> 8) & 0xff;
        m_data[3] = i & 0xff;
    } else {
        const int len = m_size;
        char *p = (char *)malloc(len + 4);
        memcpy(p, m_data, len);
        p[len] = i >> 24;
        p[len + 1] = (i >> 16) & 0xff;
        p[len + 2] = (i >> 8) & 0xff;
        p[len + 3] = i & 0xff;
        DELETE_BUFFER(m_data);
        m_data = p;
    }
     m_size += 4;
}


int ByteBuffer::getInt(const int index) {
    int i = 0;
    if (m_data == NULL || m_size < index + 1) {
        fprintf(stderr, "error index.");
        i = 0;
    } else {
        i = getChar(index) & 0xff;
        i <<= 8;
        i |= getChar(index + 1) & 0xff;
        i <<= 8;
        i |= getChar(index + 2) & 0xff;
        i <<= 8;
        i |= getChar(index + 3) & 0xff;
    }
    return i;
}
    
void ByteBuffer::appendStr(const char * str, const int count) {
    if (str != NULL && count > 0) {
        char *p = (char *)malloc(m_size + count);
        memcpy(p, m_data, m_size);
        memcpy(&p[m_size], str, count);
        DELETE_BUFFER(m_data);
        m_data = p;
        m_size += count;
    }
}


char * ByteBuffer::subBytes(const int index, const int count) {
    char *p = (char *)malloc(count);
    bcopy(&m_data[index], p, count);
    return p;
}
    
void ByteBuffer::insertFirstChar(const char ch) {
    if (m_size == 0) {
        appendChar(ch);
    } else {
        char *p = (char *)malloc(m_size + 1);
        
        bcopy(p, m_data, m_size);
        *(p + m_size) = ch;
        m_size += 1;
        DELETE_BUFFER(m_data);
        m_data = p;
    }
}


// replace 0x7d 0x01 with 0x7d and 0x0d 0x02 with 0x7e
void ByteBuffer::reduce() {
    if (m_size == 0) {
        return ;
    }
    
    char *p = (char *)malloc(m_size);
    int data_len = 0;
    char *q = p;
    for (int i = 0; i < m_size - 1; i ++) {
        if (getChar(i) == 0x7d && getChar(i + 1) == 0x01) {
            *q ++ = 0x7d;
        } else if (getChar(i) == 0x7d && getChar(i + 1) == 0x02) {
            *q ++ = 0x7e;
        } else {
            *q ++ = getChar(i);
        }
        data_len ++;
    }
    DELETE_BUFFER(m_data);
    m_data = (char *)malloc(data_len);
    memcpy(m_data, p, data_len);
    m_size = data_len;
    DELETE_BUFFER(p);
}


// loop every character, replace 0x7d with 0x7d 0x01 and 0x7e with 0x7d 0x02
void ByteBuffer::escapse() {
    if (m_size == 0) {
        return ;
    }
    
    char * p = (char *)malloc(m_size * 2);
    int data_len = 0;
    memset(p, 0, m_size * 2);
    char * q = p;
    for (int i = 0; i < m_size; i ++) {
        if (getChar(i) == 0x7d) {
            *q ++ = 0x7d;
            *q ++ = 0x01;
            data_len += 2;
        } else if (getChar(i) == 0x7e) {
            *q ++ = 0x7d;
            *q ++ = 0x02;
            data_len += 2;
        } else {
            *q ++ = getChar(i);
            data_len += 1;
        }
    }
    
    DELETE_BUFFER(m_data);
    m_data = (char *)malloc(data_len);
    memcpy(m_data, p, data_len);
    DELETE_BUFFER(p);
    m_size = data_len;
}

测试函数如下：

/* 
 * File:   main.cpp
 * Author: dev
 *
 * Created on 2013年11月19日, 上午10:03
 */

#include <cstdlib>
#include <stdio.h>
#include "ByteBuffer.h"

using namespace std;

/*
 * 
 */
int main(int argc, char** argv) {
    ByteBuffer b;
    b.appendChar('a');
    b.appendShort(12);
    b.appendInt(456);
    b.appendStr("hello", 5);
    
    int index = 0;
    char ch = b.getChar(index);
    index += 1;
    short sh = b.getShort(index);
    index += 2;
    int i = b.getInt(index);
    index += 4;
    char * str = b.subBytes(index, 5);
    
    printf("ch = %c\nsh = %d\ni = %d\nstr = ", ch, sh, i);
    for (int i = 0; i < 5; i ++) {
        printf("%c", str[i]);
    }
    printf("\n");
    free(str);
    return 0;
}

测试结果如下:

注意：reduce和escape这两个函数没有测试！

谢谢大家！！