【C++学习笔记】之对象特性

对象的初始化和清理

​ C++中的面向对象来源于生活，每个对象也都会有初始设置以及对象销毁前的清理数据的设置。

​ – 一个对象或者变量没有初始状态，对其使用后果未知；

​ – 同样的使用完一个对象或变量，没有及时清理，也会造成—定的安全问题。

1、构造函数和析构函数

​ C++利用了构造函数和析构函数解决上述问题，这两个函数将会被编译器自动调用，完成对象初始化和清理工作。对象的初始化和清理工作是编译器强制要我们做的事情，因此如果我们不提供构造和析构，编译器会提供，但是编译器提供的构造函数和析构函数是空实现。

---

构造函数:

​ 主要作用在于创建对象时为对象的成员属性赋值，构造函数由编译器自动调用，无须手动调用。

​ 语法：类名( ){ }

	*  构造函数没有返回值，也不写void；
	*  函数名称与类名相同；
	*  构造函数**可以有参数**，因此**可以发生重载**；
	*  程序在调用对象时，会自动调用构造函数，无需手动调用，且只会调用一次；

---

析构函数:

​ 主要作用在于对象销毁前系统自动调用，执行一些清理工作。

​ 语法：~类名( ){ }

	* 析构函数没有返回值，也不写void；
	* 函数名称与类名相同，在名称前加上符号` ~`
	* 析构函数**不可以有参数**，因此**不可以发生重载**；
	* 程序在对象销毁前回自动调用析构函数，无需手动调用，且只会调用一次；

---

2、构造函数的分类及调用

（1）两种分类方式

​ 按照参数分为：有参构造和无参构造（默认构造）

​ 按照类型分为：普通构造和拷贝构造

（2）三种调用方式

​ 1.括号法

​

​ 2.显示法

​ 3.隐式转换法

（3）拷贝构造函数调用时机

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

			* 使用—个已经创建完毕的对象来初始化一个新对象；
			* 以值传递的方式给函数参数传值；
			* 以值方式返回局部对象；

（4）Code检验

#include 
#include 
using namespace std;

class Person_cl{
public:
    //构造函数
    Person_cl(){
        cout<<"Person构造函数的调用---无参构造(普通构造)" <<endl;
    }
 
 	Person_cl(string a,int b){
     	name = a;
     	age = b;
    	cout<<"Person构造函数的调用---有参构造(普通构造)" <<endl;
	}

	Person_cl(const Person_cl &p){
    	//将传入的身上的所有属性，拷贝到我身上
    	name = p.name;
    	age = p.age;
    	cout<<"Person构造函数的调用---拷贝构造" <<endl;
	}

	//析构函数
	~Person_cl(){
   	 	cout<<"Person析构函数的调用" <<endl;
	}

	string name;
	int age;
};


//构造函数的调用
void test01(){
    //括号法--------注意事项：调用默认构造函数时，不要加()，Person_cl p1(); 会被编译器认为是一个函数的声明；
    Person_cl p1;       //无参构造函数（默认构造函数）
//    Person_cl p2(10);   //有参构造函数
//    Person_cl p3(p2);   //拷贝构造函数
    //显示法
    Person_cl p2 = Person_cl("dabin",10);      //有参构造的显示法调用
    Person_cl p3 = Person_cl(p2);      //拷贝构造的显示法调用
    cout << "p2.name = " << p2.name <<endl;
    cout << "p2.age = " << p2.age <<endl;
    cout << "p3.name = " << p3.name <<endl;
    cout << "p3.age = " << p3.age <<endl;
/****************************************************************************************************************
    注意事项1：
    此处的 Person_cl(10) 和 Person_cl(p2) 单独拿出来，则为匿名对象；当放在等号右侧时，等号左侧就是匿名对象的名；
    匿名对象的特点：当前行执行结束后，系统会立即回收匿名对象，即立即调用析构函数；
    
    注意事项2：
	Person_cl(p3)；  ×
	不要利用拷贝构造函数初始化匿名对象，编译器会认为Person_cl(p3)等价于Person_cl p3;编译器会认为这是一个对象声明；
******************************************************************************************************************/
    //隐式法
    Person_cl p4 = {"Liming",20};      //相当于写了： Person_cl p4 = Person_cl(10);    有参构造
    Person_cl p5 = p4;      //相当于写了： Person_cl p4 = Person_cl(p4);    拷贝构造

    cout << "p4.name = " << p4.name <<endl;
    cout << "p4.age = " << p4.age <<endl;
    cout << "p5.name = " << p5.name <<endl;
    cout << "p5.age = " << p5.age <<endl;
}
//主函数
int main(void)
{
    //Person_cl person;
    test01();
    system("pause");
	return 0;
}
    

---

3、构造函数调用规则

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

  1 默认构造函数(无参，函数体为空)；
  2 默认析构函数(无参，函数体为空)；
  3 默认拷贝构造函数，对属性进行值拷贝；

