🚀🚀🚀大家觉不错的话，就恳求大家点点关注，点点小爱心，指点指点🚀🚀🚀

目录

🐰类与对象

🌸类和对象的关系：

🌸类的声明和对象的定义

🏡类的声明:

🏡对象的定义

🐰类的成员函数

🐰对象成员的访问

🐰构造函数和析构函数

🌸构造函数：

🏡构造函数的概念：

🏡构造函数的特性：

🏡构造函数的初始化列表

🐰类与对象

对象：对象就是封装了数据及在这些数据之上的操作的封装体，这个封装体有一个名字标识它，而且向外界提供一组操作

类：类是对具有相同属性和操作的一组对象的抽象描述

 

🌸类和对象的关系：

每一个实体都是对象。有一些对象是具有相同的结构和特性的。每个对象都属于一个特定的类型。在C++中对象的类型称为类(class )。类代表了某一批对象的共性和特征。类是对象的抽象，而对象是类的具体实例(instance)。

正如同结构体类型和结构体变量的关系一样，人们先声明一个结构体类型，然后用它去定义结构体变量。同一个结构体类型可以定义出多个不同的结构体变量。

在C然后++中也是先声明一个类类型，用它去定义若干个同类型的对象。对象就是类类型的一个变量。可以说类是对象的模板，是用来定义对象的一种抽象类型 。类是抽象的，不占用内存，而对象是具体的，占用存储空间。

 

 

🌸类的声明和对象的定义

 

🏡类的声明:

1. 类声明的一般形式：
2. class 类名
3. {
4. public:
5.     公用成员
6.     ...
7. protected:
8.     受保护成员
9.     ...
10. private:
11.     私有成员
12.     ...
13. };

在声明类的一般形式中,class 是声明类的关键字，后面跟着类名。大括号里是类的成员的声明，包括数据成员和成员函数。大括号后面要有分号。

成员的可访问性分为3类：

公用的(public)

受保护的(protected)  

私有的(private)

其中关键宇 public protected 和 private 称为成员访问限定符，后面加上冒号。 访问限定符限定它后面的成员的访问属性，直到出现下一个访问限定符或者类声明结束。

访问属性为公用的成员既可以被本类的成员函数访问，也可以在类的作用域内被其他函数访问。

访问属性为受保护的成员可以被本类区及其派生类的成员函数访问，但不能被类外访问。

访问属性为私有的成员只能被本类成员函数访问而不能被类外访问（类的友元例外）

 

 

在声明类时，这3种访问属性的成员的声明次序是任意的，并且在一个类的声明中这3种访问属性不一定全部都出现，可能只出现两种或一种。

某个成员访问限定符在一个类的声明中也可以出现多次。无论出现几次，成员的访问属性都是从一个成员访问限定符出现开始，到另一个成员访问限定符或类声明为止。如果在类声明的开始处没有写出成员访问限定符，则默认的成员访问属性是私有的。（尽量保证每一种成员访问限定符在类的声明中只出现一次）

 

关于3种成员访问限定符出现的顺序问题，从语法上说无论谁在前谁在后效果都是完全一样的。

 

🏡对象的定义

C++使用类来定义对象大体有三种方法：

 

第一种：先声明类类型，然后再定义对象

1. class student
2. {
3. public:
4.     公用成员
5.     ...
6. protected:
7.     受保护成员
8.     ...
9. private:
10.     私有成员
11.     ...
12. };
13. student stud1, stud2;   //定义了两个student类的对象stud1和stud2
14. 
15. 在C++中，在声明了类类型后，定义对象有两种形式。
16. 
17. （1） class 类名 对象名
18. 
19. class student stud1, stud2;
20. 
21. 
22. （2） 类名 对象名
23. 
24. student stud1, stud2;
25. (1)和(2)这两种形式完全等效，但是(1)形式更加简洁，使用最多

第二种： 在声明类类型的同时定义对象(在定义class类的时候，在定义类的末尾，定义类对象)

1. class student
2. {
3. public:
4.     公用成员
5.     ...
6. protected:
7.     受保护成员
8.     ...
9. private:
10.     私有成员
11.     ...
12. }; stud1, stud2; //定义了两个student类的对象stud1和stud2

第三种：不出现类名，直接定义对象(在定义类的时候，在class关键字后面，没有定义类名)

1. class
2. {
3. public:
4.     公用成员
5.     ...
6. protected:
7.     受保护成员
8.     ...
9. private:
10.     私有成员
11.     ...
12. }; stud1, stud2; //定义了两个类的对象stud1和stud2

第二种和第三种对象定义的方法不常用

特别注意：声明类时系统并不会分配内存空间，而定义对象时系统会给每个对象分配内存空间

🐰类的成员函数

返回值类型 类名::成员函数名(参数表)

