类的基础知识

建立一个Student类,用头文件的方式建立：

student.h文件：

#include <iostream>//.h文件也需要加头，否则编译会出错
#include <string>
using namespace std;

class Student
{
	public:
		Student(int,string,char);
		~Student();//析构函数没有参数，不能被重载一个类只有一个析构函数
		void display();
	//private:
		int num;
		string name;
		char sex;
};//不能忘记;

//类外定义成员函数
Student::Student(int n,string nam,char s)//形参与成员变量名称不能一样
{
	num = n;
	name = nam;
	sex = s;
}
Student::~Student()//析构函数的作用并不是删除对象，而是在撤销对象占用的内存之前完成一些清理工作
{
	cout<<"call destructor"<<endl;
}
void Student::display()//函数返回类型加在最前面
{
	cout<<num<<" "<<name<<" "<<sex<<endl;
}

主函数：

#include <iostream>
#include "student.h" //自定义文件用""
using namespace std;

//指针传递和引用传递
void dispalyByRef(Student &);
void dispalyByPoint(Student *);

int main()
{
	Student std0(10,"Jean",'f');
	std0.display();

	Student std1(11,"Jack",'f');
	std1.display();

	Student * std2 = new Student(100,"WangLi",'f');
	std2->display();
	delete std2;//删除对象前会调用析构函数

	Student * std3 = new Student(101,"Tom",'m');
	std3->display();
	
	dispalyByRef(std1);
	dispalyByPoint(&std1);
	dispalyByPoint(std3);
	return 0;
	/*std0和std1是局部变量，生命周期随着主函数的结束而结束，在撤销对象前调用析构函数
	先执行std1的析构函数，再执行std0的析构函数，这与构造函数的执行顺序相反，与栈类似，先进后出。
	*/
}

void dispalyByRef(Student &std)//引用传递，给std起了一个别名
{
	cout<<std.num<<" "<<std.name<<" "<<std.sex<<endl;//成员变量为public才可以用.访问
}

void dispalyByPoint(Student *std)//指针传递
{
	cout<<std->num<<" "<<std->name<<" "<<std->sex<<endl;//用->访问
}

运行结果：

10 Jean f
11 Jack f
100 WangLi f
call destructor (执行的是std2的析构函数)
101 Tom m
11 Jack f
11 Jack f
101 Tom m
call destructor  (执行的是std1的析构函数)
call destructor  (执行的是std0的析构函数)