析构函数对象数组对象指针

ᰔᩚ. 一怀明月ꦿ

于 2023-03-09 23:56:41 发布

阅读量1.5k

点赞数 32

文章标签：数据结构算法 java

本文链接：https://blog.csdn.net/m0_67846057/article/details/129433337

版权

🐶博主主页：@ᰔᩚ. 一怀明月ꦿ

❤️‍🔥专栏系列：线性代数，C初学者入门训练，题解C，C的使用文章

🔥座右铭：“不要等到什么都没有了，才下定决心去做”

🚀🚀🚀大家觉不错的话，就恳求大家点点关注，点点小爱心，指点指点🚀🚀🚀

🐰析构函数

🌸析构函数的定义

析构函数的函数名是固定的，由波浪线~后跟类名构成。 析构函数没有返回值，也不接受参数。 由于析构函数不接受参数，因此析构函数无法重载。 一个类可以有多个构造函数，有且仅有一个析构函数 。当一个类未定义自己的析构函数时，编译器会为他自动生成一个合成的析构函数。合成的析构函数函数体为空。

在一个析构函数中，首先执行函数体，然后析构成员，成员被初始化顺序的逆序析构 （先构造后析构，后构造线析构） 。 析构函数的作用并不是删除对象，而是在撤销对象占用的内存之前，完成一些清理工作 。使这部分内存可以被程序分配给新对象使用。程序设计者要设计好析构函数，以完成所需的功能，只要对象的生命周期结束，程序就会自动执行析构函数来完成这些工作。

🌸析构函数的应用：

无论何时一个对象被销毁，都会自动调用其析构函数

（1）对象再离开其作用域时被销毁

（2）当一个对象被销毁时，其成员函数被销毁。

（3）对于动态分配的对象，当对指向它的指针应用delete运算符时被销毁

（4）对于临时对象，当创建它的完整表达式结束时被销毁

注意：当指向对象的引用或指针离开作用域时，析构函数不会执行
class student
{
public:
    student()
    {
        sno=200;
        sname="zhagsan";
    }
    student(int a,string b)
    {
        sno=a;
        sname=b;
    };
    ~student();//析构函数的声明(记住析构函数没有返回类型，参数列表为空)
    void setStudent();
    void showStudent();
    int Add();

private:
    int sno;
    string sname;

};
void student::setStudent()
{
    cout<<"请输入学号和姓名"<<endl;
    cin>>sno>>sname;
}
void student::showStudent()
{
    cout<<sno<<' '<<sname<<' '<<endl;
}
int student::Add()
{
    return sno;
}
student::~student()//析构函数的定义（类外定义函数一定加类名）
{
    cout<<"很好"<<"\n";
}

🐰对象数组

所谓对象数组，指每一个数组元素都是对象的数组，即若一个类有若干个对象，我们把这一系列的对象用一个数组来存放。对象数组的元素是对象，不仅具有数据成员，而且还有函数成员。

声明一个一维数组的格式如下：

类名数组名[常量表达式]

与基本数据类型的数组一样，在使用对象数组时也只能访问单个数组元素，其一般形式为：

数组名[下标表达式].成员名

在建立数组时，需要对数组进行初始化。对象数组的初始化过程实际上就是调用构造函数对每一个元素对象进行初始化的过程。

注：当一个数组中的元素被删除时，系统也会调用析构函数，创建多少个对象，就会调用多少次构造函数
#include<iostream>
using namespace std;
class student
{
public:
    void setstudent();
    void showstudent();
private:
    char id;
    string name;
};
void student::setstudent()
{
    cout<<"请输入学号和姓名"<<endl;
    cin>>id>>name;
}
void student::showstudent()
{
    cout<<"学号和姓名分别为"<<endl;
    cout<<id<<name<<endl;
}
int main()
{
    student s[3];//创建有三个对象的对象数组
    for(int i=0;i<3;i++)
    {
        s[i].setstudent();
    }
    for(int i=0;i<3;i++)
    {
        s[i].showstudent();
    }
}

🐰指向对象的指针

🌸对象指针的概念：

指针指向的是内存中对象所占用空间，对象在内存中的首地址称为对象的指针，用来保存对象的地址的指针变量称为指向对象的指针变量，简称指向对象的指针

🌸定义对象指针:

类名* 指针名

注意：对象指针访问其公共成员是使用"->",对象名访问公共成员时是使用"."
student s1;
student* p=&s1
p1->Add;
🌸指向对象的数据成员的指针
数据类型名* 指针名;

指针=&对象名.数据成员名

注意：这里的数据成员一定要是公共的
student s2;
int* p2;
p2=&s2.flag;
🌸指向对象的成员函数的指针
指向对象的普通函数的指针:

返回类型 (*指针名)(参数列表)

指针名=&函数名或者指针名=函数名；

(*指针名)(参数列表);
void Add()
{
    cout<<a+b<<endl;
}

void (*p3)();
p3=Add;//(1)
P3=&Add;//(2)
(1)(2)都是一样的，因为函数名就是函数的首地址，函数名前加&不影响
指向对象的成员函数的指针：

返回类型 (类名::*指针名)(参数列表)

指针名=&对象名.成员函数名；

指向对象成员函数的指针调用对象的成员函数：

(对象名.指针名)(参数列表)
student s4;
void (student::*p4)();
p4=&student::Add;
(s4.*p4)();
创建一个两数之和的类
#include<iostream>
using namespace std;
class student
{
public:
    student()
    {
        a=1;
        b=1;
    }
    student(int x,int y)
    {
        a=x;
        b=y;
    };
    void Add();
    int flag=1;
private:
    int a;
    int b;

};
void student::Add()
{
    cout<<a+b<<endl;
}
//普通函数
void Add(int x,int y)
{
    cout<<x+y<<endl;
}
int main()
{
    //对象指针
    student s1(1,6);
    student* p1=&s1;
    p1->Add();
    //对象数据成员指针
    student s2(1,6);
    int *p2;
    p2=&s2.flag;
    //普通函数指指针
    void (*p3)(int,int);
    p3=Add;
    //普通函数指针调用函数
    (*p3)(3,5);

    //成员函数指针
    student s4={1,3};
    void (student::*p4)();
    p4=&student::Add;
    //成员函数指针调用函数
    (s4.*p4)();
}