C++类与对象学习总结

一，基础知识

1，类的定义

     类是对具有相同属性和行为的一组对象的抽象与统一描述。是用户自定义的数据类型。类的定义包括行为和属性两个部分。属性以数据表示，行为通过函数实现。

2，（1）C ++中定义类的说明语句一般形式为：

class <类名>
{
public:
//公有段数据成员和成员函数;
protected:
//保护段数据成员和成员函数;
private:
//私有段数据成员和成员函数;
};     //分号不得省略!!!

关键字private用于声明私有成员，私有成员只能在类中可见，不能在类外或派生类中使用。如果私有成员放在第一段，则可以忽略关键字private。

protected声明保护成员。保护成员在类和它的派生类中可见。

public 声明公有成员。公有成员是类的接口，在类中和类外可见。

（2）注意事项：

  类的成员可以是其他类的对象，但不能以类自身的对象作为本类的成员，而类自身的指针和引用可以作为类的成员。  类定义必须以分号“;”结束  。

 类与结构体的区别：

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

（3）数据成员和成员函数

class Date
{public:
void SetDate(int y,int m,int d);
int IsLeapYear();
void PrintDate();
private:
int year,month,day;
};

在这个类的定义中

定义了三个私有数据成员：year，month，day;SetDate函数是用于获取对象的值，设置日期;函数IsLeapYear用于判断是否是闰年; PrintfDate函数用于输出日期。在类的说明语句中没有给出函数的实现。

成员函数在类外的定义使用作用域区分符进行说明，此时函数头的形式为：

返回类型  类名::函数名（参数表） 

则以上的三个成员函数可以输入为：

void Date::SetDate(int y,int m,int d)
{year=y;
month=m;
day=y;
}
int Date::IsLeapYear()
{return(year%4==0&&year%100!=0)||(year%400==0);}
Void Date::PrintDate()
{cout<<year<<”.”<<month<<”.”<<day;}

简单的成员函数实现可以在类中定义，此时，编译器作为内联函数处理例如，成员函数的Setdate在类中写成：

// ...
public：
  void SetDate（int y，int m，int d）
    {year = y;
      month=m;
      day= d;
     }
// ...

成员函数有两个作用：

一是操作数据成员，包括访问和修改数据成员;

二是用于协同不同的对象操作，称为传递消息

3，对象

（1）对象是类的实例或实体。类与对象的关系，如同C ++基本数据类型和该类型的变量之间的关系。

           对象定义的格式：类名对象名1，对象名2，...，对象名n;

（2）访问对象成员

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

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

例：

#include<iostream>
using namespace std;
class  ptr_access
 {public:
 void setvalue(float a, float b) { x=a; y=b; }
 float Getx() {return x;}
 float Gety() {return y;}
 void print()
{
	 cout<<"x="<<x<<endl;
	 cout<<"y="<<y<<endl;
 }
private:                          //私有数据成员
	 float x,y;
};
int main()
{
	 float a1,a2;
	 ptr_access *ptr=new ptr_access;
     	 ptr->setvalue(2,8);
      //通过指针访问公有成员函数
	 ptr->print();
	 a1=(*ptr).Getx();
      //通过公有成员函数访问私有数据成员
	 a2=(*ptr).Gety();
	 cout<<"a1="<<a1<<endl;
        cout<<"a2="<<a2<<endl;
        return 0;
}

4，构造函数和析构函数

（1）构造函数的特点

构造函数是用于创建对象的特殊成员函数 ，当创建对象时，系统自动调用构造函数 。

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

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

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

构造函数可以重载。

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

例：为类Date建立一个构造函数。

#include <iostream.h>
class Date {
    public:
	    Date();     // 无参构造函数
	    Date(int y,int m,int d); 
	    void showDate();
    private:
            int year, month, day;
    };
