深入理解C/C++中的写时拷贝

写时拷贝

何为写时拷贝？ 前面我说过深拷贝浅拷贝，今天我们来探究一下写时拷贝。深拷贝是补充了浅拷贝的不足，写时拷贝其实也就是补充一点深拷贝的不足。其实写时拷贝的意思就是： 当你读取到这个空间的时候，并不会开辟出一个一模一样的空间出来给你，当你真正需要拷贝的时候，那么他就会开辟出空间给你。也就是拖延版的深拷贝。

写时拷贝技术是通过"引用计数"实现的，在分配空间的时候多分配4个字节，用来记录有多少个指针指向块空间，当有新的指针指向这块空间时，引用计数加一，当要释放这块空间时，引用计数减一(假装释放)，直到引用计数减为0时才真的释放掉这块空间。当有的指针要改变这块空间的值时，再为这个指针分配自己的空间(注意这时引用计数的变化，旧的空间的引用计数减一，新分配的空间引用计数加一)。

写时拷贝的实用：实现一个string类

class String
{
public:
 String(const char *str = "")
 :_str(new char[strlen(str) + 1 + 4])
 {
 cout << "Sring()" << endl;
 _str += 4;    //前4个字节用来存放引用计数
 GetCount() = 1;   //引用计数的初始值设置成1
 strcpy(_str, str);
 } 

 String(String& s)
 :_str(s._str)
 {
 cout << "Sring(String&)" << endl;
 GetCount()++;
 } 

 String& operator=(String& s)
 {
 cout << "Sring& operator=" << endl; 

 if (this != &s)
 {
  Release();
  _str = s._str;
  GetCount()++;
 }
 return *this;
 } 

 ~String()
 {
 cout << "~Sring()" << endl;
 Release();
 }
public:
 char& operator[](size_t index)
 {
 if (GetCount() == 1)   //如果计数器为1，则直接返回
 {
  return _str[index];
 }
 GetCount()--;
 char *tmp = _str;
 _str = new char[strlen(tmp) + 1 + 4];
 _str += 4;
 strcpy(_str, tmp);
 GetCount() = 1;
 return _str[index];
 }
private:
 int& GetCount()
 {
 return *(int *)(_str - 4);
 }
 void Release()
 {
 if (--GetCount() == 0)
 {
  cout << "释放" << endl;
  delete[](_str - 4); //注意释放的时候还有 存放引用计数的4个字节
  _str = NULL;
 }
 }
private:
 char *_str;
};

这里有一个问题呢~，C++标准的确就是这样的，C++标准认为，当你通过迭代器或[]获取到string的内部地址的时候，string并不知道你将是要读还是要写。这是它无法确定，为此，当你获取到内部引用后，为了避免不能捕获你的写操作，它在此时废止了写时才拷贝技术。

这样看来我们在使用写时拷贝的时候，一定要注意，如果你不需要对string的内部进行修改，那你就千万不要使用通过[]操作符和迭代器去获取字符串的内部地址引用，如果你一定要这么做，那么你就必须要付出代价。当然，string还提供了一些使迭代器和引用失效的方法。比如说push_back，等， 你在使用[]之后再使用迭代器之后，引用就有可能失效了。

总结

以上就是这篇文章的全部内容了，希望本文的内容对大家的学习或者工作能带来一定的帮助，如果有疑问大家可以留言交流，谢谢大家对我们的支持。

赞 (0)

