C++学习笔记:类和对象

本文中将会以Date类反复举例,Date类的实现链接: http://t.csdn.cn/vtDQK

1.什么是类?

1. 面向过程和面向对象的初步认识

我们在刚开始学C语言的时候就知道,C语言是面向过程的,关注的是过程,分析出结局问题的步骤,然后通过调用函数来解决问题.
而C++是面向对象的,关注的是对象,将一件事情拆分成不同的对象,靠对象之间的交互完成.

那么,到底什么是对象呢?
首先了解一下C语言的面向过程思想:

举个例子,如果我今天想让我的舍友帮我去食堂打饭,我要先告诉他以下步骤:

在面向过程中,我需要告诉我舍友每一个步骤应该怎么做而达到我的目的

而C++ 的面向对象可以省去很多步骤,直接一步到位:

而这个对象,就是知道怎么帮我打饭,在哪里打饭,打完饭回来送到我手上的我室友,我不用告诉他应该怎么下楼,去哪个饭堂,怎么回宿舍.我只需要告诉他我要吃哪个饭堂的什么饭,他就会帮我打回来.

2. 类的引入

C语言的结构体中只能定义变量,定义完变量,我们想实现一些其他功能就需要用另外的函数来实现,而到了C++中,结构体不仅可以定义变量,还可以定义函数,这样我们在调用这个结构体并实现一些功能的时候在定义这个变量的时候就能顺带的完成一些功能,例如在C++中,栈的实现只需要写一个结构体就可以在实现和调用了:

typedef int DataType;
struct Stack
{
 void Init(size_t capacity)
 {
 _array = (DataType*)malloc(sizeof(DataType) * capacity);
 if (nullptr == _array)
 {
 perror("malloc申请空间失败");
 return;
 }
 _capacity = capacity;
 _size = 0;
 }
 void Push(const DataType& data)
 {
 // 扩容
 _array[_size] = data;
 ++_size;
 }
 DataType Top()
 {
         return _array[_size - 1];
 }
 void Destroy()
 {
        if (_array)
         {
         free(_array);
         _array = nullptr;
         _capacity = 0;
         _size = 0;
         }
 }
 DataType* _array;
 size_t _capacity;
 size_t _size;
};

而在C++中,一般会将这种结构体写成class,因为C语言并不支持这样写,这样写的结构体已经和C++的类非常相似了,我们可以认为这就是一个 栈 对象,当我们需要用到栈的时候只需要调用这个对象就可以实现这个对象中的所有功能,不需要像C语言那样挨个找到对应功能的函数来调用了

2. 类的定义

class Name
{
		//类体:由成员变量和成员函数组成

};   // 这里要带分号

其中class是类的关键字,代表你现在要定义一个类了,class后面用空格隔着的就是你想要定义的类的名字,紧接着**{}中为类的主体**,后面有一个分号;

在类中的内容都被称为类的成员,其中的变量被称为成员变量,类中的函数被称为成员函数 或 类的方法

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

这种一般是在刚开始的学习阶段使用,大项目工程一般都会使用第二种

2.类声明放在.h文件中，成员函数定义放在.cpp文件中，注意：成员函数名前需要加类名 ::

3. 类的访问限定符及封装

1. C++实现封装的方式

用类将对象的属性与方法结合在一块，让对象更加完善，通过访问权限选
择性的将其接口提供给外部的用户使用

【访问限定符说明】

1. public修饰的成员在类外可以直接被访问
2. protected和private修饰的成员在类外不能直接被访问(此处protected和private是类似的)
3. 访问权限作用域从该访问限定符出现的位置开始直到下一个访问限定符出现时为止
4. 如果后面没有访问限定符，作用域就到 } 即类结束。
5. class的默认访问权限为private，struct为public(因为struct要兼容C)
   注意：访问限定符只在编译时有用，当数据映射到内存后，没有任何访问限定符上的区别

2. 封装

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

封装本质上是一种管理，让用户更方便使用类。
比如：对于电脑这样一个复杂的设备，提供给用户的就只有开关机键、通过键盘输入，显示器，USB插孔等，让用户和计算机进行交互，完成日常事务。但实际上电脑真正工作的却是CPU、显卡、内存等一些硬件元件。对于计算机使用者而言，不用关心内部核心部件，比如主板上线路是如何布局的，CPU内部是如何设计的等，用户只需要知道，怎么开机、怎么通过键盘和鼠标与计算机进行交互即可。因此计算机厂商在出厂时，在外部套上壳子，将内部实现细节隐藏起来，仅仅对外提供开关机、鼠标以及键盘插孔等，让用户可以与计算机进行交互即可。