Date::Date()    // 构造函数的实现
{  year=0; month=0; day=0; }
Date::Date(int y,int m,int d) 
{ year=y; month=m; day=d; }
inline void Date::showDate()
{  cout<<year<<"."<<month<<"."<<day<<endl; } 
int main()
{
     Date a_date,bDate(2014,3,25);   
     a_date.showDate();
     b_date.showDate();
     return 0;
}

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

a 利用构造函数直接创建对象.其一般形式为:
   类名  对象名[(实参表)];
这里的“类名”与构造函数名相同,“实参表”是为构造函数提供的实际参数。 
b 利用构造函数创建对象时,通过指针和new来实现。其一般语法形式为:

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

（3）构造函数初始化成员的两种方法

A 使用构造函数的函数体进行初始化：

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;
	}
}

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

格式:

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

{  函数体，可以是空函数体  } 
初始化列表的形式: 

成员名1(形参名1),成员名2(形参名2),成员名n(形参名n) 

例：

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)
	{               	}
}

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

a 数据成员为常量
b 数据成员为引用类型

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

（4）构造函数的重载

class Date
{ public:
Date();
Date(int);
Date(int,int);
Date(int,int,int);
~Date();
//...
}
//...
void f()
{ Date d;//调用Date();
Date d1(2000);//调用Date(int);
Date d1(2000,1);//调用Date(int,int);
Date d1(2000,1,1);//调用Date(int,int,int);
}

（5）析构函数

 析构函数是用于取消对象的成员函数，当一个对象作用域结束时，系统自动调用析构函数。

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

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

 析构函数名为： ~ 类名。

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

5，需要显式引用this指针的三种情况

（1）在类的非静态成员函数中返回类对象本身或对象的引用的时候，直接使用 return *this，返回本对象的地址时，return this。
（2）当参数与成员变量名相同时，如this->x = x，不能写成x = x。

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

6，复制构造函数

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

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

（1）复制构造函数的特点： 

a 复制构造函数名与类名相同，并且也没有返回值类型。

b 复制构造函数可写在类中，也可以写在类外。

c 复制构造函数要求有一个类类型的引用参数。

d 如果没有显式定义复制构造函数，系统自动生成一个默认形式的复制构造函数。 

(2)三种由编译系统自动调用复制构造函数的情况

a 声明语句中用类的一个已知对象初始化该类的另一个对象时。 
b 当对象作为一个函数实参传递给函数的形参时，需要将实参对象去初始化形参对象时，需要调用复制构造函数。 
c 当对象是函数的返回值时，由于需要生成一个临时对象作为函数返回结果，系统需要将临时对象的值初始化另一个对象，需要调用复制构造函数。

(3)浅复制和深复制

（1）关于浅复制

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

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

（2）关于深复制

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

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

7，常成员

（1）常数据成员

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

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

#include<iostream>
using namespace std;
class Mclass
{ public :
      int k;
      const int M;		//说明常数据成员
      Mclass() : M(5) { } 	//用初始式对常数据成员赋值
      void testFun()
       { //M++;	 	//错误，不能在成员函数中修改常数据成员
           k++;		//可以修改一般数据成员
       }
 } ;
int main()
{ Mclass t1, t2;
   t1.k=100;	
   //t1.M=123;	//错误，不能在类外修改常数据成员
   cout<<"t1.k="<<t1.k<<'\t'<<"t1.M="<<t1.M<<endl;
   t2.k=200;   t2.testFun();
   cout<<"&t1.M="<<&t1.M<<endl;
   cout<<"t2.k="<<t2.k<<'\t'<<"t2.M="<<t2.M<<endl;
   cout<<"&t2.M="<<&t2.M<<endl;
}

（2）常对象

如果在说明对象时用const修饰,则被说明的对象为常对象。
常对象的说明形式如下:
      类名 const 对象名[(参数表)];
  或者
      const  类名 对象名[(参数表)];
  在定义常对象时必须进行初始化,而且不能被更新。
    说明：
   （1）C++不允许直接或间接更改常对象的数据成员。

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

（3）常成员函数

