前言

🎃C++是基于C语言衍生的一门语言。它的特色在于面向对象、泛型编程和提供的强大的STL（标准模板库）。

🎈提到面向对象思想，不免想到封装、继承和多态，这是面向对象的三大特性，面向对象的基础是类。

🎡面向对象仅仅靠几句话是无法理解的，必须通过实践才能体会面向对象的优势所在。

🐾本文系统的梳理一下面向对象的基础—类。

注意：本文以介绍类为主，尽量不使用C++中的STL。如string使用了char数组进行代替。

类

类的定义

🎉万物皆是对象，类是对具有共同特征的一类对象的抽象。

🧧共同特征分为：属性特征（数据成员）和行为特征（成员函数）。

C++中类的定义格式：

1
2
3
4
5
6
class 类名
{
成员访问控制符:
	数据成员
	成员函数
};

🧑下面以学生为例，定义一个Student类。

学生的共同属性有：姓名、年龄、考试成绩

共同行为有：学习。

1
2
3
4
5
6
7
8
9
class Student	//类名：Student
{
public:			//成员访问控制符：public
	char name[20];	//数据成员：name
	int age;		//数据成员：age
	int grade;		//数据成员：grade

	void study();	//成员函数的声明：study()
};

❗注意：C语言中使用struct定义结构体，C++中struct也可以定义类。

🧶class和struct的区别在于：如果省略控制访问权限，class默认为privare，struct默认为public。

成员访问控制权限

🛒成员访问控制权限分为：public、private、protected

🎁本文不讨论其它这个问题，private涉及类的封装，而protected涉及类的继承和多态。

简单介绍下它们的区别：

访问控制权限 类内访问权限 子类访问权限 外部访问权限
public √ √ √
protected √ √
private √

成员函数的实现

🎃在前面，我们可以看到，我们在类中仅仅对函数进行了声明，如何进行函数的定义呢？

C++提供了两种定义方法：

声明时实现成员函数

以Student类为例：

1
2
3
4
5
6
7
8
9
10
11
12
class Student
{
public:
	char name[20];
	int age;
	int grade;

	void study()	//声明成员函数时定义
	{
		printf("%s", "学习ing\n");
	}
};

类外实现成员函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
class Student
{
public:
	char name[20];
	int age;
	int grade;

	void study();
};

void Student::study()	//在类外进行定义
{
	printf("%s", "学习ing\n");
}

✨在类外进行定义时需要指明成员函数在哪个类里。

🎡我们使用 类名::函数名 说明成员函数所在位置。

类的使用

类是对具有共同特征的一类对象的抽象。

创建对象

🤨类似C语言中的结构体。我们想使用类必须使用类创建对象，这个过程叫做类的实例化。

创建对象和定义变量格式一样：

1
类名 对象名

使用Student类为例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
#include <cstdio>

class Student	//定义Student类
{
public:
	char name[20];
	int age;
	int grade;

	void study();
};

void Student::study()
{
	printf("%s", "学习ing\n");
}

int main()
{
	Student student;	//创建对象

	return 0;
}

访问成员

🎡我们可以通过对象修改、访问类的数据成员和执行成员函数。

下面以Student类为例：

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
36
37
38
#include <cstdio>
#include <cstring>

class Student	//定义Student类
{
public:
	char name[20];	//数据成员：name
	int age;		//数据成员：age
	int grade;		//数据成员：grade

	void study();	//声明study成员函数
};

void Student::study()	//定义study成员函数
{
	printf("%s", "学习ing\n");
}

int main()
{
	Student student1, student2;	//创建对象

	strcpy(student1.name, "小明");
	student1.age = 18;
	student1.grade = 100;

	strcpy(student2.name, "张华");
	student2.age = 20;
	student2.grade = 90;

	printf("student1：%s\nage:%d\ngrade:%d\n\n", student1.name, student1.age, student1.grade);
	printf("student2：%s\nage:%d\ngrade:%d\n\n", student2.name, student2.age, student2.grade);

	student1.study();
	student2.study();

	return 0;
}

输出结果：

1
2
3
4
5
6
7
8
9
10
student1：小明
age:18
grade:100

