前言

🎃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、输入输出)。

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

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

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

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

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