作业
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
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<<"请输入学生的 分数 姓名" <> 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停止,按任意键继续"<>star;
}
}
注意：
//构造函数的缺省参数只能是最后的参数，而且不能在声明和实现中同时定义缺省的形式。
//但是，不在类外实现的话就没有问题了。
2 设计BOOK类
//包括ISBN号(string),书名(string),作者(string)以及单价信息，
//还能根据数量确定折扣率并计算应付款项， 折扣率五本以上90%,
//十本以上 80%,二十本以上70%。提示：只设计一个种类的书，
//设计适当的构造及析构函数(类声明和成员函数定义分离)。
#include
using namespace std;
#include
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 常成员函数？
不能。