类和对象

一、知识点

1、定义：类是对具有相同属性和行为的一组对象的抽象与统一描述。是用户自定义的数据类型

            包括行为和属性两个部分。

            属性以数据表示，行为通过函数实现。

2、 class  类名

{

  public: 公有数据成员和成员函数；

  protected: 保护数据成员和成员函数；

  private:私有数据成员和成员函数；

}；各成员函数的实现；

3、类的成员可以是其他类的对象，但不能以类自身的对象作为本类的成员，而类自身的指针和引用可以作为类的成员。

  ①类定义必须以分号“；”结束。

  ②类与结构体的区别：

         没有明确指定类成员的访问权限时，C++结构体的成员是公有的，而类的成员是私

4、访问控制：

类的访问属性有：

       Public

       Protected

       Private

功能：

访问控制        含义                   属性

Public           公有成员            类的外部接口

Protected     保护成员            仅允许本类成员函数及派生类成员函数访问

Private          私有成员            仅允许本类成员函数访问

3、成员函数

    类的成员函数是实现类的行为属性的成员。

    一般将成员函数声明为函数原型，在类外具体实现成员函数。

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

  { 

   函数体

  }

4、对象：

  对象是类的实例或实体。

  类与对象的关系，如同C++基本数据类型和该类型的变量之间的关系。

  对象的定义格式类名  对象名1，对象名2，…，对象名n；

注意

     必须在定义了类之后，才可以定义类的对象。

 5、类成员的访问包括：

       圆点访问形式：对象名.公有成员

      指针访问形式   对象指针变量名->公有成员

类定义和使用时应注意：

1. 在类的定义中不能对数据成员进行初始化。
2. 类的任何成员都必须指定访问属性，一般将数据成员定义为私有成员或保护成员，将成员函数定义为公有成员。
3. 类中的数据成员可以是C++语法规定的任意数据类型。
4. 类的成员可以是其他类的对象，称为类的组合。但不能以类自身的对象作为本类的成员。
5. 类定义必须以分号“；”结束
6. class与struct的不同：

    ①   class中，成员缺省情况是private。

     struct中，成员缺省情况是public。

      内联函数作用

           减少频繁调用小子程序的运行的时间开销

     内联函数机制

        编译器在编译时，将内联函数的调用以相应代码代替

     内联函数声明

                     inline  函数原型

注意 ：内联函数仅在函数原型作一次声明。

        适用于只有1 ~ 5行的小函数

        不能含有复杂结构控制语句 ，不能递归调用

 6、函数重载：函数名相同，但参数不相同（类型不同，或者个数不同）的一组函数。

       编译器根据不同参数的类型和个数产生调用匹配

       函数重载用于处理不同数据类型的类似任务

 7、构造函数：

     构造函数是用于创建对象的特殊成员函数

     当创建对象时，系统自动调用构造函数

  作用：为对象分配空间；对数据成员赋初值；请求其他资源

   没有用户定义的构造函数时，系统提供缺省版本的构造函数

   构造函数名与类名相同：类名

   构造函数可以重载

   构造函数和析构函数  构造函数可以有任意类型的参数，但没有返回类型

   构函数是用于取消对象的成员函数

   当一个对象作用域结束时，系统自动调用析构函数

   析构函数的作用是进行对象消亡时的清理工作

   没有用户定义析构函数时，系统提供缺省版本的析构函数

   析构函数名为： ~ 类名

  析构函数没有参数，也没有返回类型

8、默认构造函数

     如果类中没有定义构造函数，系统将自动生成一个默认形式的构造函数，用于创建对象，默认构造函数形式：  

     类名::类名(){}

     默认构造函数是一个空函数

