初识-类与对象

一、类

  　C语言是面向过程的，关注的是过程。 C++是基于面向对象的，关注的是对象。 就好比一个外卖APP，C语言更关注的是如何下单等过程，C++更加关注的是骑手、商家、买家的关系。对象就是指类的实例，将对象作为程序的基本单元，将程序和数据封装其中，以提高软件的应用性、灵活性和扩展性。

1.1 类的定义

  　类是现实世界在计算机中的反映，它将数据和对这些数据的操作封装在一起（并没有开空间）。

  　C语言中，结构体中只能定义变量，在C++中，结构体内不仅可以定义变量，也可以定义函数。 同时与class不同的是： class的默认访问限定符是私有，而struct默认访问限定符是公有。
  　class为定义类的关键字，ClassName为类的名字，{}中为类的主体，类定义结束时后面分号。 类中的元素称为类的成员：类中的数据称为类的属性或者成员变量; 类中的函数称为类的方法或者成员函数。

class Student
{
//成员函数
	void Print()
	{
		cout << _name << " " << _age << " " << _tell << endl;
	}
//成员变量
	char* _name;
	int _age;
	int _tell[20];
};

1.1.2 两种定义方式

  　1. 声明和定义全部放在类体中，注意：成员函数如果在类中定义，编译器可能会将其当成内联函数处理。

class Student
{
public:
	void Print()
	{
		cout << _name << " " << _age << " " << _tell << endl;
	}
private:
	char* _name;
	char* _sex;
	int _age;	
};

  　2.声明放在.h文件中，类的定义放在.cpp文件中。

//声明放在类的头文件student.h中
class Student
{
public:
	void Print()；
private:
	char* _name;
	char* _sex;
	int _age;	
};
//定义放在类的实现文件test.cpp中
#include"student.h"
void Student::Print()
{
	cout << _name << " " << _age << " " << _tell << endl;
}

更加推荐第二种写法。

二、类的访问限定符及封装

2.1 三种访问限定符

  　public：公有的，修饰的成员在类外可以直接被访问
  　private/protected：私有的，修饰的成员在类外不能直接被访问
  　访问权限作用域从该访问限定符出现的位置开始直到下一个访问限定符出现时为止。

2.2 封装

  　面向对象的三大特性：封装、继承、多态。
  　封装：函数的封装是一种形式，隐藏对象的属性和实现细节（函数内部），仅仅对外提高函数的接口和对象进行交互。 类的访问限定符可以协助其完成封装。封装本质上是一种管理。

三、类的作用域

  　类定义了一个新的作用域，类的所有成员都在类的作用域中。在类体外定义成员，需要使用 :: 作用域解析符指明成员属于哪个类域。

class Person
{
public:
	void PrintPersonInfo();
private:
	char* _name;
	char* _sex;
	int _age;
};
// 这里需要指定PrintPersonInfo是属于Person这个类域
void Person::PrintPersonInfo()
{
	cout<<_name<<" "_sex<<" "<<_age<<endl;
}

四、类的实例化

  　用类类型创建对象的过程，称为类的实例化。
  　1）类里面有哪些成员，定义出一个类并没有分配实际的内存空间来存储它；类相当于盖楼房的图纸一样，虽然定义了有哪些成员，但并没有实际开辟出来空间。
  　2）类可以实例化出多个对象，实例化出的对象才能实际存储数据，占
用物理空间；类实例化出对象就像现实中使用建筑设计图建造出房子。

class Date
{
public:
	void Printf()
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}
public :
    int _year;     //年
	int _month;    //月
	int _day;      //日
};

void Test()
{
    Date d;     //实例化对象
    d._year = 0;
    d._month = 1;
    d._day = 1;
    day.Printf();
}

五、计算类大小

  　类的成员函数放在公共代码区，所有该类的对象共享这些成员函数， 每个对象的大小为类内成员变量的大小之和，遵循内存对齐原则。

  　对象中只存储成员变量，不存储成员函数【成员函数放在代码区】？一个类实例化出N个对象，每个对象的成员变量都可以存储不同的值，但是调用成员函数确实同一个的【如果每个对象都存一样的成员函数会浪费空间】。下图可以看出类实例化出来的对象s1和s2调用的push函数是同一个。

  　没有成员变量的类【空类/仅有成员函数的类】大小是1。开1个字节不是为了存数据而是占位表示对象存在，不然在实例化对象的时候为0的话没有地址。

class stack
{
public:
	void Pop()
	{
		///
	}
	void Push(int x)
	{
		//
	}
private:
	int* _a;
	int size;
	int capity;
};
class A1 
{
public:
	void f1()
	{}
private:
	int _a;
};

// 类中仅有成员函数
class A2 
{
public:
	void f2() //     1
	{}
};

// 类中什么都没有---空类
class A3
{};          //      1
int main()
{
    stack s1;
	stack s2;
	s1.Push(1);
	s2.Push(1);
	
	cout << sizeof(s1) << endl;//--12
	cout << sizeof(A1) << sizeof(A2) << sizeof(A3) << endl;// 4 1 1
	system("pause");
	return 0;
}

六、 this指针

  　C++类中的成员函数中增加了一个隐藏的指针参数，让该指针指向当前对象(函数运行时调用该函数的对象)，在函数体中所有成员变量的操作，都是通过该指针去访问。
问。只不过所有的操作对用户是透明的，即用户不需要来传递，编译器自动完成。
  　this指针存在进程地址空间的哪个区域？栈上，因为它是一个形参【vs下是在ecx这个寄存器来传递、寄存器存储量小但是很快】。
  　this指针是成员函数隐含指针形参，是编译器自己处理的，我们不能在成员函数的形参中添加this指针的参数定义，也不能在显示传递对象的地址给this指针。

6.1 特性

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

//this指针问题
class A
{
public:
	//成员函数存在公共的代码段，所以p->show()这里不会去p指向的对象上找
	void print()//void print(A*this)
	{
		cout << _a << endl;//cout<<this->_a<<endl; 空指针被访问了所以程序崩溃
	}
	void show()//void (A*this)只存在成员函数中
	{
		cout << "show()" << endl;
	}
private:
	int _a;
};
class date
{
public:
	void Printf()//void(date* this)隐含的this指针--谁调用这个成员函数this就指向谁
	{
		cout << _year << "-" << _month << "-" << _day << endl;
		//cout << this->_year << "-" <<this-> _month << "-" << this->_day << endl;
	}
	date(int year = 1900,int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	A*p = NULL;
	//p->print();--程序奔溃
	p->show();//p->show(p) --正常运行

	date d1;
	d1.Printf();//d1.Printf(&d1)
	system("pause");
	return 0;
}