c++入门学习④——对象的初始化和清理

使用构造函数和析构函数

构造函数语法:

类名(){}
1.构造函数，没有返回值也不写void
2.函数名称与类名相同
3.构造函数可以有参数，因此可以发生重载
4.程序在调用对象时候会自动调用构造，无须手动调用,而且只会调用一次

自己不写，程序会自动帮你实现，不过函数里面的代码是空的，要是自己写，程序运行你自己写的构造函数

析构函数语法:

~类名(){}
1.析构函数，没有返回值也不写void
2.函数名称与类名相同,在名称前加上符号
3.析构函数不可以有参数，因此不可以发生重载
4.程序在对象销毁前会自动调用析构，无须手动调用,而且只会调用一次

自己不写，程序会自动帮你实现，不过函数里面的代码是空的，要是自己写，程序运行你自己写的析构函数

代码：
#include<iostream>
#include<string>
using namespace std;
class person{
     public:
         //创造构造函数
         person() {
             cout << "构造函数" << endl;
         }
         ~person() {
             cout << "析构函数调用" << endl;
         }
};
void test1() {
       person a;
}//局部变量，在栈区上创建，test执行完毕后，释放对象，会自动实现析构函数，不过是空的
//当自己创建了一个，那么就执行自己创建的析构函数

int main()
{
    test1();
    system("pause");
    return 0;
}

构造函数的分类：

两种分类方式：

按照参数分类：有参数和无参数（默认情况下为无参）

按照类型分类：普通和拷贝

拷贝：copy、复制，

例如：person（const person &a){name=a.name;};把其他的属性拷贝到这个上面

拷贝方式创建，注意括号里写要copy的对象，并加上const，以引用的方式写入。

三种构造函数的具体表示：
#include<iostream>
#include<string>
using namespace std;
class person{
     public:
         //创造构造函数
         person() {
             cout << "默认构造函数" << endl;
         }
         person(int age) {
             cout << "有参构造函数" << endl;
             Age = age;
         }
         person(const person& p) {
             cout << "拷贝构造函数" << endl;
             Age = p.Age;
         }
         ~person() {
             cout << "析构函数调用" << endl;
         }
         int Age;
};

引用：c++引用-CSDN博客

三种调用方法：

括号法（默认构造函数调用）

person p1;调用无参构造函数，也是默认构造函数调用；

person p2(12);调用有参构造函数

person p3(p2);调用拷贝构造函数

注意事项：调用默认构造函数的时候不要加（），因为编译器会认为这个是一个函数声明，不会认为在创建对象

显示法

person p1;默认构造

person p2=person(12);有参构造

person p3=person(p2);拷贝构造

单独拿出来person(12),称为匿名对象，当前执行结束后，系统会立即回收掉匿名对象，马上析构掉

不单独看这个，匿名对象就有名字了，左边的就是它的名字

注意：不要利用拷贝构造函数初始化匿名对象。编译器会认为person(p3)==person p3;认为这是一个对象声明

隐式转换法

person p4=10;相当于写了person p4=person(10)有参构造

person p5=p4;拷贝构造

括号法最简单，这里推荐使用这个

拷贝调用函数的调用时机

1.使用一个已经常见完毕的对象来初始化一个新对象

#include<iostream>
using namespace std;
class person{
     public:
         //创造构造函数
         person() {
             cout << "默认构造函数" << endl;
         }
         person(int age) {
             Age = age;
             cout << "有参构造函数" << endl;
         }
         person(const person & a) {
             Age = a.Age;
             cout << "拷贝构造函数" << endl;
         }
         ~person() {
             cout << "析构函数调用" << endl;
         }
         int Age;
};
void test1() {
       person a;//局部变量，在栈区上创建，test执行完毕后，释放对象
}
//使用一个已经创建完毕的对象来初始化一个新的对象
void test2() {
    person p(20);//调用有参构造函数
    person p1(p);//调用拷贝构造函数
}

int main()
{
    //test1();
    test2();
    system("pause");
    return 0;
}

输出结果：

2.值传递的方式给函数参数传值。

#define  _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include<string>
using namespace std;
class person{
     public:
         //创造构造函数
         person() {
             cout << "默认构造函数" << endl;
         }
         person(int age) {
             Age = age;
             cout << "有参构造函数" << endl;
         }
         person(const person & a) {
             Age = a.Age;
             cout << "拷贝构造函数" << endl;
         }
         ~person() {
             cout << "析构函数调用" << endl;
         }
         int Age;
};
//值传递的方式给函数参数传值
void test(person p) 
{
}
void test3() {
    person p;//调用默认构造函数
    test(p);//调用拷贝构造函数，因为这里是以值传入，相当于拷贝一个副本传进去

}