在类中使用关键字const说明的函数为常成员函数,常成员函数的说明格式如下:
       类型说明符 函数名(参数表) const;
  const是函数类型的一个组成部分,因此在函数的实现部分也要带关键字const。 

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

#include<iostream>
using namespace std ;
class  Simple
{   int  x, y ;
  public :
     void setXY ( int a, int b) { x = a ;  y = b ; }
     void printXY() { cout << x << "," << y << endl ; } 
     void  constFun ( ) const
         { x ++ ; y ++ ; }//非法
}；

8，静态成员

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

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

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

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

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

9，友元

如果在本类（类A）以外的其他地方定义了一个函数（函数B）
这个函数可以是不属于任何类的非成员函数，
也可以是其他类的成员函数，
在类体中用friend对其（函数B）进行声明，此函数就称为本类（类A）的友元函数。

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

例：

class  A
   { private:
          int  i ;
          friend void FriendFun(A * , int) ; 
      public:
         void MemberFun(int) ;
   } ;
    …
void FriendFun( A * ptr , int x  ) 
     { ptr -> i = x ; } ;  
void A:: MemberFun( int x ) 
     { i = x ; } ;

10，类的包含

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

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

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

初始化顺序：先初始化被包含的对象成员再初始化本身的数据成员。

二，例题总结

在这一章的学习中就完整的写出了Student这一个类

#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"<<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;
}
bool cmp2(Student stu1,Student stu2)
{
    return stu1.getNo()<stu2.getNo();
}
class Reportcard
{
    Student list[60];
    int n;
public:
      Reportcard():n(0){};
      void add();
      //void deleteStu;
      void query();
      void change();
      void display(int flag);
      int search(int no);
      void sortList();
};
void Reportcard::add()
{
    int no,x,y,z;
    string name;
    //system("cls");//清屏
    cout<<"按学号、姓名、数学、英语、c++顺序输入学生信息，学号输-1表示结束"<<endl;
    while((cin>>no)&&no!=-1)
    {
        cin>>name>>x>>y>>z;
        Student s(no,name,x,y,z);
        list[n++]=s;
        /*for(int i=0,i<n,i++)
        list[i].display();
        */
        sortList();
    }
}
void Reportcard::sortList()
{
    sort(list,list+n,cmp1);
    int i;
    for(i=0;i<n;i++)
    list[i].setOrder(i+1);
}
void Reportcard::display(int flag)
{
    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();
}//flag=1,按学号排列；flag=2,按名次排列
int Reportcard::search(int no)
{
    int i;
    for(i=0;i<n;i++)
    {
        if(list[i].getNo()==no)
        return i;
    }
    return -1;
}
void Reportcard::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 Reportcard::deleteStu()
{
}*/
int main()
{
    Student s(1,"ff",66,77,88);
    s.display();
    cout<<s.getAverage()<<endl;
    s.setName("ff");
    s.display();
    Reportcard c;
    c.add();
    c.display(1);
    c.query();
    c.display(0);
    return 0;
}

1，在定义类的过程中，每增加一个功能都要首先把它调通，每写一个类，也要先把它调试通，采用滚雪球的方法一步步完成。

2，描述信息的类重点是描述信息，成员函数一定有一组get和set函数，以及构造函数。

3，操作类关注于功能的实现，数据成员一定是集合类型和对象数组。

三，学习心得

    从面向过程向面向对象思维的转变，还是有一定难度的。在这章学习中，对管理信息系统开发基本步骤有了基本的了解。先了解系统要实现什么功能;再对系统功能进行分类汇总;然后设计操作类;再设计数据类;然后整合操作类所需的数据，设计数据类，明确如何修饰数据成员，确定数据类的成员函数;最后编码调试数据类和操作类。这种思维模式让我更好的完成向面向对象思维的转变。最后通过老师讲解的ATM的案例，对软件开发的思路也有了初步的了解。随着课程的进行，要做的东西越来越难，越来越复杂，加油！