C++奇迹之旅：深入思考拷贝构造函数

文章目录

• 📝拷贝构造函数
• 🌠 概念
• • 🌉特征
  • 🌠浅拷贝(值拷贝)
  • • 🌉深拷贝
    • 🌠拷贝构造函数典型调用场景
    • 🌠应用时效率的思考
    • 🚩总结

      ---

      📝拷贝构造函数

      🌠 概念

      在现实生活中，可能存在一个与你一样的自己，我们称其为双胞胎。

      那在创建对象时，可否创建一个与已存在对象一某一样的新对象呢？

      拷贝构造函数：只有单个形参，该形参是对本类类型对象的引用(一般常用const修饰)，在用已存在的类类型对象创建新对象时由编译器自动调用。

      还是我们熟悉的日期函数：

      class Date
      {
      public:
      	Date(int year, int month, int day)
      	{
      		_year = year;
      		_month = month;
      		_day = day;
      	}
      	void Print()
      	{
      		cout 
      	Date d1(2024, 4, 18);
      	d1.Print();
      	return 0;
      }
      
      	Date d2(2024, 4, 9);
      	Date d3(d2);
      	
      	d2.Print();
      	d3.Print();
      	
      	return 0;
      }
      
      public:
      	Date(int year, int month, int day)
      	{
      		_year = year;
      		_month = month;
      		_day = day;
      	}
      	//ClassName(const ClassName& other);
      	Date(const Date& d)
      	{	//this==d2
      		//this-_year=d1.year;
      		_year = d._year;
      		_month = d._month;
      		_day = d._day;
      	}
      	void Print()
      	{
      		cout 
      	Date d1(2024, 4, 18);
      	Date d2(d1);
      	
      	d1.Print();
      	d2.Print();
      	
      	return 0;
      }
      
      public:
          // 默认构造函数
          Date()
          {
              _year = 1;
              _month = 1;
              _day = 1;
          }
          // 带参数的构造函数
          Date(int year, int month, int day)
          {
              _year = year;
              _month = month;
              _day = day;
          }
          // 拷贝构造函数
          Date(const Date& other)
          {
              _year = other._year;
              _month = other._month;
              _day = other._day;
          }
          void Print()
          {
              cout 
          // 使用默认构造函数创建对象
          Date d1;
          d1.Print(); // 输出: 1-1-1
          // 使用带参数的构造函数创建对象
          Date d2(2023, 4, 18);
          d2.Print(); // 输出: 2023-4-18
          // 使用拷贝构造函数创建对象
          Date d3(d2);
          d3.Print(); // 输出: 2023-4-18
          return 0;
      }
      
      public:
      	Date(int year, int month, int day)
      	{
      		_year = year;
      		_month = month;
      		_day = day;
      	}
      	//ClassName(const ClassName& other);
      	Date(const Date& d)
      	{	//this==d2
      		//this-_year=d1.year;
      		_year = d._year;
      		_month = d._month;
      		_day = d._day;
      	}
      	void Print()
      	{
      		cout 
      	d.Print();
      }
      void func2(Date& d)
      {
      	d.Print();
      }
      int main()
      {
      	Date d1(2024, 4, 18);
      	func1(d1);
      	func1(d1);
      	return 0;
      }
      
      public:
      	Time()
      	{
      		_hour = 1;
      		_minute = 1;
      		_second = 1;
      	}
      	Time(const Time& t)
      	{
      		_hour = t._hour;
      		_minute = t._minute;
      		_second = t._second;
      		cout 
      private:
      	// 基本类型(内置类型)
      	int _year = 2024;
      	int _month = 4;
      	int _day = 18;
      	// 自定义类型
      	Time _t;
      };
      int main()
      {
      	Date d1;
      	// 用已经存在的d1拷贝构造d2，此处会调用Date类的拷贝构造函数
      	// 但Date类并没有显式定义拷贝构造函数，则编译器会给Date类生成一个默认的拷贝构造函数
      	Date d2(d1);
      	return 0;
      }
      
      public:
      	Time(const Time& t)
      	{
      		_hour = t._hour;
      		_minute = t._minute;
      		_second = t._second;
      		cout 
      private:
      	// 基本类型(内置类型)
      	int _year = 2024;
      	int _month = 4;
      	int _day = 18;
      	// 自定义类型
      	Time _t;
      };
      int main()
      {
      	Date d1;
      	// 用已经存在的d1拷贝构造d2，此处会调用Date类的拷贝构造函数
      	// 但Date类并没有显式定义拷贝构造函数，则编译器会给Date类生成一个默认的拷贝构造函数
      	Date d2(d1);
      	return 0;
      }
      
      public:
      	Stack(size_t capacity = 10)
      	{
      		_array = (DataType*)malloc(capacity * sizeof(DataType));
      		if (nullptr == _array)
      		{
      			perror("malloc申请空间失败");
      			return;
      		}
      		_size = 0;
      		_capacity = capacity;
      	}
      	void Push(const DataType& data)
      	{
      		// CheckCapacity();
      		_array[_size] = data;
      		_size++;
      	}
      	~Stack()
      	{
      		if (_array)
      		{
      			free(_array);
      			_array = nullptr;
      			_capacity = 0;
      			_size = 0;
      		}
      	}
      private:
      	DataType* _array;
      	size_t _size;
      	size_t _capacity;
      };
      int main()
      {
      	Stack s1;
      	s1.Push(1);
      	s1.Push(2);
      	s1.Push(3);
      	s1.Push(4);
      	Stack s2(s1);
      	return 0;
      }
      
      public:
      	Stack(size_t capacity = 3)
      	{
      		cout 
      			perror("malloc申请空间失败!!!");
      			return;
      		}
      		_capacity = capacity;
      		_size = 0;
      	}
      	// Stack st2 = st1;
      	Stack(const Stack& st)
      	{
      		_array = (DataType*)malloc(sizeof(DataType) * st._capacity);
      		if (NULL == _array)
      		{
      			perror("malloc申请空间失败!!!");
      			return;
      		}
      		memcpy(_array, st._array, sizeof(DataType) * st._size);
      		_size = st._size;
      		_capacity = st._capacity;
      	}
      	void Push(DataType data)
      	{
      		// CheckCapacity();
      		_array[_size] = data;
      		_size++;
      	}
      	bool  Empty()
      	{
      		return _size == 0;
      	}
      	DataType Top()
      	{
      		return _array[_size - 1];
      	}
      	
      	void Pop()
      	{
      		--_size;
      	}
      	// 其他方法...
      	~Stack()
      	{
      		cout 
      			free(_array);
      			_array = NULL;
      			_capacity = 0;
      			_size = 0;
      		}
      	}
      private:
      	DataType* _array;
      	int _capacity;
      	int _size;
      };
      int main()
      {
      	Stack st1;
      	st1.Push(1);
      	st1.Push(2);
      	// 拷贝构造
      	Stack st2(st1);
      	return 0;
      }
      
      private:
      	Stack _st1;
      	Stack _st2;
      	int _size = 0;
      };
      int main()
      {
      	MyQueue q1;
      	MyQueue q2(q1);
      	return 0;
      }
      
          obj.print();
      }
      MyClass obj("Hello");
      printObject(obj);  // 调用拷贝构造函数
      
          MyClass obj("Hello");
          return obj;  // 调用拷贝构造函数
      }
      MyClass newObj = createObject();
      
      public:
      	Date(int year, int minute, int day)
      	{
      		cout 
      		cout 
      		cout 
      	Date temp(d);
      	return temp;
      }
      int main()
      {
      	Date d1(2022, 1, 13);
      	Test(d1);
      	return 0;
      }