在C++语言中实现封装，可以通过类将数据以及操作数据的方法进行有机结合，通过访问权限来隐藏对象内部实现细节，控制哪些方法可以在类外部直接被使用。

4. 类的作用域

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

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

5. 类的实例化

用类类型创建对象的过程，称为类的实例化

1. 类是对对象进行描述的，是一个模型一样的东西，限定了类有哪些成员，定义出一个类并没有分配实际的内存空间来存储它；
   比如：入学时填写的学生信息表，学生信息表格就可以看成是一个类，来描述具体学生信息。每个学生都有自己的姓名,学号,电话号码.
2. 一个类可以实例化出多个对象，实例化出的对象占用实际的物理空间，存储类成员变量

int main()
{
	Person._age = 100; //编译错误,因为没有实例化
	return 0;
}

正确的做法应该是这样:

int main()
{
 	Person  p;  //先实例化出一个对象出来
	p._age = 100; 
	return 0;
}

6. 类对象模型

如何计算类对象的大小?

首先,在类中分为成员变量和成员函数;因为每一个对象中的成员变量是不同的,但是同一个类的对象调用的成员函数是相同的,因此一个对象中只会保存成员变量的大小,而成员函数被存放在公共代码区,当然,类的大小和结构体一样,要遵循内存对齐原则
但是空类的大小为1,这1个字节的大小是编译器用来标识这个类对象的

7. this指针

1. this指针的引入

因为成员函数都被放在了公共代码区,每一个类的对象都可以调用自己的成员函数,那当我们定义多个类的时候,在使用成员函数时编译器怎么知道我们调用的到底是哪个对象的函数呢?

C++中通过引入this指针解决该问题，即：C++编译器给每个“非静态的成员函数“增加了一个隐藏的指针参数，让该指针指向当前对象(函数运行时调用该函数的对象)，在函数体中所有“成员变量”的操作，都是通过该指针去访问。只不过所有的操作对用户是透明的，即用户不需要来传递，编译器自动完成。

2. this指针的特性

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

8.类的6个默认成员函数

任何类在什么都不写时，编译器会自动生成以下6个默认成员函数。
默认成员函数：用户没有显式实现，编译器会生成的成员函数称为默认成员函数。

9.构造函数

构造函数是一个特殊的成员函数，名字与类名相同,创建类类型对象时由编译器自动调用，以保证每个数据成员都有 一个合适的初始值，并且在对象整个生命周期内只调用一次。

构造函数是特殊的成员函数，需要注意的是，构造函数虽然名称叫构造，但是构造函数的主要任务并不是开空间创建对象，而是初始化对象。
其特征如下：

1. 函数名与类名相同。
2. 无返回值。
3. 对象实例化时编译器自动调用对应的构造函数。
4. 构造函数可以重载。

具体可以看一下这篇文章:链接: http://t.csdn.cn/mQALA

10.析构函数

析构函数：与构造函数功能相反，析构函数不是完成对对象本身的销毁，局部对象销毁工作是由编译器完成的。而对象在销毁时会自动调用析构函数，完成对象中资源的清理工作。
析构函数是特殊的成员函数，其特征如下：

1. 析构函数名是在类名前加上字符 ~。例如:Date类的析构函数

~Date()
{

}

2. 无参数无返回值类型。
3. 一个类只能有一个析构函数。若未显式定义，系统会自动生成默认的析构函数。注意：析构函数不能重载
4. 对象生命周期结束时，C++编译系统系统自动调用析构函数

如果类中没有申请资源时，析构函数可以不写，直接使用编译器生成的默认析构函数，比如Date类；有资源申请时，一定要写，否则会造成资源泄漏，比如Stack类。

11.拷贝构造函数

1. 概念

拷贝构造函数：只有单个形参，该形参是对本类类型对象的引用(一般常用const修饰)，在用已存
在的类类型对象创建新对象时由编译器自动调用。

2. 特征

拷贝构造函数也是特殊的成员函数，其特征如下：

1. 拷贝构造函数是构造函数的一个重载形式。
2. 拷贝构造函数的参数只有一个且必须是类类型对象的引用，使用传值方式编译器直接报错，因为会引发无穷递归调用。
3. 若未显式定义，编译器会生成默认的拷贝构造函数。 默认的拷贝构造函数对象按内存存储按
   字节序完成拷贝，这种拷贝叫做浅拷贝，或者值拷贝。
