C++类和对象详解_c++中类和对象的区别

类与对象上篇：

主要内容：
1.类和对象的区别。
2.类的定义。
3.类的访问限定符和封装
4.类的作用域
5.类的实例化（用类类型创建对象）
6.计算类对象的大小
7.this指针

C语言是面向过程的，关注的是过程，分析出求解问题的步骤，通过函数调用逐步解决问题。
C++是基于面向对象的，关注的是对象，将一件事情拆分成不同的对象，靠对象之间的交互完成。

1.类和对象的区别：
类是抽象的，不占用内存。
对象是具体的，占用内存。
类是对象的抽象，而对象是类的具体事项；
比如说：类是蔬菜，那么对象就是青菜等等。

2.类的定义：

class className
{
	 // 类体：由成员函数和成员变量组成
 
}; 	// 一定要注意后面的分号
1
2
3
4
5

class为定义类的关键字，ClassName为类的名字，{}中为类的主体，注意类定义结束时后面分号。
类中的元素称为类的成员：类中的数据称为类的属性或者成员变量; 类中的函数称为类的方法或者成员函数。

类的两种定义方式：

1. 声明和定义全部放在类体中，需要注意：成员函数如果在类中定义。
2. 声明放在.h文件中，类的定义放在.cpp文件中。

一般情况下，更希望大家采用第二种方式。

3.类的访问限定符及封装
类的访问限定符：
public
protected
private
说明：

1. public修饰的成员在类外可以直接被访问。
2. protected和private修饰的成员在类外不能直接被访问(此处protected和private是类似的).
3. 访问权限作用域从该访问限定符出现的位置开始直到下一个访问限定符出现时为止。
4. class的默认访问权限为private，struct为public(因为struct要兼容C)。

经常会有面试题这样问大家：
问题：C++中struct和class的区别是什么？

**答：**C++需要兼容C语言，所以C++中struct可以当成结构体去使用。另外C++中struct还可以用来定义类。和class是定义类是一样的，区别是struct的成员默认访问方式是public，class是struct的成员默认访问方式是private。

封装：
面向对象的三大特性：封装、继承、多态。

封装：将数据和操作数据的方法进行有机结合，隐藏对象的属性和实现细节，仅对外公开接口来和对象进行交互。

封装的本质就是一种管理：比如博物馆的文物，我们如何管理呢？首先是键一座房子把文物给封装起来。然后我们开放了售票通道。可以买票突破封装在和合理的监管机制下去参观。类也是一样，我们使用类数据和方法都封装到一下。不想给别人看到的，我们使用protected/private把成员封装起来。开放一些共有的成员函数对成员合理的访问。所以封装本质是一种管理
C++实现封装的方式：用类将对象的属性与方法结合在一块，让对象更加完善，通过访问权限选择性的将其接口提供给外部的用户使用。

4.类的作用域

1. 每个类都定义了自己的作用域，类的成员(成员函数/成员变量)都在类的这个作用域内，成员函数内可任意访问成员变量和其它成员函数。
2. 对象可以通过 . 直接访问公有成员，指向对象的指针通过 -> 也可以直接访问对象的公有成员。
3. 在类体外定义成员，需要使用 :: 作用域解析符指明成员属于哪个类域。

class Person
{
public:
	 void PrintPersonInfo();
private:
	char _name[20];
	 char _gender[3];
	 int _age;
};
// 这里需要指定PrintPersonInfo是属于Person这个类域
void Person::PrintPersonInfo()
{
	 cout<<_name<<" "_gender<<" "<<_age<<endl;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

5.类的实例化
用类类型创建对象的过程称为类的实例化。

class Person
{
public:
	 void PrintPersonInfo();
private:
	 char _name[20];
	 char _gender[3];
	 int _age;
};
void Test()
{
	Person man;
	man._name = "Peter";
	man._age = 10;
	man._sex = "男";
	man.PrintPersonInfo();

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

6.计算类对象的大小

看代码：

class A
{
public:
	void TestFunc()
	{}


	int _a;
	char _b;
};

class B
{
public:
	void TestFunc()
	{}
};

// 空类
class C
{};


// 类大小的计算方式：类成员变量加起来 + 内存对齐
// 求结构体大小一模一样

// 空类和没有类成员变量的类的大小为一个字节
int main()
{
	cout << sizeof(A) << endl;
	cout << sizeof(B) << endl;
	cout << sizeof(C) << endl;
	system("pause");
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

运行结果

结论：一个类的大小，实际就是该类中”成员变量”之和，当然也要进行内存对齐，注意空类（包括没有成员变量的类）的大小，空类比较特殊，编译器给了空类一个字节来唯一标识这个类。（比如如果现在给了C1,C2,C3三个空类，如果不给内存，那就无法区分这3个类）

7 this指针

先定义一个日期类

class Date
{ 
public :
 void Display ()
 {
	 cout <<_year<< "-" <<_month << "-"<< _day <<endl;
 }
 
 void SetDate(int year , int month , int day)
 {
	 _year = year;
	 _month = month;
	 _day = day;
 }
private :
	 int _year ; // 年
 	int _month ; // 月
	 int _day ; // 日
};
int main()
{
	 Date d1, d2;
	 d1.SetDate(2018,5,1);
	 d2.SetDate(2018,7,1);
	d1.Display();
 	d2.Display();
 	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

对于上述类，有这样的一个问题：
Date类中有SetDate与Display两个成员函数，函数体中没有关于不同对象的区分，那当s1调用SetDate函数时，该函数是如何知道应该设置s1对象，而不是设置s2对象呢？
C++中通过引入this指针解决该问题，即：C++编译器给每个“成员函数“增加了一个隐藏的指针参数，让该指针指向当前对象(函数运行时调用该函数的对象)，在函数体中所有成员变量的操作，都是通过该指针去访问。只不过所有的操作对用户是透明的，即用户不需要来传递，编译器自动

编译器自动操作完成后：

class Date
{ 
public :
 void Display (Date* this)
 {
	 cout <<this->_year<< "-" <<this->_month << "-"<< this->_day <<endl;
 }
 
 void SetDate(Date* this,int year , int month , int day)
 {
	this-> _year = year;
	this-> _month = month;
	this-> _day = day;
 }
private :
	 int _year ; // 年
 	int _month ; // 月
	 int _day ; // 日
};
int main()
{
	 Date d1, d2;
	 d1.SetDate(2018,5,1);
	 d2.SetDate(2018,7,1);
	d1.Display();
 	d2.Display();
 	return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

this指针的特性：

1. this指针的类型：类类型* const
2. 只能在“成员函数”的内部使用
3. this指针本质上其实是一个成员函数的形参，是对象调用成员函数时，将对象地址作为实参传递给this形参。所以对象中不存储this指针。
4. this指针是成员函数第一个隐含的指针形参，一般情况由编译器通过ecx寄存器自动传递，不需要用户传递

关于this指针的一个面试题：

问题：下面程序能通过编译吗？如果崩溃，会在哪里奔溃？

class A
{ 
public:
 void PrintA() 
 {
 	cout<<_a<<endl;
 }
 
 void Show()
 {
	 cout<<"Show()"<<endl;
 }
private:
 	int _a;
};
int main()
{
	 A* p = nullptr;
	 p->PrintA(); 
	 p->Show();
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

答案：能够编译通过，但会崩溃。因为p指向空，然后在运行类中的成员函数时，会通过p找到this指针。此时就会越界访问

---

未完待续！！！