1 访问权限

public:

  当前的成员变量和成员函数，可以被本类/它类的的成员函数、外部函数(包括main函数和自定义函数)来调用

private:

  当前的成员变量和成员函数，只能被本类的成员函数来调用

protected;

  当前的成员变量和成员函数，只能被本类/派生类的成员函数来调用

 

 

2 初始化表

当需要调用它类的构造函数时，考虑使用(如果不使用，就需要使用普通的公共成员函数)

使用方法：

    在函数原型的后面，添加初始化表语句(注意，在类的声明中不能加初始化表语句)

原因：

    构造函数不能被显示调用，只能在定义对象时自动调用(包括无参构造函数和有参构造函数)   

#include <stdio.h>

#include <string.h>

class score

{

private:

    int math;

    int english;

public:

    score();

    score(int mat,int eng);

    void print();

};

score:: score()

{

    math=100;

    english=100;

    printf("score的无参构造函数被调用了\n");

}

score:: score(int mat,int eng)

{

    math=mat;

    english=eng;

    printf("score的有参构造函数被调用了\n");

}

void score::print()

{

    printf("math is %d\tenglish is %d\n",math,english);

    return;

}

class student

{

public:

    int number;

    char *name;

    int age;

    score chengji;

    void print();

    student & operator=(student &other);

    student();

    student(int num,char *nam,int ag,int mat,int eng);

    student(student &other);

    ~student();

};

student:: student()

{

    number=0;

    name=new char[1];

    strcpy(name,"");

    //chengji.math=100;

    //chengji.english=100;

    //score(100,100);

    age=0;

}

student:: student(student &other)

{

    number=other.number;

    name=new char[strlen(other.name)+1];

    strcpy(name,other.name);

    age=other.age;

}

student & student:: operator=(student &other)

{

    if(this==&other)

        return *this;

    number=other.number;

    char *namebak=name;

    name=new char[strlen(other.name)+1];

    strcpy(name,other.name);

    age=other.age;

    delete []namebak;

    return *this;

}

student:: ~student()

{

    printf("开始析构了\n");

    delete []name;

}

student:: student(int num,char *nam,int ag,int mat,int eng):chengji(mat,eng)

{

    number=num;

    name=new char[strlen(nam)+1];

    strcpy(name,nam);

    age=ag;

    //chengji.math=mat;

    //chengji.english=eng;

    //socre(mat,eng);

}

void student:: print()

{

    printf("%d\t%s\t%d\n",number,name,age);   

    chengji.print();

    return;

}

int main()

{

    //student stu1(1001,"zhangsan",21);

    //student stu2(1002,"lisi",22);

    //student stu3(1003,"wangwu",23);

    //stu3=stu2=stu1;

    //stu3.operator=(stu2);

    //stu3.print();

    student stu21(3001,"chuanda",32,91,92);

    stu21.print();

    return 0;

}

 

2 new的另外的用法

score *chengji=new score; //自动调用类的构造函数初始化。

score *chengji=new score(81,82);

score *chengji=new score[1];

score *chengji=new score[1](81,82);//编译失败

score *chengji=new score[2](81,82);//编译失败

为什么一定要定义类的无参构造函数？

原因：否则，无法使用new score[2]这样的用法

3 类和类之间的关系

3.1 UML中的解释

class student

{

public:

    int number;

    char *name;

    int age;

    score *chengji;

    void print();

    student & operator=(student &other);

    student();

    student(int num,char *nam,int ag,int mat,int eng);

    student(student &other);

    ~student();

};

本例1中：student和score是聚合关系

class student

{

public:

    int number;

    char *name;

    int age;

    score chengji;

    void print();

    student & operator=(student &other);

    student();

    student(int num,char *nam,int ag,int mat,int eng);

    student(student &other);

    ~student();

};

本例2中：student和score是组合关系

聚合、组合都属于关联 关系。它们是关联的2个特例

3.2 在很多程序员当中这样解释

本例1中：student和score是关联关系

本例2中：student和score是组合关系

 

 

1 自由组合

7-9人

2 选项目

  2个组可以有相同的

3 组长选好

4 人员分为ABC

5 项目要真实的

6 项目要重视质量---健壮性 

 

4 继承关系

代码;

#include <stdio.h>

#include <string.h>

class student

{

private:

    int number;

    char *name;

    int age;

public:

    void print();

    student & operator=(student &other);

    student();

    student(int num,char *nam,int ag);

    student(student &other);

    ~student();

};

student:: student()

{

    number=0;

    name=new char[1];

    strcpy(name,"");

    age=0;       

}

student:: student(student &other)