4. 类中如果没有涉及资源申请时，拷贝构造函数是否写都可以,因为编译器会自动成拷贝构造函数;一旦涉及到资源申请时，则拷贝构造函数是一定要写的，否则就是浅拷贝。
   Date类的拷贝构造:

Date(const Date& d)
{
	_year = d._year;
	_month = d._month;
	_day = d._day;
}

3. 拷贝构造函数的应用场景

1. 使用已存在对象创建新对象
2. 函数参数类型为类类型对象
3. 函数返回值类型为类类型对象

为了提高程序效率，一般对象传参时，尽量使用引用类型，返回时根据实际场景，能用引用
尽量使用引用。

12. 赋值运算符重载

1 .概念

C++为了增强代码的可读性引入了运算符重载，运算符重载是具有特殊函数名的函数，也具有其返回值类型，函数名字以及参数列表，其返回值类型与参数列表与普通的函数类似。

函数名字为：关键字operator后面接需要重载的运算符符号。

函数原型：返回值类型 operator操作符(参数列表)

2. 注意点

1. 不能通过连接其他符号来创建新的操作符：比如operator@
2. 重载操作符必须有一个类类型参数用于内置类型的运算符，其含义不能改变，例如：内置的整型+,不能改变其含义
3. 作为类成员函数重载时，其形参看起来比操作数数目少1，因为成员函数的第一个参数为隐藏的this
4. . :: sizeof ?: .* 注意以上5个运算符不能重载。
5. 如果类中未涉及到资源管理，赋值运算符是否自己实现都可以；一旦涉及到资源管理则必须要实现。

3. 前置++和后置++重载

C++中,因为运算符重载的语法是operator后面接需要重载的运算符符号;
但是,前置++和后置++的语法写出来是一样的,都是operator++那应该怎么区分呢?
C++规定：后置++重载时多增加一个int类型的参数，但调用函数时该参数不用传递，编译器自动传递
因此前置++的语法(以Date类举例):

Date operator++();

后置++的语法

Date operator++(int);

13. const成员

将const修饰的“成员函数”称之为const成员函数，const修饰类成员函数，实际修饰该成员函数隐含的this指针，表明在该成员函数中不能对类的任何成员进行修改。

注意点:

1. const对象不可以调用非const成员函数
2. 非const对象可以调用const成员函数
3. const成员函数内不可以调用其它的非const成员函数
4. 非const成员函数内可以调用其它的const成员函数

取地址及const取地址操作符重载这两个默认成员函数一般不用重新定义 ，编译器默认会生成。
例如:

class Date
{ 
public :
	 Date* operator&()
		 {
			 return this ;
	 	 }
	 const Date* operator&()const
		 {
			 return this ;
		 }
private :
	int _year ; // 年
 	int _month ; // 月
	int _day ; // 日
};

这两个运算符一般不需要重载，使用编译器生成的默认取地址的重载即可，只有特殊情况，才需要重载，比如想让别人获取到指定的内容！

14. 初始化列表

在创建对象时，编译器通过调用构造函数，给对象中各个成员变量一个合适的初始值。

class Date
{
public:
	Date(int year, int month, int day)
	 {
   		 _year = year;
 	  	 _month = month;
	  	 _day = day;
 }
private:
	int _year;
	int _month;
	int _day;
};

虽然上构造函数调用之后，对象中已经有了一个初始值，但是不能将其称为对对象中成员变量的初始化，构造函数体中的语句只能将其称为赋初值，而不能称作初始化。因为初始化只能初始化一次，而构造函数体内可以多次赋值。因此更建议使用初始化列表

初始化列表：以一个冒号开始，接着是一个以逗号分隔的数据成员列表，每个"成员变量"后面跟一个放在括号中的初始值或表达式。

class Date
{
public:
	Date(int year, int month, int day)
	     : _year(year)
	     , _month(month)
	     , _day(day)
	 {}
private:
	int _year;
	int _month;
	int _day;
};

【注意】

1. 每个成员变量在初始化列表中只能出现一次(初始化只能初始化一次)
2. 类中包含以下成员，必须放在初始化列表位置进行初始化：1.引用成员变量 2. const成员变量 3. 自定义类型成员(且该类没有默认构造函数时)
3. 成员变量在类中声明次序就是其在初始化列表中的初始化顺序，与其在初始化列表中的先后次序无关

