类和对象——中-CSDN博客

本文链接：https://blog.csdn.net/2301_76643854/article/details/134159666

文章目录

每日一码

前言

如果类和对象上没有看，这里的链接是类和对象上的链接：类和对象——上-CSDN博客https://blog.csdn.net/2301_76643854/article/details/134156397?spm=1001.2014.3001.5502

一、this指针

在类和对象上了解了关于this指针的一些基本知识，这里来看一些题。

第一题：这里程序运行是否正常退出？

#i#include<iostream>
using std::cout;
using std::endl;
class A
{
public:
	void Print()
	{
		cout << "print" << endl;

	}
private:

};
int main()
{
	A* s1=nullptr;
	s1->Print();
	return	0;
}

在这道题里面我们如果没有了解过类中函数的存储位置，那么就会觉得这段程序运行的结果是程序崩溃，因为这里我们会觉得使用了空指针，但其实这里并没有使用空指针，在类和对象——上我讲到了，类中的函数并不是存储在类中的，这里我们调用Print函数并没有使用到指针s1.

第二题：这段程序是否正常运行

#include<iostream>
using std::cout;
using std::endl;
class A
{
public:
	void Print()
	{
		cout << a << endl;

	}
private:
	int a;
};
int main()
{
	A* s1=nullptr;
	s1->Print();
	return	0;
}

这里就不像第一题那样了，这里的Print函数使用了类中的变量a，也就使用了空指针，所以程序崩溃。

二、构造函数

1.什么是构造函数

构造函数是和类同名的函数，没有返回值，并且构造函数虽然是叫做构造函数，但它的主要任务并不是开空间创对象，而是初始化对象。

#include<iostream>
using std::cout;
using std::endl;
class A
{
public:
	A()                                     //构造函数A
	{
		cout << "构造函数" << endl;
	}
private:
	int a;
};
int main()
{
	A s1;
	return	0;
}

构造函数和普通的函数其实并没有多大区别，只有一个区别，那就是没有返回值。

当然也有比较特别的构造函数，比如说默认构造函数，为什么说它特别呢？它的独特之处就在于它可以自动执行，

#include<iostream>
using std::cout;
using std::endl;
class A
{
public:
	A()
	{
		cout << "构造函数" << endl;
	}
private:
	int a;
};
int main()
{
	A s1;
	return	0;
}

在我们平时写代码的时候，比如说写一些栈啊，队列啊，之类的数据结构时，我们有时可能会忘记初始化数据，这时候默认构造函数就起了作用，它能帮助我们初始化数据，如果我们更加健忘呢？连初始化函数都忘记写了呢？不要慌张，系统会为你生成默认构造函数，当然只限于默认构造函数。

那么默认构造函数的适用对象有哪些呢？在c++中，祖师爷规定了，默认构造函数初始化的对象只限于自定义类型，而内置类型是不能初始化的（有些编译器会初始化如vs2019）。

#include<iostream>
using std::cout;
using std::endl;

class mystack
{
	int* a;
	int cicy;
	int top;
};

class MyStruct
{
	mystack s1;
	mystack s2;
};
class A
{
public:
	/*A()
	{
		cout << "构造函数" << endl;
	}*/

	void Print()
	{
		cout << a << endl;

	}
private:
	int a;
	MyStruct w;


};
int main()
{
	A s1;
	s1.Print();
	return	0;
}

在默认构造函数的调用时他会给数据进行初始化，但是我们并不知道它会给个什么值，所以我们就需要自己写一个默认构造函数来进行初始化，

#include<iostream>
using std::cout;
using std::endl;

class mystack
{	public:
	int* a;
};

class MyStruct
{
public:
	mystack s1;
};
class A
{
public:
	A()
	{
		a = 1;
		w.s1.a = nullptr;

	}

	void Print()
	{
		cout << a << endl;

	}
private:
	int a;
	MyStruct w;


};
int main()
{
	A s1;
	s1.Print();
	return	0;
}

在这段程序运行时调用默认构造函数A进行初始化，这就是构造函数的作用。

来看看这段程序：

#include<iostream>
using std::cout;
using std::endl;

class mystack
{	public:
	int* a;
};

class MyStruct
{
public:
	mystack s1;
};
class A
{
public:
	A(int i=1)
	{
		a = i;
		w.s1.a = nullptr;

	}

	void Print()
	{
		cout << a << endl;

	}
private:
	int a;
	MyStruct w;


};
int main()
{
	A s1;
	s1.Print();
	return	0;
}

这里的构造函数使用了缺省参数，但是能够照常调用并且初始化，说明了就算是添加了缺省参数，但是A还是默认构造函数，并且：

int main()
{
	A s1(0);
	s1.Print();
	return	0;
}

当我传入一个参数初始化时，它是优先选择传入的那个参数进行初始化的，由此可以得出，只要是不需要参数就可以调用的构造函数就是默认构造函数。

2.析构函数

析构函数相比构造函数就简单许多了，析构函数的写法为： ~类名（）{}

#include<iostream>
using std::cout;
using std::endl;

class A
{
public:
	A(int i=1)        //默认构造函数
	{
		a = i;

	}

	~A()            //析构函数
	{
		cout << "析构函数调用" << endl;
	}
private:
	int a;


};
int main()
{
	A s1(0);
	return	0;
}

析构函数的作用呢与默认构造函数相反，析构函数是进行销毁，并且将在程序结束时自动调用，同默认构造函数一样方便