【C++入门（5）】类和对象（初始类、默认成员函数）

一、初识类

1、struct

C语言中，struct用来声明一个结构体，在C++中，兼容了C语言的用法，struct可以用来声明一个结构体，除此之外，C++还把struct升级为了类，引入了类和对象的概念。

类和结构体的不同：

1、在类中，可以定义成员函数；

2、结构体名称可以直接代表类型；

cpp 复制代码

//C语言写法

struct hat {
	int a;
	int b;
};

void func()
{
	;
}

int main()
{
    struct hat h;
    return 0;
}


//C++写法

struct hat {

	void func()
	{
		;
	}

	int a;
	int b;
};

int main()
{
	hat h;
	return 0;
}

用类来创建的变量就叫做对象，这个操作被称为类的实例化。一个类可以实例化出多个对象。

2、class

上面用struct来定义类是C++兼容C语言的体现，实际在C++中定义类，一般是用class来声明的。

cpp 复制代码

class hat {
	void func() {
		;
	}
	int a;
	int b;
};

int main()
{
	class hat h_1;
	hat h_2;
	return 0;
}

3、访问限定符

类中还包含三种访问限定符：public(公有)、protected(保护)、private(私有).

（1）public修饰的成员可以在类外直接被访问；

（2）protected和private修饰的成员不能被直接访问；

（3）访问权限作用域从一个访问限定符出现开始，到下一个访问限定符出现或类定义结束为止；

（4）class的默认访问权限为private，而struct的默认访问权限为public（为了兼容C语言）。

cpp 复制代码

class hat {
public:
	void func() {
		;
	}
private:
	int a;
	int b;
};

int main()
{
	hat h;
	h.func();
	return 0;
}

4、类域

类也会形成自己的域。

cpp 复制代码

class hat {
public:
	void in();
};

void hat::in() {
	;
}

我们在一个类中声明一个公有的成员函数，在类外对它进行定义的时候，需要在函数名前加上类名和域作用限定符，来告诉编译器这个要定义的函数是hat类中的成员函数in.

5、封装

封装就是指在类中，把数据和操作数据的方法（函数）结合起来，隐藏掉对象的属性和数据等，仅对外公开接口来和对象进行交互。

也就是说，通常把成员函数设为公有，包括的数据的设成私有，在对对象进行操作时，只能通过调用类所提供的函数来进行，而没有办法直接操作对象中被设为私有的数据。

通过封装，可以把我们想要呈现出去的部分呈现出去，把我们想要隐藏的部分隐藏起来，进而实现对对象数据的保护，也更便于数据的管理，防止其他使用者对数据的非法引用。

二、默认成员函数

默认成员函数是指，即使我们没有去显式的实现，编译器也会自动生成的类的成员函数。

默认成员函数一共有六个：构造函数、析构函数

1、构造函数

构造函数是用来初始化对象的，规定它的函数名与类名相同，无返回类型，在对象实例化时由编译器自动调用，并且这个函数是可以重载的。

（1）显式定义构造函数

cpp 复制代码

class Date {
public:
	Date(int year,int month,int day) {
		_year = year;
		_month = month;
		_day = day;
	}
	void Print() {
		cout << _year << ' ' << _month << ' ' << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};

int main()
{
	Date date(2000, 1, 1);
	date.Print();
	return 0;
}

（2）编译器定义构造函数

如果我们没有显式定义构造函数，编译器会自动生成默认的构造函数。

C++规定，编译器自默认生成的构造函数，是无参的，并且在函数中，把类型分为内置类型和自定义类型。

这个默认生成的构造函数，会对自定义类型，调用这个自定义类型自己的构造函数，而对内置类型，什么都不会做。

（3）默认构造函数

默认构造函数，不仅仅指编译器自动生成的构造函数，还包括无参的构造函数，和全缺省的构造函数。但是在一个类中，只能存在一个默认构造函数。

也就是说，我们自己显式定义的构造函数，如果是无参的，或者是全缺省的，那么这个构造函数也属于默认构造函数。

cpp 复制代码

class Date {
public:
	Date() {
		_year = 0;
		_month = 0;
		_day = 0;
	}
	void Print() {
		cout << _year << ' ' << _month << ' ' << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};

这也是一个默认构造函数。

如果我们显式定义了一个非默认构造函数，而在对象的实例化时试图用默认的构造函数来进行初始化，编译器就会报错。

cpp 复制代码

class Date {
public:
	Date(int year,int month,int day) {
		_year = year;
		_month = month;
		_day = day;
	}
	void Print() {
		cout << _year << ' ' << _month << ' ' << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};

int main()
{
	Date date;
	date.Print();
	return 0;
}

（4）C++11的补丁性规定

编译器默认生成的构造函数，对内置参数没有规定要如何处理，这往往导致一些小麻烦。

所以C++11中，规定在对类中成员变量声明时，可以采用给缺省值的做法，来规避这一小麻烦。

cpp 复制代码

class Date {
private:
	int _year = 0;
	int _month = 0;
	int _day = 0;
};

这样即使在对象实例化时调用的是编译器自动生成的构造函数，对象内部的内置变量类型也会被初始化。