{

     函数体  

｝

 

它与普通函数区别于：成员函数是属于某个类的，是类的一个成员。可以指定函数的访问权限（公有，私有，受保护）。在类外调用成员函数要注意它的访问属性， 公有的成员函数才可以被类外任意的调用，私有的成员函数在类外是看不到的。 成员函数可以访问本类的任何成员，不管它的访问属性，可以访问本类的数据成员，也可以调用本类的其他成员函数。

 

成员函数的第一种定义方式：在类声明中只给出成员函数的原型，而将成员函数的定义放在类的外部。

1. #include<iostream>
2. using namespace std;
3. class Point{
4.  public:
5.      void Info();
6.      void Add();
7.  private:
8.      int x,y;
9. };
10. void Point::Info()   //在类外定义成员函数setpoint
11. {
12.     cin>>x>>y;
13. }
14. void Point::Add()
15. {
16.     cout<<x+y<<endl;
17. }
18. int main()
19. {
20.     Point s;
21.     s.Info();
22.     s.Add();
23.     retuen 0;
24. }

成员函数的第二种定义方式：将成员函数直接定义在类的内部

1. #include<iostream>
2. using namespace std;
3. class Point{
4.  public:
5.      void Info()
6.     {
7.          cin>>x>>y;
8.      }
9.      void Add()
10.     {
11.          cout<<x+y<<endl;
12.      }
13.  private:
14.      int x,y;
15. };
16. int main()
17. {
18.     Point s;
19.     s.Info();
20.     s.Add();
21.     return 0;
22. }

注意：

(1） 成员函数在类内定义或是在类外定义,对程序执行的效果基本一样。只是对于较长的成员函数放在类外更有利于程序的阅读。

(2）在类外定义成员函数时，必须首先在类内写出成员函数的原型声明，然后再在类外定义,这就要求类的声明必须在成员函数定义之前

(3） 如果在类外有函数定义，但是在函数名前没有类名和作用域运算符进行限定，则该函数被认为是普通函数

(4） 如果成员函数的函数体很短，如只有两三行,也可以将其定义在类内

 

在类中的成员函数是在类内定义时，C++系统会默认该成员函数是inline成员函数，此时不必在函数定义前面加inline，如果加上也是可以的。如果成员函数定义在类外，类内只有成员函数的声明，则在成员函数的声明或成员函数定义前必须要有inline，成员函数定义前和成员函数声明前只要有一处有inline即可。

🐰对象成员的访问

（1）通过对象名和成员操作符进行访问

 

   对象名.成员名

s.Info();

（2）通过指向对象的指针进行访问

1. #include<iostream>
2. using namespace std;
3. class Point{
4.  public:
5.      void Info()
6.     {
7.          cin>>x>>y;
8.      }
9.      void Add()
10.     {
11.          cout<<x+y<<endl;
12.      }
13.  private:
14.      int x,y;
15. };
16. int main()
17. {
18.     Point s;
19.     Point* ps=&s;
20.     ps->Info();
21.     ps->Add();
22.     return 0;
23. }

（3）通过对象的引用进行访问

 

1. #include<iostream>
2. using namespace std;
3. class Point{
4.  public:
5.      void Info()
6.     {
7.          cin>>x>>y;
8.      }
9.      void Add()
10.     {
11.          cout<<x+y<<endl;
12.      }
13.  private:
14.      int x,y;
15. };
16. int main()
17. {
18.     Point s;
19.     Point &ps=s;
20.     ps.Info();
21.     ps.Add();
22.     return 0;
23. }

🐰构造函数和析构函数

 

🌸构造函数：

🏡构造函数的概念：

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

 

🏡构造函数的特性：

（1）构造函数与类的名相同，与其他函数不一样的是， 构造函数没有返回类型，在定义构造函数时在函数名前什么也不能加（加void也不可以）；除此之外类似于其他的函数，构造函数也有一个（可能为空的）参数列表和一个（可能为空）函数体。

（2）构造函数可以被重载，一个类可以包含多个构造函数，不同的构造函数之间在形参数量或形参类型上有所不同。

（3）构造函数不需要用户调用，它是由系统在创建对象时自动调用的。因此，构造函数要声明为public访问属性的。

（4）构造函数不能声明为const的。

（5）构造函数的作用是在创建对象时对对象的数据成员进行初始化，一般在构造函数的函数体里写对其数据成员初始化的语句，但是也可以在其中加上和初始化无关的其他语句。

（6）C++系统在创建对象时必须执行一个构造函数，如果用户自己没有定义构造函数，编译器会隐式地提供一个构造函数，称为默认构造函数该构造函数的参数列表和函数体都为空

注意：编译器只有发现类不包含任何构造函数的情况下才会替我们生成一个默认的构造函数。一旦我们定义了一些其他的构造函数，如果定义的构造函数的参数列表为空或构造函数为全缺省函数则会是默认构造函数

注：默认的构造函数只能存在一个

 

构造函数体中不是初始化而是赋值

 

🏡构造函数的初始化列表

构造函数的执行分为两个阶段：

（1）初始化阶段（初始化）

初始化阶段具体指的是用构造函数初始化列表的方式来初始化类中的数据成员。没有在构造函数的初始值列表中显式地初始化的成员，则该成员将在构造函数体之前执行默认初始化。

（2）普通计算阶段（赋值）

执行构造函数的函数体，函数体内一般是对类的数据成员进行赋值的操作

1. SalesData(const string &No,int n,double price):bookNo(No),unitsSold(n),revenue(n*price)
2. {
3.     
4. }
5. 
6. SalesData(const string &No,int n,double price)
7. {
8.     bookNo=No;
9.     unitsSold=n;
10.     revenue=n*price;
11. }

 

这两个构造函数执行完成后的效果是一样的，数据成员的值是相同的。区别在于上面的代码初始化了它的数据成员，而下面这个是对数据成员执行了赋值。

 

  🌸🌸🌸如果大家还有不懂或者建议都可以发在评论区，我们共同探讨，共同学习，共同进步。谢谢大家！ 🌸🌸🌸