student2：张华
age:20
grade:90

学习ing
学习ing

静态成员

静态数据成员

🎡使用static关键字修饰的数据成员即静态数据成员。

🎃静态数据成员可以被类的所有对象共享，可以直接使用类名访问。

🍟类中只能声明静态数据成员，需要在类外进行定义。

定义静态数据成员方法：

1
类型说明符 类名::静态数据成员 = 初始值;

下面通过一个例子说明：

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
#include <cstdio>
#include <cstring>

class Student	//定义Student类
{
public:
	static char teacherName[20];	//老师名 静态数据成员

	char name[20];	//数据成员：name
	int age;		//数据成员：age
	int grade;		//数据成员：grade

	void study();	//声明study成员函数
};

void Student::study()	//定义study成员函数
{
	printf("%s", "学习ing\n");
}

char Student::teacherName[20] = "Name";

int main()
{
	Student student1, student2;	//创建对象
	
	strcpy(Student::teacherName, "yellowBaby");		//使用类名直接访问
	printf("%s\n", student1.teacherName);			//可以被任意对象访问
	printf("%s\n", student2.teacherName);

	return 0;
}

输出结果：

1
2
yellowBaby
yellowBaby

静态成员函数

🎡使用static修饰的成员函数即静态成员函数。

🧶静态成员函数可以被任意对象调用，也可以直接使用类名调用。

❗需要注意的是：静态成员函数默认情况下只能访问静态数据成员。

这是因为：编译器默认给成员函数加入了this指针指向当前对象，而静态成员函数没有this指针。这里不属于基础知识，感兴趣可以自行查阅资料。

下面通过一个例子说明：

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
36
37
#include <cstdio>
#include <cstring>

class Student	//定义Student类
{
public:
	static char teacherName[20];	//老师名 静态数据成员

	char name[20];	//数据成员：name
	int age;		//数据成员：age
	int grade;		//数据成员：grade

	void study();	//声明study成员函数
	static void printTeacherName();
};

void Student::study()	//定义study成员函数
{
	printf("%s", "学习ing\n");
}

void Student::printTeacherName()	//定义study成员函数
{
	printf("%s\n", teacherName);
}

char Student::teacherName[20] = "yellowBaby";

int main()
{
	Student student1;	//创建对象
	
	Student::printTeacherName();	//通过类名调用静态成员函数
	student1.printTeacherName();	//通过对象调用静态成员函数

	return 0;
}

输出结果：

1
2
yellowBaby
yellowBaby

常成员和常对象

常数据成员

🧶使用const修饰的数据成员即常数据成员。

🎶常数据成员即初始化后不能修改。

🧨初始化的两种方式：

1.使用构造函数的列表初始化（后面讲到）

2.直接在类内初始化。

❗注意：常数据成员不能在构造函数的函数体内进行赋值初始化。

静态常数据成员

🧶使用static 和 const修饰的数据成员即静态常数据成员。

🧧它和静态数据成员的区别是值初始化后不能修改。

🎡在类外进行初始化时需要加上const修饰符。

❗注意：如果静态常数据成员是整型，允许在类内初始化（虽然这种做法不被推荐）。

常成员函数

😁使用const修饰的成员函数即常成员函数。

🤣常成员函数不能修改数据成员。

❗在声明和定义常成员函数时都需使用const限定符。

常对象

🎨使用const关键字创建的类对象的即常对象。

😋常对象定义时初始化，不能修改数据成员。

🎉常对象只能调用常函数。

总结

😋本文介绍了C++面向对象的基础：类、类中的数据成员和成员函数、类的相关知识

🤣以初学者角度讲解，尽量避免触及C++的其它知识（如STL、输入输出）。

🎡类是对事物的抽象，正因有了类的出现，强大的面向对象才得以实现。

🧑以上仅仅是个人一些见解，难免会出现错误，还请指正。

🚩创作不易，本人保证所发文章均为精心筹备。

💌如需转载，请保留作者信息和博客地址。

📡如果感觉博客对你略有帮助，欢迎转发给你的朋友，让他们加入到技术风暴中来吧！