• C++中构造函数默认规则：

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

  2 如果用户定义拷贝构造函数，C++不会再提供其他构造函数，此时需要手动创建其他构造函数才能正常创建对象；

• code验证

  #include 
  using namespace std;
  
  class Person{
  public:
  //    Person(){
  //        cout << "Person默认构造函数调用" <
  //    }
  
  //    Person(int age){
  //        cout << "Person有参构造函数调用" <
  //        m_age = age;
  //    }
  Person(const Person & p){
      cout << "Person拷贝构造函数调用" <<endl;
      m_age = p.m_age;
  }
  
  ~Person(){
      cout << "Person析构函数调用" <<endl;
  }
  
  int m_age;
  };
  
  //void test01(){
  //    Person p1;
  //    p1.m_age = 20;
  //
  //    Person p2(p1);
  //
  //    cout << "p2.m_age = " << p2.m_age <
  //}
  
  //void test02(){
  //    Person p1(20);
  //    Person p2(p1);
  //
  //    cout << "p2.m_age = " << p2.m_age <
  //}
  
  void test03(){
      Person p1;
      Person p2(p1);
  //
  //    cout << "p2.m_age = " << p2.m_age <
  }
  
  int main()
  {
     // test01();
      //test02();
      test03();
      system("pause");
  return 0;
  }
  

4、深拷贝与浅拷贝

​ 浅拷贝:简单的赋值拷贝操作，容易导致堆区的内存重复释放；

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

1 问题产生

​ 浅拷贝带来的问题：堆区的内存重复释放；

#include 
using namespace std;
class Person{
public:
    Person(){
        cout << "Person默认构造函数调用" <<endl;
    }
    Person(int age,int height){
    cout << "Person有参构造函数调用" <<endl;
    m_age = age;
    m_height = new int(height);
}
    ~Person(){
        //析构代码，将堆区开辟数据做释放操作；
        if(m_height != NULL)
        {
            delete m_height;
            m_height = NULL;
        }
        cout << "Person析构函数调用" <<endl;
 }

    int m_age;
    int *m_height;
};

void test01()
{
    Person p1(18,160);
    cout << "p1的年龄为：" << p1.m_age <<" 身高为："<< *p1.m_height<<endl;
    Person p2(p1);
    cout << "p2的年龄为：" <<p2.m_age<<" 身高为："<< *p1.m_height<<endl;
}
    
int main()
{
    test01();
    system("pause");
return 0;
}

​ 运行上述程序，会返回错误值，原因如下：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-RFeDkgMs-1639556588094)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20210908091309707.png)]

​ 由于class Person{}中未自定义拷贝构造函数，编译器则会提供默认的拷贝构造函数，此时执行浅拷贝操作，即只进行简单的赋值拷贝。
​ 在上述程序中，当运行完位于栈空间的test01()函数时，由于栈空间先入后出的属性，会使得p2先运行析构函数，此时，申请的0x11的堆空间被释放；当运行p1的析构函数时，发现此时仍然要释放0x11的堆空间，便导致堆空间的重复释放！

  Person(const Person & p){
  		cout << "Person拷贝构造函数调用" <<endl;
  		m_age = p.m_age;
      	m_height = p.m_height;
  }

---

2 解决方法

​ 自定义拷贝构造函数，在其内同样申请同样大小的堆空间，此时p2运行析构函数时，释放的就不是p1内部申请的堆空间了，即避免重复释放堆空间；

  Person(const Person & p){
  		cout << "Person拷贝构造函数调用" <<endl;
  		m_age = p.m_age;
   		m_height = new int(*p.m_height);
  }

---

5 初始化列表

​ **作用：**C++提供了初始化列表语法，用来初始化属性；

​ 语法：构造函数():属性1(值1),属性2(值2)...{}

/*****************************************************************************
初始化列表

		作用：C++提供了初始化列表语法，用来初始化属性；
	
		语法：构造函数():属性1(值1),属性2(值2)...{}；

*****************************************************************************/
#include 
using namespace std;


class Person{
public:
    //传统初始化操作
//    Person(int a,int b, int c){
//        cout << "Person有参构造函数调用" <
//        m_a = a;
//        m_b = b;
//        m_c = c;
//    }
    //初始化列表初始化属性
    Person(int a,int b,int c):m_a(a), m_b(b), m_c(c)
    {

    }
    
    int m_a;
    int m_b;
    int m_c;

};

void test01(){
   // Person p(10,20,30);
   Person p(30,20,10);
    cout << "m_a = " << p.m_a << endl;
    cout << "m_b = " << p.m_b << endl;
    cout << "m_c = " << p.m_c << endl;

}


int main()
{
    test01();

    system("pause");
    return 0;

}

6 类对象作为类成员

​ C++类中的成员可以是另一个类的对象，我们称该成员为对象成员；

​ B类中有对象A作为成员，A为对象成员；

