c++自学日记 day6

1、拷贝构造函数调用时机

C++中拷贝构造函数调用时机通常有三种情况

• 使用一个已经创建完毕的对象来初始化一个新对象  （S s1 (s2)）;
• 值传递的方式给函数参数传值（将一个对象传给函数的形参，传的是一个副本）
• 以值方式返回局部对象 （return 时返回的也是一个拷贝，即副本）

• class Person {
  public:
  	Person() {
  		cout << "无参构造函数!" << endl;
  		mAge = 0;
  	}
  	Person(int age) {
  		cout << "有参构造函数!" << endl;
  		mAge = age;
  	}
  	Person(const Person& p) {
  		cout << "拷贝构造函数!" << endl;
  		mAge = p.mAge;
  	}
  	//析构函数在释放内存之前调用
  	~Person() {
  		cout << "析构函数!" << endl;
  	}
  public:
  	int mAge;
  };
  
  //1. 使用一个已经创建完毕的对象来初始化一个新对象
  void test01() {
  
  	Person man(100); //p对象已经创建完毕
  	Person newman(man); //调用拷贝构造函数
  	Person newman2 = man; //拷贝构造
  
  	//Person newman3;
  	//newman3 = man; //不是调用拷贝构造函数，赋值操作
  }
  
  //2. 值传递的方式给函数参数传值
  //相当于Person p1 = p;
  void doWork(Person p1) {}
  void test02() {
  	Person p; //无参构造函数
  	doWork(p);
  }
  
  //3. 以值方式返回局部对象
  Person doWork2()
  {
  	Person p1;
  	cout << (int *)&p1 << endl;
  	return p1;
  }
  
  void test03()
  {
  	Person p = doWork2();
  	cout << (int *)&p << endl;
  }
  
  
  int main() {
  
  	//test01();
  	//test02();
  	test03();
  
  	system("pause");
  
  	return 0;
  }
  

  2、

   构造函数调用规则

  默认情况下，c++编译器至少给一个类添加3个函数

  1．默认构造函数(无参，函数体为空)

  2．默认析构函数(无参，函数体为空)

  3．默认拷贝构造函数，对属性进行值拷贝

  构造函数调用规则如下：

• 如果用户定义有参构造函数，c++不在提供默认无参构造，但是会提供默认拷贝构造

• 如果用户定义拷贝构造函数，c++不会再提供其他构造函数

 （简单来说就是，用户定义了一个有参，系统就会认为你无参也写好了，不给你写了，但是拷贝不知道你还会不会，就给你写好了。）

（拷贝你也写好了，那你无参和有参肯定也写好了，系统就不给你写了）（自己理解的hh）

class Person {
public:
	//无参（默认）构造函数
	Person() {
		cout << "无参构造函数!" << endl;
	}
	//有参构造函数
	Person(int a) {
		age = a;
		cout << "有参构造函数!" << endl;
	}
	//拷贝构造函数
	Person(const Person& p) {
		age = p.age;
		cout << "拷贝构造函数!" << endl;
	}
	//析构函数
	~Person() {
		cout << "析构函数!" << endl;
	}
public:
	int age;
};

void test01()
{
	Person p1(18);
	//如果不写拷贝构造，编译器会自动添加拷贝构造，并且做浅拷贝操作
	Person p2(p1);

	cout << "p2的年龄为： " << p2.age << endl;
}

void test02()
{
	//如果用户提供有参构造，编译器不会提供默认构造，会提供拷贝构造
	Person p1; //此时如果用户自己没有提供默认构造，会出错
	Person p2(10); //用户提供的有参
	Person p3(p2); //此时如果用户没有提供拷贝构造，编译器会提供

	//如果用户提供拷贝构造，编译器不会提供其他构造函数
	Person p4; //此时如果用户自己没有提供默认构造，会出错
	Person p5(10); //此时如果用户自己没有提供有参，会出错
	Person p6(p5); //用户自己提供拷贝构造
}

int main() {

	test01();

	system("pause");

	return 0;
}

3、

深拷贝与浅拷贝

深浅拷贝是面试经典问题，也是常见的一个坑

浅拷贝：简单的赋值拷贝操作（指向的内存块都是一样的）（仅对于类中的对象而言，实测在main函数中的貌似不会，指向的内存块不同）

深拷贝：在堆区重新申请空间，进行拷贝操作

class Person {
public:
	//无参（默认）构造函数
	Person() {
		cout << "无参构造函数!" << endl;
	}
	//有参构造函数
	Person(int age ,int height) {
		
		cout << "有参构造函数!" << endl;

		m_age = age;
		m_height = new int(height);
		
	}
	//拷贝构造函数  
	Person(const Person& p) {
		cout << "拷贝构造函数!" << endl;
		//如果不利用深拷贝在堆区创建新内存，会导致浅拷贝带来的重复释放堆区问题
		m_age = p.m_age;
		m_height = new int(*p.m_height);
		
	}

	//析构函数
	~Person() {
		cout << "析构函数!" << endl;
		if (m_height != NULL)
		{
			delete m_height;
		}
	}
public:
	int m_age;
	int* m_height;
};

void test01()
{
	Person p1(18, 180);

	Person p2(p1);

	cout << "p1的年龄： " << p1.m_age << " 身高： " << *p1.m_height << endl;

	cout << "p2的年龄： " << p2.m_age << " 身高： " << *p2.m_height << endl;
}

int main() {

	test01();

	system("pause");

	return 0;
}

个人写的代码：

#include <iostream>
#include <string>
using namespace std;
class S {
public:
    int s_a;
    int* s_b;
    S() {
        cout << "无参构造函数" << endl;
    }
    S(int a,int b) {
        cout << "有参构造函数" << endl;
        s_a = a;
        s_b = new int (b);//在堆区创建内存
    }
    S(const S &s) {
        cout << "拷贝构造函数" << endl;
        s_a = s.s_a;
 /*       s_b = s.s_b;这是系统默认进行的语句，为浅拷贝，指向的堆区数据是一样的。*/
        s_b = new int (*s.s_b);//这就是深拷贝，在涉及到堆区的数据时要new一下对象，让其在堆区有一个新的数据，不至于出现重复删除的操作
    }
    ~S() {
        cout << "析构函数" << endl;
        if (s_b !=NULL) {
            delete s_b;
            s_b = NULL;
        }//删除对象属性
    }
};
int main() {
    S s1(10,20);
    S s2(s1);
    cout << int(s1.s_b) << endl;
    cout << int(&s1.s_a) << endl;
    cout << int(s2.s_b) << endl;
    cout << int(&s1.s_a) << endl;
    int a = 10;
    int b = a;
    cout << int(&a) << int(&b) << endl;
    return 0;
}