{

    number=other.number;

    name=new char[strlen(other.name)+1];

    strcpy(name,other.name);

    age=other.age;

}

student & student:: operator=(student &other)

{

    if(this==&other)

        return *this;

    number=other.number;

    char *namebak=name;

    name=new char[strlen(other.name)+1];

    strcpy(name,other.name);

    age=other.age;

    delete []namebak;

    return *this;

}

student:: ~student()

{

    printf("student开始析构了\n");

    delete []name;

}

student:: student(int num,char *nam,int ag):number(num),age(ag)

{

    //number=num;

    name=new char[strlen(nam)+1];

    strcpy(name,nam);

}

void student:: print()

{

    printf("%d\t%s\t%d\n",number,name,age);   

    return;

}

class student_college:public student

{

private:

    char * name_college;

    char * name_prof;

    int count_persons;

public:

    student_college();

    ~student_college();

};

student_college::student_college()

{

    name_college=new char;

    name_prof=new char;

    strcpy(name_college,"");

    strcpy(name_prof,"");

    count_persons=0;

   

}

student_college::~student_college()

{

    delete []name_college;

    delete []name_prof;

}

int main()

{

    student_college stu_col;   

    return 0;

}

 

代码2：

#include <stdio.h>

#include <string.h>

class student

{

private:

    int number;

    char *name;

    int age;

public:

    void print();

    student & operator=(student &other);

    student();

    student(int num,char *nam,int ag);

    student(student &other);

    ~student();

};

student:: student()

{

    number=0;

    name=new char[1];

    strcpy(name,"");

    age=0;   

    printf("学生类的无参构造函数被调用\n");

}

student:: student(student &other)

{

    number=other.number;

    name=new char[strlen(other.name)+1];

    strcpy(name,other.name);

    age=other.age;

}

student & student:: operator=(student &other)

{

    if(this==&other)

        return *this;

    number=other.number;

    char *namebak=name;

    name=new char[strlen(other.name)+1];

    strcpy(name,other.name);

    age=other.age;

    delete []namebak;

    return *this;

}

student:: ~student()

{

    printf("student开始析构了\n");

    delete []name;

}

student:: student(int num,char *nam,int ag):number(num),age(ag)

{

    //number=num;

    name=new char[strlen(nam)+1];

    strcpy(name,nam);

}

void student:: print()

{

    printf("%d\t%s\t%d\n",number,name,age);   

    return;

}

class student_college:public student

{

private:

    char * name_college;

    char * name_prof;

    int count_persons;

public:

    student_college();

    ~student_college();

};

student_college::student_college()

{

    name_college=new char;

    name_prof=new char;

    strcpy(name_college,"");

    strcpy(name_prof,"");

    count_persons=0;

    printf("大学生的无参构造函数被调用\n");

}

student_college::~student_college()

{

    delete []name_college;

    delete []name_prof;

    printf("大学生的析构函数被调用\n");

}

int main()

{

    student_college *stu_col=new student_college;   

    delete stu_col;

    return 0;

}

注意点：

1 使用new建立的对象，也必须使用delete来销毁。

如果，不delete，则会内存泄露。(析构函数不会被自动调用)

2 析构函数前面都要加virtual

原因：使用多态特性的时候，如果基类的析构函数前面没有virtual,则可能导致析构不全的问题。

代码3：

#include <stdio.h>

#include <string.h>

class student

{

private:

    int number;

    char *name;

    int age;

public:

    void print();

    student & operator=(student &other);

    student();

    student(int num,char *nam,int ag);

    student(student &other);

    virtual ~student();

};

student:: student()

{

    number=0;

    name=new char[1];

    strcpy(name,"");

    age=0;   

    printf("学生类的无参构造函数被调用\n");

}

student:: student(student &other)

{

    number=other.number;

    name=new char[strlen(other.name)+1];

    strcpy(name,other.name);

    age=other.age;

}

student & student:: operator=(student &other)

{

    if(this==&other)

        return *this;

    number=other.number;

    char *namebak=name;

    name=new char[strlen(other.name)+1];

    strcpy(name,other.name);

    age=other.age;

    delete []namebak;

    return *this;

}

student:: ~student()

{

    printf("student开始析构了\n");

    delete []name;

}

student:: student(int num,char *nam,int ag):number(num),age(ag)

{

    //number=num;

    name=new char[strlen(nam)+1];

    strcpy(name,nam);

    printf("学生类的有参构造函数被调用\n");

}

void student:: print()

{

    printf("%d\t%s\t%d\n",number,name,age);   

    return;

}

class student_college:public student

{

private:

    char * name_college;

    char * name_prof;

