deque中包含类，类中有new出来的数组，deque.pop_front()报错

deque中包含类，类中有new出来的数组，deque.pop_front()出错！
deque通过push_back()来添加类的多个对象，

类的对象中有new开辟的数组，长度各不相同，

现在发现调用deque.pop_frot() 删除队列中对象时出错，



push_back() 跟 pop_frot() 在不同的线程中，  


而且还发现push_back()填进去的数据是正确的，但是 front()取出来的数据则可能会出错，
------解决方案--------------------
deque不是线程安全的，需要加锁。参考：

//循环向a函数每次发送200个字节长度（这个是固定的）的buffer,

//a函数中需要将循环传进来的buffer，组成240字节（也是固定的）的新buffer进行处理，

//在处理的时候每次从新buffer中取两个字节打印

#ifdef WIN32

    #pragma warning(disable:4996)

#endif

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#ifdef WIN32

    #include <windows.h>

    #include <process.h>

    #include <io.h>

    #define  MYVOID             void

    #define  vsnprintf          _vsnprintf

#else

    #include <unistd.h>

    #include <sys/time.h>

    #include <pthread.h>

    #define  CRITICAL_SECTION   pthread_mutex_t

    #define  MYVOID             void *

#endif

//Log{

#define MAXLOGSIZE 20000000

#define MAXLINSIZE 16000

#include <time.h>

#include <sys/timeb.h>

#include <stdarg.h>

char logfilename1[]="MyLog1.log";

char logfilename2[]="MyLog2.log";

static char logstr[MAXLINSIZE+1];

char datestr[16];

char timestr[16];

char mss[4];

CRITICAL_SECTION cs_log;

FILE *flog;

#ifdef WIN32

void Lock(CRITICAL_SECTION *l) {

    EnterCriticalSection(l);

}

void Unlock(CRITICAL_SECTION *l) {

    LeaveCriticalSection(l);

}

void sleep_ms(int ms) {

    Sleep(ms);

}

#else

void Lock(CRITICAL_SECTION *l) {

    pthread_mutex_lock(l);

}

void Unlock(CRITICAL_SECTION *l) {

    pthread_mutex_unlock(l);

}

void sleep_ms(int ms) {

    usleep(ms*1000);

}

#endif

void LogV(const char *pszFmt,va_list argp) {

    struct tm *now;

    struct timeb tb;


    if (NULL==pszFmt
------解决方案--------------------
0==pszFmt[0]) return;

    vsnprintf(logstr,MAXLINSIZE,pszFmt,argp);

    ftime(&tb);

    now=localtime(&tb.time);

    sprintf(datestr,"%04d-%02d-%02d",now->tm_year+1900,now->tm_mon+1,now->tm_mday);

    sprintf(timestr,"%02d:%02d:%02d",now->tm_hour     ,now->tm_min  ,now->tm_sec );

    sprintf(mss,"%03d",tb.millitm);

    printf("%s %s.%s %s",datestr,timestr,mss,logstr);

    flog=fopen(logfilename1,"a");

    if (NULL!=flog) {

        fprintf(flog,"%s %s.%s %s",datestr,timestr,mss,logstr);

        if (ftell(flog)>MAXLOGSIZE) {

            fclose(flog);

            if (rename(logfilename1,logfilename2)) {

                remove(logfilename2);

                rename(logfilename1,logfilename2);

            }

        } else {

            fclose(flog);

        }

    }

}

void Log(const char *pszFmt,...) {

    va_list argp;


    Lock(&cs_log);

    va_start(argp,pszFmt);

    LogV(pszFmt,argp);

    va_end(argp);

    Unlock(&cs_log);

}

//Log}

#define ASIZE    200

#define BSIZE    240

#define CSIZE      2

char Abuf[ASIZE];

char Cbuf[CSIZE];

CRITICAL_SECTION cs_HEX ;

CRITICAL_SECTION cs_BBB ;

struct FIFO_BUFFER {

    int  head;

    int  tail;

    int  size;

    char data[BSIZE];

} BBB;

int No_Loop=0;

void HexDump(int cn,char *buf,int len) {

    int i,j,k;

    char binstr[80];