9、通常,利用构造函数创建对象有以下两种方法:

   ① 利用构造函数直接创建对象.其一般形式为:

             类名  对象名[(实参表)];

             这里的“类名”与构造函数名相同,“实参表”是为构造函数提供的实际参数。

  ② 利用构造函数创建对象时,通过指针和new来实现。其一般语法形式为:

         类名 *指针变量 = new 类名[(实参表)];

   例如:

        Date *date1=new Date(1998,4,28);

  就创建了对象(*date1)。

  构造函数的初始化列表
                            --------数据成员的初始化

 10、构造函数初始化成员有两种方法
 
    ①使用构造函数的函数体进行初始化 class Date

  {

       int d, m, y;

  public:

         Date(int dd, int mm, int yy)

         {

              d=dd;

              m=mm;

              y=yy;

         }

         Date(int dd, int mm)

         {

              d=dd;

              m=mm;

         }

  }

  ②使用构造函数的初始化列表进行初始化 

  格式:

  funname(参数列表):初始化列表

  {  函数体，可以是空函数体  }

  初始化列表的形式: 成员名1(形参名1),成员名2(形参名2),成员名n(形参名n)

11、必须使用参数初始化列表对数据成员进行初始化的几种情况

     数据成员为常量

     数据成员为引用类型

     数据成员为没有无参构造函数的类的对象

     类成员的初始化的顺序：

     按照数据成员在类中的声明顺序进行初始化，与初始化成员列表中出现的顺序无关

12、设计一个point 类

    数据成员

    点的坐标x,y

    成员函数

          无参构造函数 

                   有参构造函数

         set函数（设置x,y的值）

        get_X函数

                 get_Y函数

             display      函数

13、析构函数

  对象生存期结束时，需要做清理工作，比如：释放成员(指针)所占有的存储空间

  析构函数可以完成上述工作。

  析构函数自动调用（隐式调用）

  析构函数没有返回值，不能有参数，也不能重载

  定义格式如下(类外实现)：

   类名：：~类名()

  {

        函数语句

  }

特点:

      ① 析构函数与构造函数名字相同,但它前面必须加一个波浪号(~);

      ② 析构函数没有参数,也没有返回值,而且不能重载。因此在一个类中只能有一个析构函数;

      ③ 当撤消对象时,编译系统会自动地调用析构函数。

14、默认析构函数

  若没有显式定义析构函数，则系统自动生成一个默认形式的析构函数。

  系统自动生成的默认构造函数形式如下：

  类名::~类名(){}

  注意：一般情况下，可以不定义析构函数但如果类的数据成员中包含指针变量是从堆上进行存储空间分配的话，需要在析构函数中进行存储空间的回收

15、this指针

     用类去定义对象时，系统会为每一个对象分配存储空间。如果一个类包括了数据和函数，要分别为数据和函数的代码分配存储空间。按理说，如果用同一个类定义了10个对象，那么就需要分别为10个对象的数据和函数代码分配存储单元

     类的成员函数如何区分不同的实例对象的数据成员呢?

    C++为此专门设立了一个名为this的指针，用来指向不同的对象。

  一个对象的this指针并不是对象本身的一部分，不会影响sizeof(对象)的结果。

16、需要显式引用this指针的三种情况

（1）在类的非静态成员函数中返回类对象本身或对象的引用的时候，直接使用return *this，返回本对象的地址时，return this。

（2）当参数与成员变量名相同时，如this->x = x，不能写成x = x。

（3）避免对同一对象进行赋值操作，判断两个对象是否相同时，使用this指针。

17、复制构造函数

  复制构造函数用一个已有同类对象创建新对象进行数据初始化

  C++为类提供默认版本的复制构造函数

  程序员可以定义用户版本的复制构造函数

 语法形式

       类名 :: 类名（const  类名  &  引用名  ,  …）；

特点：

1. 复制构造函数名与类名相同，并且也没有返回值类型。
2.  复制构造函数可写在类中，也可以写在类外。
3.  复制构造函数要求有一个类类型的引用参数。
4.  如果没有显式定义复制构造函数，系统自动生成一个默认形式的复制构造函数。

18、复制构造函数的调用

  以下三种情况下由编译系统自动调用：

    ①声明语句中用类的一个已知对象初始化该类的另一个对象时。

    ②当对象作为一个函数实参传递给函数的形参时，需要将实参对象去初始化形参对象时，需要调用复制构造函数。

    ③当对象是函数的返回值时，由于需要生成一个临时对象作为函数返回结果，系统需要将临时对象的值初始化另一个对象，需要调用复制构造函数。

