类的对象-类的构造和析构

YOUTOI

已于 2024-03-20 14:49:32 修改

阅读量23

点赞数

文章标签： c++ 开发语言

于 2023-08-02 10:43:03 首次发布

本文链接：https://blog.csdn.net/m0_72576165/article/details/131920519

版权

类的实例化

class person
{
public:
	void Init(int age,int id)
	{
		_age = age;
		_id = id;
		
	}
	void print()
	{
		cout << _age << " " << _id << " " <<  endl;
	}
private:
	int _age;
	int _id;
	

};

int main()
{
	cout << sizeof(person) << endl;
	person s;
	s.Init(1, 2);
	s.print();
	return 0;
}

this指针

当我们调用成员函数时，实际上是在替某个对象调用它。而成员函数通过一个名叫this的额外的隐式参数来访问调用它的那个对象。

同一个对象去调用函数，那么函数里面的this指针指向的是同一个空间
类的对象中只保存成员变量，成员函数在公共区域
类的空指针去访问成员函数（不在对象里面，在公共区），如果不需要解引用成员变量，那就可以正常运行
this里面存的是对象的地址，是一个形参，一般存在栈帧里面
this指针在实参和形参的位置不能显示写，但可以在内部使用

class Date
{
public:
	//访问成员变量
	//this在实参和形参位置不能显示写
	//但在类里面可以显示用
    //        Date* const this
	void Init(int year, int month, int day)
	{
		//定义
		_year = year;
		_month = month;
		_day = day;
	}
	void Print()
	{
		cout << this << endl;
		cout << _year << "/" << _month << "/" << _day << endl;
	}
private:
	//声明
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1;
	d1.Init(2023, 7, 31);
	Date d2;
	d2.Init(2021,3,4);
	d1.Print();
	cout << &d1 << endl;
	cout << endl;
	d2.Print();
	cout << &d2 << endl;

	return 0;
}

默认成员函数

一个类中一般有6个默认成员函数（编译器自己生成的函数）

构造函数（也叫默认成员函数，不写，编译器也会自动生成）

主要任务：初始化对象，而不是开空间

特点：

默认构造函数（只能有一个）不写才会生成，写了任意一个就不生成
内置类型（用关键字定义的类型）的成员不会处理
自定义类型的成员才会处理，会去调用这个成员的默认构造函数(不传参就可以调用：全缺省，无参的都算默认构造）
无参，全缺省，默认构造都可以调用构造函数，但只能存在一个

特征：

类名与函数名相同
无返回值
对象实例化后编译器自动调用对应的构造函数
构造函数可以重载

对于默认构造而言：

内置类型编译器不做处理
自定义类型编译器则会调用他的默认构造

因此，一般情况下，都要自己写默认构造，除了全是自定义类型或者内置类型有符合我们需求的缺省值

对于无参的构造和全缺省的构造函数，语法上可以同时存在，但是实操时编译器区分不了

析构函数（清理资源，作用等同于销毁函数）

对内置类型的成员，不做处理；对自定义类型，会调用他的析构

对象在销毁时会自动调用析构函数，完成对象中资源的清理

特征：

析构函数名在类名前面加~
无参无返回值
析构函数不能重载，一个类只能有一个
对象生命周期结束时，编译器自动调用析构函数

class Stack
{
public:
	Stack()
	{
		cout << "Stack()" << endl;
		a = nullptr;
		top = capacity = 0;
	}
	void Push(int x)
	{
		if (top == capacity)
		{
			size_t newcapacity = capacity == 0 ? 4 : capacity * 2;
			a = (int*)realloc(a, sizeof(int) * newcapacity);
			capacity = newcapacity;
			if (a == NULL)
			{
				perror("realloc fail");
			}
		}
		else
		{
			a[top++] = x;

		}
	}
	int Top()
	{
		return a[top - 1];
	}
	void Pop()
	{
		assert(top > 0);
		--top;
	}
	/*void Destroy()
	{
		free(a);
		top = capacity = 0;
	}*/
	~Stack()
	{
		cout << "~Stack()" << endl;
		free(a);
		a = nullptr;
		top = capacity = 0;
	}
	bool Empty()
	{
		return top == 0;
	}
private:
	int* a;
	int top;
	int capacity;
};

int main()
{

  Stack s;
  return 0;
}