copy on write

B从A处复制了一个复杂对象，B当且仅当要写这个对象的时候才从A拷贝一份真实的数据过来。写时才拷贝（Copy-On-Write）技术，就是编程界“懒惰行为”——拖延战术的产物。举个例子，比如我们有个程序要写文件，不断地根据网络传来的数据写，如果每一次fwrite或是fprintf都要进行一个磁盘的I/O操作的话，都简直就是性能上巨大的损失，因此通常的做法是，每次写文件操作都写在特定大小的一块内存中（磁盘缓存），只有当我们关闭文件时，才写到磁盘上（这就是为什么如果文件不关闭，所写的东西会丢失的原因）。

  1. #include <iostream>
  2. #include <cstring>
  3. #include <chrono>
  5. #include <vector>
  6. #include <sstream>
  7. #include <iterator>
  8. #include <algorithm>
  10. // COW string
  11. struct String {
  12. private:
  13.   struct Impl {
  14.     size_t length;
  15.     size_t capacity;
  16.     size_t use_count;
  18.     Impl(size_t length, size_t capacity, size_t use_count)
  19.       :length(length),
  20.       capacity(capacity),
  21.       use_count(use_count) {
  22.     }
  24.     Impl(const Impl &other) 
  25.       :length(other.length),
  26.       capacity(other.capacity),
  27.       use_count(other.use_count) {
  28.     }
  29.   };
  30.   char* ptr;
  31.   Impl* impl;
  33. public:
  34.   explicit String(const char* str);
  35.   String(const String &other);
  36.   ~String();
  38.   struct WriteProxy {
  39.     void operator= (char c) {
  40.       if (ptr[index] != c && impl->use_count != 1) {
  41.         char *new_data = new char[impl->capacity];
  42.         strncpy(new_data, ptr, impl->length);
  43.         ptr = new_data;
  44.         Impl *new_impl = new Impl(*impl);
  45.         --impl->use_count;
  46.         new_impl->use_count = 1;
  47.         impl = new_impl;
  48.       }
  49.       ptr[index] = c;
  50.     }
  52.     ~WriteProxy() {
  53.       std::clog << "delete WriteProxy" << std::endl;
  54.     }
  56.     char* &ptr;
  57.     Impl* &impl;
  58.     size_t index;
  59.   };
  61.   WriteProxy operator[](size_t index) {
  62.     std::clog << "WriteProxy" << std::endl;
  64.     return WriteProxy {ptr, impl, index};
  65.   }
  67.   char operator[](size_t index) const {
  68.     std::clog << "char operator[]" << std::endl;
  69.     return ptr[index];
  70.   }
  72.   friend std::ostream &operator<<(std::ostream &os, const String &str) {
  73.     os << str.ptr << std::endl;
  74.     return os;
  75.   }
  76. };
  78. String::String(const char *str) {
  79.   ptr = new char[strlen(str) + 1];
  80.   strcpy(ptr, str);
  81.   impl = new Impl {strlen(str), strlen(str) + 1, 1};
  82. }
  84. String::String(const String &other) {
  85.   ptr = other.ptr;
  86.   impl = other.impl;
  87.   ++impl->use_count;
  88. }
  90. String::~String() {
  91.   --impl->use_count;
  92.   if (impl->use_count == 0) {
  93.     delete[] ptr;
  94.     delete impl;
  95.   }
  96. }
  98. int main() {
  99.   String a("Hello");
  100.   std::clog << a;
  101.   String b(a);
  102.   std::clog << b;
  103.   String c(a);
  104.   std::clog << c;
  106.   auto jj = c[3];
  107.   jj = '3';
  109.   std::clog << a;
  110.   std::clog << b;
  111.   std::clog << c;
  112.   return 0;
  113. }

COW - 图1

核心代码

  1.   struct WriteProxy {
  2.     void operator= (char c) {
  3.       if (ptr[index] != c && impl->use_count != 1) {
  4.         char *new_data = new char[impl->capacity];
  5.         strncpy(new_data, ptr, impl->length);
  6.         ptr = new_data;
  7.         Impl *new_impl = new Impl(*impl);
  8.         --impl->use_count;
  9.         new_impl->use_count = 1;
  10.         impl = new_impl;
  11.       }
  12.       ptr[index] = c;
  13.     }
  15.     char* &ptr;
  16.     Impl* &impl;
  17.     size_t index;
  18.   };
  20.   WriteProxy operator[](size_t index) {
  21.     return WriteProxy {ptr, impl, index};
  22.   }

将 String 类的 ptr 和 impl 传给了 char &ptr; Impl &impl; 所以在 WriteProxy 中是可以直接访问到 String 类中的 ptr 和 impl 。