int main()
{
    //test1();
    //test2();
    test3();
    return 0;
}

3.以值方式返回局部对象

示例：

#define  _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include<string>
using namespace std;
class person{
     public:
         //创造构造函数
         person() {
             cout << "默认构造函数" << endl;
         }
         person(int age) {
             Age = age;
             cout << "有参构造函数" << endl;
         }
         person(const person & a) {
             Age = a.Age;
             cout << "拷贝构造函数" << endl;
         }
         ~person() {
             cout << "析构函数调用" << endl;
         }
         int Age;
};

//以值返回局部对象
person test0() {
    person p;//局部对象在完成函数之后会被自动释放掉，但是现在以值方式返回，则在返回的时候会自动给创建一个新的对象
    cout << "p地址" << (int*) & p << endl;
    return p;//返回的是p拷贝的一个新的对象
}
void test4() {
     person a=test0();//这里的函数a没有调用析构函数和构造函数
     cout << "a地址" << (int*)&a << endl;
}
int main()
{
    //test1();
    //test2();
    //test3();
    test4();
    system("pause");
    return 0;
}

构造函数调用时机：

默认情况添加的函数：

⭐注意：拷贝构造函数默认情况下只写值传递语句，不会出现输出语句

构造函数调用规则如下:
若用户定义有参构造函数，c++不再提供默认无参构造，但是会提供默认拷贝构造函数

，当仅定义有参构造函数时不要进行默认无参构造，会发生错误显示没有默认无参构造函数。

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

只定义拷贝构造函数时如果使用其他的构造函数，则会发生错误

深拷贝浅拷贝：

一般浅拷贝是逐个字节依次复制过去，而默认情况下系统创建拷贝构造函数是浅拷贝

有可能的错误：

一般使用不会出错，但是如果数据是程序员开发在堆区，就会发生释放重复的错误

错误原因：

因为浅拷贝使两个对象里的属性指向同一块空间，当释放一个对象中的属性之后，再去释放另一个也在堆区的数据，由于她们指向相同，所指向的空间已经被释放，但是系统不知道因此会发生错误

解决方案：

改进方法就是进行深拷贝，程序员自己创建一个函数来达到深拷贝的效果，深拷贝是在拷贝构造函数内进行自己再开辟一片空间，只复制要拷贝对象属性的内容而非空间地址。

深拷贝和浅拷贝案例：

#include<iostream>

using namespace std;
class person{
     public:
         //创造构造函数
         person() {
             cout << "默认构造函数" << endl;
         }
         person(int age,int height) {
             Age = age;
             high = new int(height);
             cout << "有参构造函数" << endl;
         }
         person(const person & a) {
             Age = a.Age;
             cout << "person的拷贝构造函数" << endl;
             high=new int(*a.high);
         }
         ~person() {
             //析构代码，将堆区开辟数据做释放操作
             if (high != NULL) {
                 delete high;
                 high = NULL;
             }//加上这个代码后运行，发现程序崩溃了？
             cout << "析构函数调用" << endl;
         }
         int Age;
         int* high;//身高，使用指针，把这个参数存放在堆区
         //堆区的数据，由程序员手动开辟，也由程序员手动释放，销毁前释放，在析构之前释放
};
void test1() {
    person p1(18,160);
    cout << "p1年龄：" << p1.Age<<"p1身高为："<<*p1.high << endl;
    person p2(p1);//编译器创建了一个拷贝函数，进行了一个浅拷贝的操作，简单的赋值操作，逐字节拷贝
    cout << "p2年龄：" << p2.Age<< "p2身高为：" <<*p2.high << endl;
    //栈区先进后出，所以p2先被释放，p2先执行析构函数，p2释放过了指针所指的内存，则再次用p1释放时发生错误
    //解决：浅拷贝用深拷贝改进，不是逐个字节拷贝了，是重新开辟一个空间，两个空间就不会存在重复释放了
    //自己写拷贝构造函数
}
int main()
{
    test1();
    system("pause");
    return 0;
}

初始化列表

简介：
初始化类中属性：1创建构造函数2.初始化列表
构造函数（）：属性1（值1），属性2（值2）

基本初始化列表案例：

#include<iostream>
using namespace std; 
         //初始化列表
         //初始化类中属性：1创建构造函数2.初始化列表
         // 构造函数（）：属性1（值1），属性2（值2）
class person{
     public:
         //初始化列表给类属性赋初值；
         person() :Age(10),b(20)
         {

             
         }
         int Age;
         int b;
};
void test1() {
    person p1;
    cout << p1.Age <<"\t" << p1.b << endl;
}
int main()
{
    test1();
    system("pause");
    return 0;
}

灵活定义初始化的数字时的初始化列表案例：

