大四中软实习笔记20130228

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
多组合
多聚合