​ 问题：那么当创建B对象时，A与B的构造和析构的顺序是谁先谁后?

​ 答案：当其他类对象作为本类成员，构造时先构造类对象，再构造自身；析构时先析构自身，再析构类对象；

/************************************
类对象作为类成员
************************************/
#include 
//#include 
using namespace std;

class phone_cl{
public:
    phone_cl(string pname){
        p_name = pname;
        cout << "phone_cl的有参构造函数" <<endl;
    }
    ~phone_cl(){
        cout << "phone_cl的析构函数" <<endl;
    }
    //手机品牌名称
    string p_name;

};

class Person_cl{
public:
    //phone_cl m_phone = phone;  隐式转换法
    Person_cl(string name, string phone):m_name(name),m_phone(phone)
    {
        cout << "Person_cl的有参构造函数" <<endl;
    }
    ~Person_cl(){
        cout << "Person_cl的析构函数" <<endl;
    }

    //姓名
    string m_name;
    //手机
    phone_cl m_phone;

};

void test01(){
    Person_cl p1("张三","iphone");
    cout <<p1.m_name <<"拿着"<<p1.m_phone.p_name<<endl;
}

int main(void)
{
    test01();
    system("pause");
    return 0;

}

运行结果：

7 静态成员

​ 静态成员：在成员变量和成员函数前加上关键字static，称为静态成员

​ 静态成员分为：

​ (1) 静态成员变量

​ (2) 静态成员函数
​

1 静态成员变量

1.1 特点

​ -所有对象共享同—份数据，因此两个对象子修改的是同一份数据；
​ -在编译阶段分配内存，因此可以通过类名直接访问；
​ -类内声明，类外初始化；
​ -静态成员变量同样具有访问权限；

1.2 code

/*****************************************************
                          静态成员
  静态成员就是在成员变量和成员函数前面加上关键字static

  *静态成员变量
     ①所有对象共享同一份数据，一个对象修改该变量后，另一个对象的该变量也随之修改；
     ②在编译阶段分配内存，即程序运行前就分配在了全局区；
     ③类内声明，类外初始化；

 *****************************************************/

#include 
using namespace std;

class Person_cl
{
public:
    //静态成员变量m_A,类内声明
    static int m_A;
    int m_B;
    //静态成员变量也是有访问权限的
private:
    static int m_C;
};

//类外初始化
int Person_cl::m_A = 100;
int Person_cl::m_C = 200;

void test01(void)
{
    Person_cl Liming;
    Liming.m_A = 20;
    Liming.m_B = 10;
    Person_cl Meng;
    Meng.m_A = 10;
    Meng.m_B = 20;cout <<"Liming.m_A = " << Liming.m_A <<endl;
    cout <<"Liming.m_B = " << Liming.m_B <<endl;

    cout <<"Meng.m_A = " << Meng.m_A <<endl;
    cout <<"Meng.m_B = " << Meng.m_B <<endl;
}

void test02(void)
{
    //静态成员变量 不属于某个对象上，所有对象都共享同一份数据；
    //因此静态成员变量有两种访问方式
    ///1、通过对象进行访问；
    Person_cl p;
    cout << p.m_A <<endl;
    ///2、通过类名进行访问；
    cout << Person_cl::m_A <<endl;      //由于编译阶段就分配了内存！
    //cout << Person_cl::m_B <
    //cout << Person_cl::m_C <
}

int main()
{
    //test01();
    test02();
}
    

2 静态成员函数

2.1 特点

		-所有对象共享同一个函数；
		-静态成员函数只能访问静态成员变量，不可以访问非静态成员变量；因为非静态成员变量作为特定对象的属性，静态成员函数无法区分是哪个对象的属性；
		-静态成员函数也是具有访问权限的；

2.2 code

/*****************************************************
                          静态成员
  静态成员就是在成员变量和成员函数前面加上关键字static

  *静态成员函数
     ①所有对象共享同一个函数；
     ②静态成员函数只能访问静态成员变量；

 *****************************************************/

 #include 
using namespace std;

class Person_cl{
public:
    //静态成员函数
    static void func()
    {
        m_A = 200;  //静态成员函数可以访问静态成员变量
        //m_B = 100;  //静态成员函数不可以访问非静态成员变量；因为非静态成员变量作为特定对象的属性，静态成员函数无法区分是哪个对象的属性。
        cout << "static void func 调用" << endl;
    }

    static int m_A;     //静态成员变量
    int m_B;            //非静态成员变量

    //静态成员函数也是具有访问权限的
private:
    //静态成员函数
    static void func2()
    {
        cout << "static void func2 调用" << endl;
    }

};

int Person_cl::m_A = 0;

void test01()
{
    //通过对象访问；
    Person_cl p;
    p.func();

    //通过类名访问；
    Person_cl::func();
    //Person_cl::func2();     //私有权限，无法类外调用私有静态成员函数
}

int main(){
    test01();

    system("pause");
    return 0;
}

​

​

​

​

​