    int count_persons;

public:

    student_college();

    student_college(int num,char *nam,int ag,char *name_col,char *name_pro,int count_per);

    virtual ~student_college();

    void print();

};

student_college::student_college()

{

    name_college=new char;

    name_prof=new char;

    strcpy(name_college,"");

    strcpy(name_prof,"");

    count_persons=0;

    printf("大学生的无参构造函数被调用\n");

}

student_college:: student_college(int num,char *nam,int ag,char *name_col,char *name_pro,int count_per):student(num,nam,ag)

{

    name_college=new char[strlen(name_col)+1];

    name_prof=new char[strlen(name_pro)+1];

    strcpy(name_college,name_col);

    strcpy(name_prof,name_pro);

    count_persons=count_per;

    printf("大学生的有参构造函数被调用\n");

}

student_college::~student_college()

{

    delete []name_college;

    delete []name_prof;

    printf("大学生的析构函数被调用\n");

}

void student_college:: print()

{

    printf("%s\t%s\t%d\n",name_college,name_prof,count_persons);

    student::print();

    return ;

}

int main()

{

    //student_college *stu_col=new student_college;   

    student_college stu1(1001,"zhangsan",22,"chongda","jike",56);

    stu1.print();

    return 0;

}

注意点：

1 调用基类的有参构造函数时，需要在派生类有参构造函数的后面，使用初始化表，进行显式调用

2 派生类的成员函数，如果要调用基类的成员函数，要加(基类的)作用域。(如果不同名，则可以省略)

5 多态

代码：

#include <stdio.h>

#include <string.h>

class student

{

private:

    int number;

    char *name;

    int age;

public:

    void print();

    student & operator=(student &other);

    student();

    student(int num,char *nam,int ag);

    student(student &other);

    virtual ~student();

    virtual void fun();

};

void student:: fun()

{

    printf("student_fun()\n");

    return;

}

student:: student()

{

    number=0;

    name=new char[1];

    strcpy(name,"");

    age=0;   

    printf("学生类的无参构造函数被调用\n");

}

student:: student(student &other)

{

    number=other.number;

    name=new char[strlen(other.name)+1];

    strcpy(name,other.name);

    age=other.age;

}

student & student:: operator=(student &other)

{

    if(this==&other)

        return *this;

    number=other.number;

    char *namebak=name;

    name=new char[strlen(other.name)+1];

    strcpy(name,other.name);

    age=other.age;

    delete []namebak;

    return *this;

}

student:: ~student()

{

    printf("student开始析构了\n");

    delete []name;

}

student:: student(int num,char *nam,int ag):number(num),age(ag)

{

    //number=num;

    name=new char[strlen(nam)+1];

    strcpy(name,nam);

    printf("学生类的有参构造函数被调用\n");

}

void student:: print()

{

    printf("%d\t%s\t%d\n",number,name,age);   

    return;

}

class student_college:public student

{

private:

    char * name_college;

    char * name_prof;

    int count_persons;

public:

    student_college();

    student_college(int num,char *nam,int ag,char *name_col,char *name_pro,int count_per);

    virtual ~student_college();

    void print();

    virtual void fun();

};

void student_college:: fun()

{

    printf("student_college_fun()\n");

    return;

}

student_college::student_college()

{

    name_college=new char;

    name_prof=new char;

    strcpy(name_college,"");

    strcpy(name_prof,"");

    count_persons=0;

    printf("大学生的无参构造函数被调用\n");

}

student_college:: student_college(int num,char *nam,int ag,char *name_col,char *name_pro,int count_per):student(num,nam,ag)

{

    name_college=new char[strlen(name_col)+1];

    name_prof=new char[strlen(name_pro)+1];

    strcpy(name_college,name_col);

    strcpy(name_prof,name_pro);

    count_persons=count_per;

    printf("大学生的有参构造函数被调用\n");

}

student_college::~student_college()

{

    delete []name_college;

    delete []name_prof;

    printf("大学生的析构函数被调用\n");

}

void student_college:: print()

{

    printf("%s\t%s\t%d\n",name_college,name_prof,count_persons);

    student::print();

    return ;

}

int main()

{

    student *stu_col=new student_college;

    stu_col->fun();

    return 0;

}

注意点:

1 使用基类的地址变量来实现多态

2 基类和派生类的函数，成员函数原型一致，而且前面要加virtual。

3 其它情况不存在多态的问题。

6

虚函数

纯虚函数   =0     无定义

抽象类  只要有1个成员函数是纯虚函数     不能实例化（不能建立 对象）    只用来派生

实例类 可以进行实例化

7

多组合

多聚合