C++继承

作业

1 （学生类设计）.设计一个友元函数，
按照成绩从高到低的顺序输出姓名、学号和成绩信息。

参考1

class stu{
    friend void sort(stu stu[]);
private:
    int stu_name;
    int stu_hao;
    int stu_grade;
public:
    stu(int name,int hao,int grade);
};
stu::stu(int name,int hao,int age)
    :stu_name(name),stu_hao(hao),stu_grade(age){}

void sort(stu stu6[]){
    int i = 0;
    int j = 0;
    for(i=0;i<5;i++){
        for(j=0;j<5-i-1;j++){
            if(stu6[j].stu_grade > stu6[j+1].stu_grade){
                stu stu7(7,7,88);
                stu7 = stu6[j];
                stu6[j] = stu6[j+1];
                stu6[j+1] = stu7;
            }
        }
    }
    for(i=0;i<5;i++){
        printf("%d %d %d\n",stu6[i].stu_name,stu6[i].stu_hao,stu6[i].stu_grade);
    }
}

参考2

#include <iostream>
using namespace std;
class error{
public:
  error* next;

};
class wenti{
public:
    error *p;
};
void test( wenti &a);


stu::stu(int score , string name,stu* next = NULL):score(score),name(name),next(next){}

void stu::set(int score, string name,stu*next = NULL){
    this->score = score;
    this->name= name;
    this->next = next;

}
int stu::getscore(){
    return this->score;
}
string stu::getname(){
    return this->name;
}
void stu::setnext(stu*next){
    this->next = next;

}
stu* stu::getnext(){
    return this->next;

}
sort::sort(int num, stu* front= NULL, stu *rear = NULL):num(num),front(front),rear(rear){}

void insersort(sort& gg){
    int star = 1;
    while(star){
        cout<<"请输入学生的 分数 姓名" <<endl;
        stu* man = new stu(0," ",NULL);
        int score;
        string name;
        cin >> score>> name;
        man->set(score,name,NULL);
        if(gg.num ==0){
            gg.front = man;
            gg.rear = gg.front;
        }else{
            stu*p = gg.front;

            while(p){
                if(p->getscore() < man->getscore()){
                    man->setnext(p);
                    if(p == gg.front){
                        gg.front = man;
                        gg.rear = man;
                    }else{
                        while(1){
                            if(gg.rear->getnext() == p){
                                gg.rear->setnext(man);
                                gg.rear = gg.front;
                                break;
                            }
                            gg.rear = gg.rear->getnext();
                        }
                    }
                    break;
                }
                p = p->getnext();
            }
            if(!p){
                p = gg.front;
                while(p->getnext()){
                    p = p->getnext();
                }
                p->setnext(man);
            }
        }
        ++gg.num;
        cout<<"按0停止,按任意键继续"<<endl;
        cin>>star;
    }
}

注意：

//构造函数的缺省参数只能是最后的参数，而且不能在声明和实现中同时定义缺省的形式。
//但是，不在类外实现的话就没有问题了。

2 设计BOOK类

//包括ISBN号(string),书名(string),作者(string)以及单价信息，
//还能根据数量确定折扣率并计算应付款项，折扣率五本以上90%,
//十本以上 80%,二十本以上70%。提示：只设计一个种类的书，
//设计适当的构造及析构函数(类声明和成员函数定义分离)。

#include <iostream>
using namespace std;
#include <string>
class BOOK{

private:
    string m_ISBN;
    string m_bookname;
    string m_writer;
    float m_price;
public:
    static int count;
    BOOK(string ISBN,string bookname,string writer,float price);
    friend float totalmoney(BOOK *p);
    ~BOOK(){}
};

int BOOK::count=0;

BOOK::BOOK(string ISBN="",string bookname="",
           string writer="",float price=0.0f)
    :m_ISBN(ISBN),m_bookname(bookname),m_writer(writer),m_price(price)
{
    count++;
}
//打折函数
float totalmoney(BOOK *p){
    if(NULL == p){
        return 0.0f;
    }
    float discount= 0;//折扣
    int i = BOOK::count;
    float t_money = 0.0f;
    while(i){
        t_money += p[i-1].m_price;
        i--;
    }
    i = BOOK::count;
    if(i<5){
        discount=1;
        return t_money*discount;
    }
    else if(i>=5&& i<10){
        discount = 0.9f;
        return t_money*discount;

    }
    else{
        discount = 0.8f;
        return t_money*discount;
    }
}
注意：
//静态成员变量也受访问权限的控制。
//初始化的方式不变。使用私有静态成员变量的方式同普通成员变量。

面向对象程序设计有4个主要特点：

（抽象）、封装、继承和多态性。

单继承语法

说明

1、子类拥有父类的所有成员变量和成员函数
2、子类可以拥有父类没有的方法和属性
3、子类就是一种特殊的父类
4、子类对象可以当作父类对象使用

派生类的访问控制

public继承：
父类成员在子类中保持原有访问级别
private继承：
父类成员在子类中变为private成员
protected继承：
父类中public成员会变成protected
父类中protected成员仍然为protected
父类中private成员仍然为private

C++中的继承方式（public、private、protected）会影响子类的对外访问属性

判断某一句话，能否被访问
1）看调用语句，这句话写在子类的内部、外部
2）看子类如何从父类继承（public、private、protected）
3）看父类中的访问级别（public、private、protected）

类型兼容规则（参考课件）

父类的指针或者引用可以子类对象；
父类指针（引用）做函数参数
可以让子类对象初始化父类（拷贝构造函数）；

继承的对象模型

继承中的构造和析构

1个对象的初始化
2个对象的初始化（组合）
n个对象的初始化（继承）
调用顺序：先调用父类的构造，然后子类的构造
析构顺序相反。

继承和组合混搭

调用顺序：先构造父类，再构造成员变量（组合类）、最后构造自己
先析构自己，在析构成员变量、最后析构父类
//先构造的对象，后释放

当子类成员变量与父类成员变量同名时

当派生类与基类有同名成员时，派生类中的成员将屏蔽基类中的同名成员。
同名成员变量和成员函数通过作用域分辨符进行区分

继承中的static变量

1、在继承体系中依然共享一份内存。
2、继承之后的访问权限与普通变量的访问控制权限一致。

问题：
常成员函数能不能修改static变量？
能。
能否定义 static 常成员函数？
不能。