最佳技術，用於解析從緩沖區接收的實時char *數據以獲取C ++中的文本內容

Question

我創建了一個實時的連續mjpeg流。 粗略的插圖是這樣的

....[image (jpeg)]->[text "content-length"]->[image (jpeg)]->[text "content-length"]->.... 

如您所見，我從gstreamer媒體管道接收數據，該管道包含圖像和自己注入的文本（注意：盡管我使用的是Gstreamer，但我的問題僅與C ++原則有關。）

為了解析此實時數據，我試圖接收並將其推送到隊列中。 隨后，我計划在隊列包含一定數量的數據包之后解析“內容長度”一詞的數據。

我的代碼如下所示：

void clear( std::queue<char> &q )
{
   std::queue<char> empty;
   std::swap( q, empty );
}


static GstFlowReturn new_buffer (GstAppSink *app_sink, gpointer user_data)
{

  GstBuffer* buffer = gst_app_sink_pull_buffer(app_sink);

  //create queue
  std::queue<char> q;

  g_print("The input buffer contents are\n");

  gint i=0;
  for(i=0; buffer->data[i];i++)
  {  
      //g_print("\n%d",i);
      q.push(buffer->data[i]);
  }
  //g_print("\nsize of inbuf is %d\n",GST_BUFFER_SIZE(buffer)); 
  g_print("\n");  
  gst_buffer_unref(buffer);

  //#####################
  //parsing method here???
  //#####################

  clear(q);
  return GST_FLOW_OK;
}

我以前在C / C ++中使用過循環隊列/環形緩沖區。 那是最好的選擇嗎？ 還是C ++ STL隊列在上述這種情況下更合適？

Answer 1

我最終使用了ringbuffer類

在頭文件中聲明

 //queue size
enum { rb_size = 5 };       // ---->element1 -> element2 -> .... -> elementN -> gap ->
                            // ^                                                     |
                            // |                                                     |  
                            // <--------------------<------------------<-------------V
typedef struct 
{
 char * data[rb_size];
 int head, tail;
} ring_buffer_struct; 

namespace myspace{
class ring_buffer{

    private:

    protected:          

    public: 
    //========= constructor ============
    ring_buffer()  
    {
    //If necessary initialization can happen here.

    }
    //========== destructor =============
    virtual ~ring_buffer()
    {

    }
    //===================================
    virtual void rb_start(ring_buffer_struct *b);
    virtual bool rb_empty(ring_buffer_struct const *b);
    virtual char *  rb_front(ring_buffer_struct const *b);
    virtual char *  rb_rear(ring_buffer_struct const *b);
    virtual void rb_pop_front(ring_buffer_struct *b);
    virtual ring_buffer_struct* rb_push_back(ring_buffer_struct *b);

}; //end of class
}

在cpp文件中

//start
void myspace::ring_buffer::rb_start(ring_buffer_struct *b)
{
b->head = 0; b->tail = 0;
}

//clear
bool myspace::ring_buffer::rb_empty(ring_buffer_struct const *b)
{
    return b->head == b->tail;
}

//front element
char *  myspace::ring_buffer::rb_front(ring_buffer_struct const *b)
{
return b->data[b->head]; //data gets popped
}

//rear element
    char *  myspace::ring_buffer::rb_rear(ring_buffer_struct const *b)
{
return b->data[b->tail]; //data gets pushed
}

//pop out front element
void myspace::ring_buffer::rb_pop_front(ring_buffer_struct *b)
{ 

    if(b->head < b->tail)  
{
      ++b->head; 
    }      
    if(b->head > b->tail)
{     
  b->head = 0;        
}

}

//push in rear element
ring_buffer_struct* myspace::ring_buffer::rb_push_back(ring_buffer_struct *b)
{
int new_tail = b->tail;

if (++new_tail >= rb_size)
{   //beginning of the queue
    new_tail = 0;      
}
if (new_tail != b->head)
{             
   //middle of the queue
    b->tail = new_tail;       
}
 if (new_tail <= b->head) 
     {
       b->tail = 0;           
     }

return b;
}

並在main（）中使用

  ...

char element1[10] = "abcdefghi";
char element2[10] = "bcdefghij";
char element3[10] = "cdefghijk";

ring_buffer_struct rb;
myspace::ring_buffer q;
q.rb_empty(&rb); //make sure empty
q.rb_start(&rb); //start - initialize

    //initialize
    uint16_t i;
    for(i=0;i<rb_size;i++)
    {
     rb.data[rb.tail] = (char *)"000000000";
     q.rb_push_back(&rb);
    }

    rb.data[rb.tail] = element1;
    q.rb_push_back(&rb);
    q.rb_pop_front(&rb);         //now parse    


    rb.data[rb.tail] = element2;
    q.rb_push_back(&rb);
    q.rb_pop_front(&rb);    //now parse

      ...

解析：我看了這篇文章

使用C ++進行簡單的字符串解析

Answer 2

離題建議：

使用交換技巧清除STL容器時，請勿顯式調用std::swap ，因為您最終可能無法獲得優化程度更高的版本。 更好的方法是：

void clear( std::queue<char> &q )
{
   std::queue<char> empty;
   using std::swap;
   swap( q, empty );
}

這樣，編譯器可以選擇專門針對swap的版本，該版本針對您使用的容器類型進行了優化。 您也可以嘗試q.swap(empty); ，但我不確定所有STL的實現都提供該功能。