19、浅复制与深复制

  浅复制：

   在用一个对象初始化另一个对象时，只复制了数据成员,而没有复制资源，使两个对象同时指向了同一资源的复制方式称为浅复制。即：对于复杂类型的数据成员只复制了存储地址而没有复制存储内容

    默认复制构造函数所进行的是简单数据复制，即浅复制

  深复制：

  通过一个对象初始化另一个对象时，不仅复制了数据成员，也复制了资源的复制方式称为深复制。

  自定义复制构造函数所进行的复制是浅复制。

   ①定义支持深复制的复制构造函数、

   ②深复制构造函数必须显式定义

20、深复制构造函数的特点

①   定义：类名::类名([const] 类名 &对象名）;

②   成员变量的处理：对复杂类型的成员变量，使用new操作符进行空间的申请，然后进行相关的复制操作

21、常成员

  常数据成员是指数据成员在实例化被初始化后,其值不能改变。

  在类的成员函数说明后面可以加const关键字，则该成员函数成为常量成员函数

  常数据成员：

         使用const说明的数据成员称为常数据成员。

          如果在一个类中说明了常数据成员,那么构造函数就只能通过初始化列表对该数据成员进行初始化,而任何其他函数都不能对该成员赋值。

22、常对象

   如果在说明对象时用const修饰,则被说明的对象为常对象。

    常对象的说明形式如下:

      类名 const 对象名[(参数表)];

  或

     const  类名 对象名[(参数表)];

  在定义常对象时必须进行初始化,而且不能被更新。

   说明：

  ①C++不允许直接或间接更改常对象的数据成员。

  ②C++规定常对象只能调用它的常成员函数、静态成员函数、构造函数(具有公有访问权限)。

 23、常成员函数

  在类中使用关键字const说明的函数为常成员函数,常成员函数的说明格式如下:

      类型说明符 函数名(参数表) const;

     const是函数类型的一个组成部分,因此在函数的实现部分也要带关键字const。

    常成员函数不能更新对象的数据，也不能调用非const修饰的成员函数（静态成员函数、构造函数除外）

【1】静态成员

  类成员冠以static声明时，称为静态成员。

   静态数据成员为同类对象共享。

   静态成员函数与静态数据成员协同操作。 

静态成员函数

      静态成员不属于某一个单独的对象，而是为类的所有对象所共有

      静态成员函数的作用不是为了对象之间的沟通，而是为了能处理静态数据成员: 保证在不依赖于某个对象的情况下，访问静态数据成员

      静态数据成员在定义或说明时前面加关键字static，如：

       class A

      {

              int n;

         static int s;

      }

  对于类的普通数据成员，每一个对象都各自拥有一个副本。（分配不同的存储空间）

  对于静态数据成员，每个类只拥有一个副本 。（在静态存储区分配一个存储空间，对所有对象都是可见的）

  公有访问权限的静态成员，可以通过下面的形式进行访问

  类名::静态成员的名字

 对象名.静态成员名字

  对象指针->静态成员的名字

  在静态成员函数内部，直接访问。

【2】静态数据成员声明及初始化

  在类外进行静态数据成员的声明

  类型 类名::静态数据成员[=初始化值];   //必须进行声明

  不能在成员初始化列表中进行初始化

  如果未进行初始化，则编译器自动赋初值（默认值是0）

  初始化时不能使用访问权限

  除静态数据成员以外，一个类还可以有静态成员函数。

   静态函数仅可以访问静态成员，

  或是静态成员函数或是静态数据成员。

  静态成员函数和静态数据成员一样，它们都属于类的静态成员，它们都不是对象成员。因此，对静态成员的引用不需要用对象名。

  静态成员函数没有this指针，只能对静态数据操作

定义静态成员函数的格式如下:

   static 返回类型 静态成员函数名（参数表）;

   与静态数据成员类似,调用公有静态成员函数的一般格式有如下几种:

   类名::静态成员函数名(实参表)

   对象. 静态成员函数名(实参表)

  对象指针->静态成员函数名(实参表)

注意:

  ①静态成员函数在类外定义时不用static前缀。

  ②静态成员函数主要用来访问同一类中的静态数据成员。

  ③私有静态成员函数不能在类外部或用对象访问。

④可以在建立对象之前处理静态数据成员。

⑤编译系统将静态成员函数限定为内部连接(在其他文件中不可见)。

⑥静态成员函数中是没有this指针的。

 ⑦静态成员函数不访问类中的非静态数据成员。如有需要，只能通过对象名（或指向对象的指针）访问该对象的非静态成员。

24、友元函数

  如果在本类（类A）以外的其他地方定义了一个函数（函数B）这个函数可以是不属于任何类的非成员函数，也可以是其他类的成员函数。

  在类体中用friend对其（函数B）进行声明，此函数就称为本类（类A）的友元函数。

  友元函数（函数B）可以访问这个类（类A）中的私有成员

  25、类的包含(类的组合)

    类的包含是程序设计中一种软件重用技术。即定义一个新的类时，通过编译器把另一个类“抄”进来。 

    当一个类中含有已经定义的类类型成员，带参数的构造函数对数据成员初始化，须使用初始化语法形式。

    构造函数 ( 形参表 ) : 对象成员1(形参表) , … , 对象成员n (形参表 ) ；

26. 对象成员的初始化

     出现成员对象时，该类的构造函数要包含对象成员的初始化。如果构造函数的成员初始化列表没有对成员对象初始化时，则使用成员对象的无参（缺省）构造函数。

    建立一个类的对象时，要先执行成员对象自己的构造函数，再执行当前类的构造函数。

    成员对象的构造函数调用次序和成员对象在类中的说明次序一致（声明顺序为：a1、b1、b2），与它们在成员初始化列表中出现的次序无关（初始化列表顺序为：b1、b2、a1）。

   析构函数的调用顺序相反

27、 对象数组

 所谓对象数组是指每一数组元素都是对象的数组。

       定义一个一维对象数组的格式如下:

       类名 数组名[下标表达式];

    当对象数组所属的类中包含带参的构造函数，可用初始化列表完成对象数组的初始化。

    当对象数组所属的类中包含无参的构造函数，也可以先定义，再给每个数组元素赋值

28、成员对象数组的初始化

    当对象数组所属的类中包含单个参数的构造函数，可简写。

29、管理信息系统开发基本步骤

  编码调试数据类

  在main函数中创建数据类对象、调用各成员函数

  调试操作类

  先调试最急需的成员函数；

  再陆续增加成员函数

  最后增加菜单函数

  调试方法同数据类

  设计多组测试数据，用不同的测试数据反复运行程序

二、例题 

学生信息系统

#include<iostream>
#include<string>
#include<algorithm>
using namespace std;
class student
{
    string name;
    int no;
    int score[3];
    float average;
    int order;
public:
    student(int id,string na,int x,int y,int z):name(na),no(id)
    {
        score[0]=x,score[1]=y,score[2]=z;
        order=-1,average=(score[0]+score[1]+score[2])/3;
    }
    student()
    {
        score[0]=score[1]=score[2]=0;
        order=-1,average=0;
    }
    int getNo(){return no;}
    float getAverage(){return average;};
    void setAverage(int avg){average=avg;}
    void setOrder(int x){order=x;}
    int getOrder(){return average;};
    string getName(){return name;}
    void setName(string name){this->name=name;}
    void display();
};
void student::display()
{
    cout<<name<<"\t"<<no<<"\t"<<score[0]<<"\t"<<score[1]<<"\t"<<score[2]<<"\t"<<average<<"\t\t"<<order<<endl;
}
bool cmp1(student stu1,student stu2)
{
    if(stu1.getAverage()-stu2.getAverage()>=1e-9) return 1;
    else return 0;
}
bool cmp2(student stu1,student stu2)
{
    return stu1.getNo()<stu2.getNo();
}
class student_list
{
    student list[60];
    int n;
public:
    student_list():n(0){};
    void add();
    void deleteStu();
    void query();
    void change();
    void display(int flag);//flag=1,成绩按学号排列。flag=0,成绩按名次排列
    void menu();
    int search(int no);//按学号查找。找到返回在成绩表中的位置，否则返回-1
    void sortList();
};
//该函数的功能是添加一个或者多个同学基本信息。
void student_list::add()
{
    int no,x,y,z;
    string name;
    system("cls");
    cout<<"请输入 学号、姓名、数学、英语、C++，输入-1结束\n";
    while((cin>>no)&&no!=-1)
    {
        cin>>name>>x>>y>>z;
        student s(no,name,x,y,z);
        list[n++]=s;
        sortList();
    }
}
//该函数的功能是对改变了的成绩表进行名次更新。结果可以按名次排列也可按学号排列
void student_list::sortList()
{
    sort(list,list+n,cmp1);
    int i;
    for(i=0;i<n;i++)
    list[i].setOrder(i+1);
}
void student_list::display(int flag)//flag=1,按学号排列; flag=0,按名次排列
{
    if(flag) sort(list,list+n,cmp2);
    else sort(list,list+n,cmp1);
    cout<<"姓名"<<"\t"<<"学号"<<"\t"<<"数学"<<"\t"<<"英语"<<"\t"<<"c++"<<"\t"<<"平均成绩"<<"\t"<<"名次"<<endl;
    for(int i=0;i<n;i++)
    list[i].display();
}
int student_list::search(int no)
{
    int i;
    for(int i=0;i<n;i++)
    if(list[i].getNo()==no) return i;
    return -1;
}
void student_list::query()
{
    int no,i;
    system("cls");
    cout<<"请输入要查询同学的学号，按-1结束查询：";
    while(cin>>no&&no!=-1)
    {
        i=search(no);
        if(i!=-1)
        {
            cout<<"姓名"<<"\t"<<"学号"<<"\t"<<"数学"<<"\t"<<"英语"<<"\t"<<"c++"<<"\t"<<"平均成绩"<<"\t"<<"名次"<<endl;
            list[i].display();
            cout<<"请输入要查询的同学的学号，按-1结束查询：";
        }
        else cout<<"学号输入有误，请重输，输入-1结束查询"<<endl;
    }


}
//该函数的功能是实现按学号进行修改操作，并输出查找的结果
void student_list::change()
{
    int no,i,x,y,z;
    string name;
    system("cls");
    cout<<"请输入要修改同学的学号，按-1结束修改：";
    while(cin>>no&&no!=-1)
    {
        i=search(no);
        if(i!=-1)
        {
            cout<<"请输入修改后的姓名、数学、英语、C++\n";
            cin>>name>>x>>y>>z;
            student s(no,name,x,y,z);
            list[i]=s;
            sortList();
            cout<<"请输入要修改同学的学号，按-1结束修改：";
        }
        else cout<<"学号输入错误，请重输，输入-1结束";
    }
}
void student_list::deleteStu()
{
    int no,i;
    system("cls");
    cout<<"请输入要删除同学的学号，按-1结束：";
    while(cin>>no&&no!=-1)
    {
        i=search(no);
        if(i!=-1)
        {
            for(int a=i;a<=n;a++)
            {
                list[a]=list[a+1];
            }
            sortList();
            cout<<"请输入要删除同学的学号，按-1结束：";
        }
        else cout<<"学号输入错误，请重输，输入-1结束";
    }
}
int main()
{
    int a;
    student s(1,"ff",66,77,88);
    s.display();
    cout<<s.getAverage()<<endl;
    s.setName("方法");
    s.display();
    student_list c;
    cout<<"请先添加学生信息\n";
    c.add();
    cout<<"请选择接下来的操作，查询输入1，修改输入2，删除输入3，按学号显示全体输入4，结束输入-1\n";
    while(cin>>a&&a!=-1)
    {
        if(a=2) c.change();
        if(a=1) c.query();
        if(a=3) c.deleteStu();
        if(a=4) c.display(1);
        else cout<<"没有这项功能，请重新输入\n请选择接下来的操作，查询输入1，修改输入2，删除输入3，结束输入-1\n";
    }
    return 0;

}

三、心得

被称为最难部分的类和对象，确实是难，看懂一些，也有一些看不懂的，完全打不出来，就像一团叫浆糊，根本不知道怎么用，现在自己买了本书在看，希望能够有些进步，看看能不能掌握。如果单就现在来说，对这部分的知识掌握极差，感觉学了和没学最大的区别就是看了一部分书，至于说应用什么的基本是零。要说别的什么心得，也说不上来，毕竟现在多数的东西都不会，只能希望再多看书之后能够将这部份知识加深一下理解，尽量掌握这部分知识的应用。