String浅拷贝、引用计数和深拷贝

最新推荐文章于 2025-06-20 10:29:10 发布

原创最新推荐文章于 2025-06-20 10:29:10 发布 · 233 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#浅拷贝 #引用计数 #深拷贝

linux 同时被 2 个专栏收录

10 篇文章

订阅专栏

C++

1 篇文章

订阅专栏

本文详细介绍了浅拷贝、引用计数及深拷贝三种对象复制方式，通过C++代码实例展示了每种方式的特点与应用场景。浅拷贝存在内存多次释放的问题，引用计数能有效解决此问题，而深拷贝则确保每个对象拥有独立内存，但可能消耗更多资源。

1. 浅拷贝

浅拷贝，是指原对象与拷贝对象共用一份实体，仅仅是对象名字不同而已（类似引用，即对原对象起别名），其中任何一个对象改变都会导致其他的对象也跟着它变。

#include <stdio.h>
#include <string.h>
#include <unistd.h>

//g++ -o StringSimple StringSimple.cpp

class String
{
public:
	String(const char* pStr = "")//构造函数
		:_pStr(new char[strlen(pStr)+1])
	{
		if(0 == *pStr)//字符串为空
		{
			*_pStr = '\0';
		}
		else//字符串不为空
		{
			strcpy(_pStr,pStr);
		}
	}
	String(const String& s)//拷贝构造函数
	{
		_pStr = s._pStr;
	}
	String& operator=(String& s)//赋值运算符重载
	{
		if(_pStr != s._pStr)//判断是不是自己给自己赋值
		{
			_pStr = s._pStr;
		}
		return *this;
	}
	~String()//析构函数
	{
		if(NULL == _pStr)
		{
			return;
		}
		else
		{
			delete []_pStr;
			_pStr = NULL;
		}
	}
  char* getStrPoint() {
      return _pStr;
    }
private:
	char* _pStr;

};


int main()
{
    String str1("abcdeaaaaa");
    String str2(str1);
    String str3;
    str3 = str1;

    //三个地址是一样的
    printf(" str1: %lx\n", (long)str1.getStrPoint());
    printf(" str2: %lx\n", (long)str2.getStrPoint());
    printf(" str3: %lx\n", (long)str3.getStrPoint());


    sleep(5);
    return 0;
}

从上面的日志可以看出：内存被多次释放。可以考虑通过引用计数的方式避免多次释放，只有计数器的值为0时，才可能真正释放内存。

2. 引用计数

通过引入计数器cnt，来解决浅拷贝多次释放同一块内存的问题。

#include <stdio.h>
#include <string.h>



class String
{

 public:
  //构造函数
  String(const char* pStr = "")
    :_pStr(new char[strlen(pStr) + 1])
    ,_cnt(new int(0))
    {
      if (0 == *pStr) {
        *_pStr = '\0';
      }
      else //字符串 不为空
      {
        strcpy(_pStr, pStr);
      }
      (*_cnt)++;
      printf("==构造函数==\n");
    }

    String(const String& s) //拷贝构造函数
    {
      _pStr = s._pStr;
      _cnt = s._cnt;
      (*_cnt)++;
      printf("==拷贝构造函数==\n");
    }

    ~String() //析构函数
    {
      if(NULL == _pStr)
      {
        return ;
      }
      else
      {
        if ((--(*_cnt)) == 0)
        {
          delete _cnt;
          delete []_pStr;
          _cnt = NULL;
          _pStr = NULL;
        }
      }
      printf("==析构函数==\n");
    }

    String& operator=(const String& s) //赋值运算符
    {
      //先释放旧数据
      if (NULL != _pStr)
      {
        if ((--(*_cnt)) == 0)
        {
          delete _cnt;
          delete []_pStr;
          _cnt = NULL;
          _pStr = NULL;
          printf("==赋值函数,释放旧内存==\n");
        }
      }
      _pStr = s._pStr;
      _cnt = s._cnt;
      (*_cnt)++;

      printf("==赋值函数==\n");
      return *this;
    }

 private:
  char* _pStr;
  int* _cnt;
};

int main()
{
    String str1("abcdeabbbb");
    String str2(str1);
    String str3;
    str3 = str1;

    return 0;
}

3. 深拷贝

每次拷贝都是重新申请一块内存，再把内容拷贝过去，当数据比较大时，这种方式是比较耗内存的，而且也会影响性能。

#include <stdio.h>
#include <string.h>
#include <unistd.h>


class String
{
public:
	String(const char* pStr = "")//构造函数
		:_pStr(new char[strlen(pStr)+1])
	{
		if(0 == *pStr)//字符串为空
		{
			*_pStr = '\0';
		}
		else//字符串不为空
		{
			strcpy(_pStr,pStr);
		}
	}
	String(const String& s)//拷贝构造函数
    :_pStr(new char[strlen(s._pStr)+1])
	{
    strcpy(_pStr,s._pStr);
	}

	String& operator=(const String& s)//赋值运算符重载
	{
		if(_pStr != s._pStr)//判断是不是自己给自己赋值
		{
      if (NULL != _pStr)
      {
        delete []_pStr;//释放当前对象
      }
      char* temp  = new char[strlen(s._pStr)+1];//先开辟一段新空间
			strcpy(temp,s._pStr);//将原对象的值赋给新空间
			_pStr = temp;//将当前对象指向新开辟的空间
		}
		return *this;
	}
	~String()//析构函数
	{
		if(NULL == _pStr)
		{
			return;
		}
		else
		{
			delete []_pStr;
			_pStr = NULL;
		}
	}
  char* getStrPoint() {
      return _pStr;
    }
private:
	char* _pStr;

};


int main()
{
    String str1("abcdecccc");
    String str2(str1);
    String str3;
    str3 = str1;

    //三个地址是不一样的
    printf(" str1: %lx\n", (long)str1.getStrPoint());
    printf(" str2: %lx\n", (long)str2.getStrPoint());
    printf(" str3: %lx\n", (long)str3.getStrPoint());


    return 0;
}