相关推荐

  • C++浅拷贝与深拷贝及引用计数分析

    C++浅拷贝与深拷贝及引用计数分析 在C++开发中,经常遇到的一个问题就是与指针相关的内存管理问题,稍有不慎,就会造成内存泄露.内存破坏等严重的问题.不像Java一样,没有指针这个概念,所以也就不必担心与指针相关的一系列问题,但C++不同,从C语言沿袭下来的指针是其一大特点,我们常常要使用new/delete来动态管理内存,那么问题来了,特别是伴随着C++的继承机制,如野指针.无效指针使用.内存泄露.double free.堆碎片等等,这些问题就像地雷一样,一不小心就会踩那么几颗. 先来谈一下C

  • 浅谈C++的浅拷贝出现的错误

    之前看一些资料提到浅拷贝的问题,即在复制对象时,只是对对象中的数据成员进行简单的赋值,默认拷贝构造函数执行的也是浅拷贝.如果对象中存在动态成员,如指针,那么仅仅做浅拷贝是不够的,并且容易引发错误,最经典的例子: #include <iostream> #include <stdio.h> using namespace std; class A{ public: A(){m_p = new int(10);}; ~A(){cout << "destructio

  • c++中深浅拷贝以及写时拷贝的实现示例代码

    c++中深浅拷贝以及写时拷贝的实现示例代码

    本文主要给大家介绍了关于c++中深浅拷贝及写时拷贝实现的相关内容,分享出来供大家参考学习,下面话不多说,来一起看看详细的介绍: 一:浅拷贝&深拷贝 浅拷贝:在拷贝构造的时候,直接将原内容的地址交给要拷贝的类,两个类共同指向一片空间.但是存在很大的缺陷:①一旦对s2进行操作,s1的内容也会改变:②析构时先析构s2,再析构s1,但是由于s1,s2指向同一片空间,会导致一片空间的二次析构导致出错. 深拷贝:通过开辟和源空间大小相同的空间并将内容拷贝下来再进行操作.不论是否对s2进行操作,都会拷贝一片相

  • 深入C++中构造函数、拷贝构造函数、赋值操作符、析构函数的调用过程总结

    1 . 用同一个类的源对象构造一个目标对象时,会调用拷贝构造函数来构造目标对象,如果没有定义拷贝构造函数,将调用类的默认拷贝函数来构造目标对象.2 . 当一个函数的返回值为一个类的对象时,如果在调用函数中,没有定义一个对象来接收这个返回对象值,会用返回一个临时对象保存返回对象的值.在被调用函数结束时,这个临时对象被销毁.而当调用函数中有一个接受对象时,就将返回对象赋值给接收对象,这个返回对象在调用函数结束时调用析构函数.3. 当类有一个带有一个参数的构造函数时,可以用这个参数同类型的数据初始化这

  • C++拷贝构造函数(深拷贝与浅拷贝)详解

    对于普通类型的对象来说,它们之间的复制是很简单的,例如:int a=88;int b=a; 而类对象与普通对象不同,类对象内部结构一般较为复杂,存在各种成员变量.下面看一个类对象拷贝的简单例子. 复制代码 代码如下: #include <iostream>using namespace std; class CExample {private:    int a;public:    CExample(int b)    { a=b;}    void Show ()    {       

  • 深入C++拷贝构造函数的总结详解

    拷贝构造函数是C++最基础的概念之一,大家自认为对拷贝构造函数了解么?请大家先回答一下三个问题:1. 以下函数哪个是拷贝构造函数,为什么?X::X(const X&);   X::X(X);   X::X(X&, int a=1);   X::X(X&, int a=1, b=2);  2. 一个类中可以存在多于一个的拷贝构造函数吗?3. 写出以下程序段的输出结果, 并说明为什么? 如果你都能回答无误的话,那么你已经对拷贝构造函数有了相当的了解. #include <iost

  • 深入理解C/C++中的写时拷贝

    深入理解C/C++中的写时拷贝

    写时拷贝 何为写时拷贝? 前面我说过深拷贝浅拷贝,今天我们来探究一下写时拷贝.深拷贝是补充了浅拷贝的不足,写时拷贝其实也就是补充一点深拷贝的不足.其实写时拷贝的意思就是: 当你读取到这个空间的时候,并不会开辟出一个一模一样的空间出来给你,当你真正需要拷贝的时候,那么他就会开辟出空间给你.也就是拖延版的深拷贝. 写时拷贝技术是通过"引用计数"实现的,在分配空间的时候多分配4个字节,用来记录有多少个指针指向块空间,当有新的指针指向这块空间时,引用计数加一,当要释放这块空间时,引用计数减一(

  • 详谈Linux写时拷贝技术(copy-on-write)必看篇

    详谈Linux写时拷贝技术(copy-on-write)必看篇

    COW技术初窥 在linux程序中,fork()会产生一个和父进程完全相同的子进程,但子进程在此后多会exec系统调用,出于效率考虑,linux中引入了"写时复制"技术,也就是只有进程空间的各段的内容要发生变化时,才将父进程的内容复制一份给子进程. 那么子进程的物理空间没有代码,怎么去取指令执行exec系统调用呢?? 在fork之后exec之前两个进程用的是相同的物理空间(内存区),子进程的代码段.数据段.堆栈都是指向父进程的物理空间,也就是说,两者的虚拟空间不同,其对应的物理空间是一

  • C++写时拷贝实现原理及实例解析

    一.什么是写时拷贝 写入时复制是一种计算机程序设计领域的优化策略.其核心思想是,如果有多个调用者同时请求相同资源(如内存或磁盘上的数据存储),他们会共同获取相同的指针指向相同的资源,直到某个调用者试图修改资源的内容时,系统才会真正复制一份专用副本(private copy)给该调用者,而其他调用者所见到的最初的资源仍然保持不变. 这个过程对其他的调用者是透明的(transparently). 此作法的主要优点是如果调用者没有修改该资源,就不会有副本被建立,因此多个调用者只是读取操作是可以共享同一

  • C++的深浅拷贝和写时拷贝你了解吗

    C++的深浅拷贝和写时拷贝你了解吗

    目录 1.浅拷贝 2.深拷贝 3.引用计数+写时拷贝 总结 1.浅拷贝 浅拷贝:对于有申请空间的对象的类来说,是按照字节序依次拷贝过去的,并没有另外申请一块空间.因此,在调用析构函数的时候会造成同一块空间释放两次的情况,从而使程序崩溃. 如下实例: class string { public: string(const char* str) { //构造string类对象时,如果传递nullptr指针 //认为程序非法,此处断言下 assert(str); _str = new char[str

  • String类的写时拷贝实例

    实例如下: #include<iostream> using namespace std; class String; ostream& operator<<(ostream &out, const String&s); //引用计数器类 class String_rep { friend class String; friend ostream& operator<<(ostream &out, const String&

  • C++深浅拷贝和写时拷贝图文详解

    C++深浅拷贝和写时拷贝图文详解

    前言 之前我们在浅谈6个成员函数中有提到深浅拷贝的问题,现在再回首掏一把. 一.深浅拷贝哪家强? 先给出代码理一理 #define _CRT_SECURE_NO_WARNINGS 1 #include <iostream> #include<assert.h> using namespace std; class String { friend ostream& operator<<(ostream &out, const String &s);

  • PHP中copy on write写时复制机制介绍

    什么是写时复制(Copy On Write)? 答:在复制一个对象的时候并不是真正的把原先的对象复制到内存的另外一个位置上,而是在新对象的内存映射表中设置一个指针,指向源对象的位置,并把那块内存的Copy-On-Write位设置为1.这样,在对新的对象执行读操作的时候,内存数据不发生任何变动,直接执行读操作:而在对新的对象执行写操作时,将真正的对象复制到新的内存地址中,并修改新对象的内存映射表指向这个新的位置,并在新的内存位置上执行写操作. 这个技术需要跟虚拟内存和分页同时使用,好处就是在执行复

  • PHP 之 写时复制介绍（Copy On Write）

    PHP 之 写时复制介绍（Copy On Write）

    在开始之前,我们可以先看一段简单的代码: 复制代码 代码如下: <?php   //例一     $foo = 1;     $bar = $foo;     echo $foo + $bar; ?> 执行这段代码,会打印出数字2.从内存的角度来分析一下这段代码"可能"是这样执行的:分配一块内存给foo变量,里面存储一个1: 再分配一块内存给bar变量,也存一个1,最后计算出结果输出.事实上,我们发现foo和bar变量因为值相同,完全可以使用同一块内存,这样,内存的使用就节

  • 浅谈js中调用函数时加不加括号的问题

    其实总结起来如下: 函数只要是要调用它进行执行的,都必须加括号.此时,函数()实际上等于函数的返回值.当然,有些没有返回值,但已经执行了函数体内的行为,这个是根本,就是说,只要加括号的,就代表将会执行函数体代码. 不加括号的,都是把函数名称作为函数的指针,用于传参,此时不是得到函数的结果,因为不会运行函数体代码.它只是传递了函数体所在的地址位置,在需要的时候好找到函数体去执行. 所以一般时候我们都是采用的是无括号的原因.这也是由于括号的二义性,因为括号是"函数调用运算符",相当于在执行

随机推荐