构造范围内的向量而不复制

Question

I have a class that wraps a big array of bytes that are network packets. The class implements a queue and provides (among others) front() function that returns a const vector of bytes that constitute the oldest packet in the queue.

class Buffer{
  unsigned char data[65536];
  unsigned int offset;
  unsigned int length;
  [...]//other fields for maintaining write ptr etc.

public:
  const std::vector<unsigned char> front(){
    return std::vector<unsigned char>(data + offset, data + offset + length);
  }

  //other methods for accessing the queue like
  //pop(), push(), clean() and so forth...
  [...]
}

The performance of above implementation of front() function suffers from unnecessary copying bytes from the range occupied by the current packet. Since the vector is const, there is no need of making a copy of the data. What I want is to create a vector on the data that are already stored in the buffer. Of course destructor of the vector should not deallocate the memory.

Answer 1

You have some options available to you:

1. Rather than returning a vector , just return a const char* :

const char* front() {
    return data;
}

2. Consider using a standard container, such as a string data as your Buffer member. This will allow you to do:

const string& front() {
    return data;
}

3. The best option though is if you have C++17 or access to experimental::string_view you could just do:

const string_view front() {
    return string_view(data);
}

---

Just a convention comment, there is going to be an expectation of front that it will behave like other standard containers, which:

Returns a reference to the first element in the container.
Calling front on an empty container is undefined.

[ source ]

Bringing front to apply to bare on fixed size arrays was also discussed by the C++ standards committee: front and back Proposal for iterators Library

As it is this method more closely resembles data , which:

Returns a pointer to the block of memory containing the elements of the container.

[ source ]

Answer 2

If you're looking to avoid unnecessary copying then you'll need to return a view into the data. You can either provide a front_begin() and front_end() set of functions:

const char *front_begin() const
{
  return data + offset;
}

const char *front_end() const
{
  return data + offset + length;
}

Or write a wrapper class:

class Data
{
private:
  const char *m_Begin;
  const char *m_End;

public:
  Data(const char *begin, const char *end) : m_Begin(begin), m_End(end)
  {
  }

  const char *begin() const
  {
    return m_Begin;
  }

  const char *end() const
  {
    return m_End;
  }
}

And have your front() method return one of these:

Data front()
{
  return Data(data + offset, data + offset + length)
}

If you're using C++11 then you can use a Data instance in a ranged based for loop:

Data data = buffer.front();
for(char c : data)
{
  // Do something with the data
}