15. static成员

1. 概念

声明为static的类成员称为类的静态成员，用static修饰的成员变量，称之为静态成员变量；用static修饰的成员函数，称之为静态成员函数。静态成员变量一定要在类外进行初始化

2. 特性

1. 静态成员为所有类对象所共享，不属于某个具体的对象，存放在静态区
2. 静态成员变量必须在类外定义，定义时不添加static关键字，类中只是声明
3. 类静态成员即可用 类名::静态成员 或者 对象.静态成员 来访问
4. 静态成员函数没有隐藏的this指针，不能访问任何非静态成员
5. 静态成员也是类的成员，受public、protected、private 访问限定符的限制

16. 友元

友元提供了一种突破封装的方式，有时提供了便利。但是友元会增加耦合度，破坏了封装，所以友元不宜多用。
友元分为：友元函数和友元类

1. 友元函数

友元函数可以直接访问类的私有成员，它是定义在类外部的普通函数，不属于任何类，但需要在
类的内部声明，声明时需要加friend关键字。
例如:重载运算符 << 发现没办法将operator<<重载成成员函数。因为cout的输出流对象和隐含的this指针在抢占第一个参数的位置。this指针默认是第一个参数也就是左操作数了。但是实际使用中cout需要是第一个形参对象，才能正常使用。所以要将operator<<重载成全局函数。但又会导致类外没办法访问成员，此时就需要友元来解决。operator>>同理。

class Date
{
 	friend ostream& operator<<(ostream& _cout, const Date& d);
 	friend istream& operator>>(istream& _cin, Date& d);
public:
	 Date(int year = 1900, int month = 1, int day = 1)
	 : _year(year)
	 , _month(month)
	 , _day(day)
 {}
private:
	 int _year;
	 int _month;
	 int _day;
};
ostream& operator<<(ostream& _cout, const Date& d)
	{
	 _cout << d._year << "-" << d._month << "-" << d._day;
	 return _cout; 
	}
istream& operator>>(istream& _cin, Date& d)
{
	 _cin >> d._year;
	 _cin >> d._month;
	 _cin >> d._day;
	 return _cin;
}
int main()
{
 	Date d;
	cin >> d;
	cout << d << endl;
	return 0;
}

注意:

1. 友元函数可访问类的私有和保护成员，但不是类的成员函数
2. 友元函数不能用const修饰
3. 友元函数可以在类定义的任何地方声明，不受类访问限定符限制
4. 一个函数可以是多个类的友元函数
5. 友元函数的调用与普通函数的调用原理相同

2. 友元类

友元类的所有成员函数都可以是另一个类的友元函数，都可以访问另一个类中的非公有成员。

友元关系是单向的，不具有交换性。
友元关系不能传递
如果C是B的友元， B是A的友元，则不能说明C时A的友元。

17. 内部类

1. 概念

概念：如果一个类定义在另一个类的内部，这个内部类就叫做内部类。内部类是一个独立的类，
它不属于外部类，更不能通过外部类的对象去访问内部类的成员。外部类对内部类没有任何优越
的访问权限。

注意：内部类就是外部类的友元类，参见友元类的定义，内部类可以通过外部类的对象参数来访
问外部类中的所有成员。但是外部类不是内部类的友元。

2. 特性

1. 内部类可以定义在外部类的public、protected、private都是可以的。
2. 注意内部类可以直接访问外部类中的static成员，不需要外部类的对象/类名。
3. sizeof(外部类)=外部类，和内部类没有任何关系。

class A
{
private:
	 static int k;
	 int h;
public:
	 class B // B天生就是A的友元
	 {
 public:
		 void foo(const A& a)
		 {
		 	cout << k << endl;//OK
			cout << a.h << endl;//OK
		 }
	 };
};
int A::k = 1;
int main()
{
    A::B b;
    b.foo(A());
    
    return 0;
}

18. 匿名对象

匿名对象的特点是不用起名字,直接 类名() 就是一个匿名对象了

    Date();

注意:匿名对象的生命周期只有一行
但是const可以延长匿名对象的生命周期

19. 总结

类是对某一类实体(对象)来进行描述的，描述该对象具有那些属性，那些方法，描述完成后就形成了一种新的自定义类型，才用该自定义类型就可以实例化具体的对象。这种面向对象的思想还需日后慢慢体会,加油coder

❀❀❀