#include<iostream>

using namespace std; 
         //初始化列表
         //初始化类中属性：1创建构造函数2.初始化列表
         // 构造函数（）：属性1（值1），属性2（值2）
class person{
     public:
         //初始化列表给类属性赋初值；
         person(int a,int n) :Age(a),b(n)//注意这个冒号的位置，别写错了
         {

             
         }
         int Age;
         int b;
};
void test1() {
    person p1(12,22);//12先传给了p1中的int a，然后传入到Age里的a,这样Age就被这个数字赋值了，被初始化了。
    cout << p1.Age <<"\t" << p1.b << endl;
}
int main()
{
    test1();
    system("pause");
    return 0;
}

类对象作为类成员

类定义的对象称为另一个类里的成员，则称为类成员

构造顺序和析构顺序相反

构造时，先构造类成员的类，再构造类成员所在的类

而析构顺序则正相反。

#include<iostream>
#include<string>
using namespace std; 
//类对象成为另一个对象的成员，称为类成员
//先有的什么？👉先构造其他的类的对象，再构造这个类
//那么析构的顺序呢？和构造的顺序是相反的。
class A {
public:
    // 可以用Phone a_phone=pname👉隐式转换法来初始化变量
    A(string Name, string pname):name(Name),a_phone(pname)
    {
        cout << "A的构造函数" << endl;
    }
    //姓名
    string name;
    //手机
    Phone a_phone;//类成员
};
//手机类
class Phone{
public:
    Phone(string pname) {//Phone  的构造函数
        Pname = pname;
        cout << "Phone的构造函数" << endl;
    }
    //手机品牌名
    string Pname;
};
void test1() {
    A p("黑菜钟","华为");
    cout << "名字:"<<p.name<< endl;
    cout <<"手机型号:"<< p.a_phone  << endl;
    
}
int main()
{
    test1();
    system("pause");
    return 0;
}

静态成员

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

分为：静态成员变量和静态成员函数

静态成员变量要求：所有对象共享同一份数据，编译阶段分配内存，类内声明，类外初始化

静态成员函数要求：

静态成员变量：

静态成员变量示例：

当静态成员变量像平常一样定义类对象并且输出所对应的值的时候，程序会怎么样？

结果：发生错误，无法解析的外部命令👉这是因为静态成员变量要类外进行初始化操作，这个程序显然没做

如何在类外初始化呢？👉int person::m = 100;（这里的person是类名，m是类内静态变量）

静态成员变量访问案例：

⭐静态成员变量不属于某个对象，所有对象共享同一份

访问方式：

1.通过对象访问
person p;
cout<<p.m_A<<endl;
2.通过类名访问
cout << person::m_A << endl;

#include<iostream>
#include<string>
using namespace std; 
//静态成员变量
//所有对象共享同一份数据
// 编译阶段分配内存
// 类内声明，类外初始化
class person {
public:
    static int m_A;

};
int person::m_A = 10;
void test1() {
    person p;
    cout << p.m_A << endl;//10
    person p2;
    p2.m_A = 20;
    cout << p.m_A << endl;//结果为20，因为所有对象共享数据，一改全改
    //静态成员变量不属于某个对象，所有对象共享同一份
}
void test2() {
    //访问方式1.通过对象访问
    person p;
    cout<<p.m_A<<endl;//20
    //访问方式2.通过类名访问
    cout << person::m_A << endl;//用::来借助访问类对象
}

int main()
{
    test1();
    test2();
    system("pause");
    return 0;
}

注意：静态成员变量只能在公共权限内定义，在私有权限内定义不出错，但是不能共享数据。类外访问不到私有静态变量。

静态成员函数

特点：所有对象共享同一个函数，静态成员函数只能访问静态成员变量

静态成员函数创建调用基本示例

#include<iostream>
#include<string>
using namespace std; 
//静态成员函数
//所有对象共享同一个函数
// 静态成员函数只能访问静态成员变量

class person {
public:
    static void func() {
        cout << "static void func调用" << endl;
    }
};

void test1() 
{
    //访问方式和静态成员变量的访问方式相同
    //1.通过对象
    person p;
    p.func();
    //2.通过类名
    person::func();
}

int main()
{
    test1();
    system("pause");
    return 0;
}

如果静态成员函数访问非静态成员变量会出现👉这样的结果

why?

数据属于特定的，而函数体无法区分是哪个对象的，会出错

而静态成员变量是共享的，所有类的对象都用一份，函数体不需要知道这是哪个类对象对应的

⭐注意：类外还是不可以访问私有的静态成员函数

结语：

希望这篇有关c++对象初始化和清理的博客对大家有所帮助，欢迎大佬们留言o(*￣▽￣*)ブ

一起学习进步！！！