想要实现 C++ 管理一段内存块

如下是一个简单的 c++ class。目标是作为一个容器管理一段连续的内存，并且可以简单别太浪费，不要内存泄漏地被 copy/move。

水平太菜自觉考虑难以周全，所以想要求 v 友们指教下代码还有哪些 bug。

无论是本身的指点，还是更好的实现思路的指教都非常感谢。


typedef uint8_t byte;

class Bytes {
 public:
  Bytes() noexcept : data_(nullptr), size_(0) {}

  // 给定 string, 读取数据后保存
  explicit Bytes(const string& data) noexcept
      : Bytes(reinterpret_cast<const byte*>(data.data()), data.size()) {}

  
  explicit Bytes(const byte* bytes, size_t size) noexcept {
    assign(bytes, size);
  }

  Bytes(const Bytes& rhs) noexcept : data_(rhs.data_), size_(rhs.size_) {}

  Bytes(const Bytes&& rhs) noexcept
      : data_(std::move(rhs.data_)), size_(rhs.size_) {}

  virtual ~Bytes() {}

  const size_t size() const noexcept { return size_; }

  const std::shared_ptr<byte> data() const noexcept { return data_; }

  // return is empty
  const bool Empty() const noexcept {
    return data_.get() == nullptr || size() == 0;
  }

  string String() const noexcept {
    return data_.get() == nullptr
               ? string()
               : string(reinterpret_cast<const char*>(data_.get()), size());
  }

  string HexString() const noexcept {
    size_t n = size_;
    char* cout = new char[n * 2];
    const char* rune = "0123456789abcdef";
    for (size_t i = 0; i < n; i++) {
      byte uc = data_.get()[i];
      // little-endian
      cout[2 * i] = rune[uc >> 4];
      cout[2 * i + 1] = rune[uc & 0xf];
    }
    string out(cout, n * 2);
    delete[] cout;
    return out;
  }

  int Compare(const Bytes& that) const noexcept {
    size_t sz = size();
    size_t that_sz = that.size();
    size_t min_sz = (sz < that_sz) ? sz : that_sz;
    int r = memcmp(data().get(), that.data().get(), min_sz);
    return r != 0 ? r : (sz == that_sz ? 0 : (sz < that_sz ? -1 : +1));
  }

  // Return the nth byte in the referenced data.
  // Didn't check: n < size
  byte& operator[](size_t n) noexcept {  //
    return data_.get()[n];
  }

  std::shared_ptr<byte> Resize(size_t size) noexcept {
    std::shared_ptr<byte> new_data(new byte[size],
                                   std::default_delete<byte[]>());
    memset(new_data.get(), 0, size);
    if (this->data_.get() != nullptr) {
      size_t min_sz = (size < this->size_) ? size : this->size_;
      memcpy(static_cast<byte*>(new_data.get()),
             static_cast<const byte*>(this->data_.get()), min_sz);
    }
    this->data_.swap(new_data);
    this->size_ = size;
    return this->data_;
  }

  static Bytes ConcatBytes(const vector<Bytes>& v) noexcept {
    Bytes bytes;
    size_t sz = 0;
    for (auto i : v) {
      sz += i.size();
    }
    bytes.Resize(sz);
    size_t off = 0;
    for (auto i : v) {
      bytes.writeTo(i.data_.get(), off, i.size());
      off += i.size();
    }
    return bytes;
  }

 private:
  std::shared_ptr<byte> data_;
  size_t size_;

  void clear() noexcept {
    data_.reset();
    size_ = 0;
  }

  void writeTo(const byte* bytes, size_t offset, size_t size) noexcept {
    memcpy(data_.get() + offset,  //
           static_cast<const byte*>(bytes), size);
  }

  void assign(const byte* bytes, size_t size) noexcept {
    std::shared_ptr<byte> new_data(new byte[size],
                                   std::default_delete<byte[]>());
    memcpy(static_cast<byte*>(new_data.get()), static_cast<const byte*>(bytes),
           size);
    size_ = size;
    data_.swap(new_data);
  }
};

wutiantong

2018-12-04 15:30:34 +08:00

C++里面做数据结构封装时的最佳实践就是值语义，而你这段代码就是一个典型的违反值语义的示范。
那么这会带来什么问题呢？请看下面的例子：

Bytes s1("Hello");
auto s2 = s1;
s2[1] = 'a';

对 s2 的改动会意外的传递给 s1，在现代 C++中这段代码表现出来的行为是完全反直觉的。

同样在内部涉及到大量的动态内存分配操作，而 STL 中的各种容器（ vector, set, map ）无一例外的遵循着值语义。

C++之所以提倡值语义而不必担心引入额外的性能开销，是因为 C++提供了引用，指针，移动这一系列利器。

也就是说当你实现了一个值语义的 Bytes 后，你就可以免费享受：
1. Bytes &
2. Bytes *
3. Bytes &&
4. std::shared_ptr<Bytes>, std::unique_ptr<Bytes>

而像现在这样一个不遵循值语义的 Bytes 只会引入无尽的混乱。