C++练习题.docx
《C++练习题.docx》由会员分享，可在线阅读，更多相关《C++练习题.docx（15页珍藏版）》请在冰点文库上搜索。
C++练习题
课后题：
5-5 5-6 5-7 5-9 5-11 5-12 5-13 5-14
5.4：
#include
#include
usingnamespacestd;
classEngine{
public:
classEngine（intx,inty）:
m_x（x）,m_y（y）{};
intGetx（）
{
returnm_x;
}
intGety（）
{
returnm_y;
}
friendclassFuel;
friendvoidShowE（Engine&x）;
private:
intm_x;
intm_y;
};
voidShowE（Engine&x1）
{
intx=x1.m_x;
cout<<"frendfunction:
"<}
classFuel{
public:
voidGet（Enginey）{
z1=y.m_y;
cout<<"friendclass:
"< }
private:
intz1;
};
intmain（）
{
EngineE1（1,2）;
ShowE（E1）;//通过友元函数访问E1里面的数据；
FuelF2;
F2.Get（E1）;//通过友员类访问E1；
return0;
}
5.5
静态数据成员：
如果某个属性为整个类所共有，不属于任何一个具体对象，则采用static关键字来声明为静态成员。
静态成员在每个类中只有一个副本，由该类的所有对象共同来维护和使用，从而实现同一类的不同对象之间的数据共享。
静态数据成员具有静态生命周期。
5.6
静态函数成员：
静态函数成可以通过类名或对象名来调用，而非静态成员函数只能通过对象名来调用。
静态成员函数可以直接访问该类的静态数据和函数成员。
而访问非静态成员函数，必须通过对象名。
5.9：
（1）：
友元关系不能传递；
（2）：
友元关系不能继承；（3）：
友元关系是单向的； 所以 都不是；
5.11：
N的值是fn1函数里赋的值，把主函数里面的值进行了覆盖；
5.12：
5.12
#include
usingnamespacestd;
voidfn1（）
{
staticintn=0;
//n=0;
n+=1;
cout<}
intmain（）
{
inti=10;
while（i--）
{
fn1（）;
}
return0;
}
5.13
#include
usingnamespacestd;
classX;
classY{
public:
voidg（X&a）;
private:
};
classZ{
public:
voidf（X&a）;
private:
};
classX{
public:
classX（inti）:
m_i（i）{};
friendvoidY:
:
g（X&a）;
friendclassZ;
friendvoidh（X&a）;
voidShow（）
{
cout< }
private:
intm_i;
};
voidZ:
:
f（X&a）
{
a.m_i+=5;
}
voidY:
:
g（X&a）
{
a.m_i+=1;
}
voidh（X&a）
{
a.m_i+=10;
}
intmain（）
{
Xx（0）;
Zz;
Yy;
y.g（x）;
z.f（x）;
h（x）;
x.Show（）;
return0;
}
5.14
#include
usingnamespacestd;
classCar;
classBoat{
public:
classBoat（doublex）:
m_weight（x）{};
frienddoublegetTotalWeight（Boat&boat,Car&car）;
private:
doublem_weight;
};
classCar{
public:
classCar（doublex）:
m_weight（x）{};
frienddoublegetTotalWeight（Boat&boat,Car&car）;
private:
doublem_weight;
};
doublegetTotalWeight（Boat&boat,Car&car）
{
return（boat.m_weight+car.m_weight）;
}
intmain（）
{
Boatb1（1223）;
Carc1（1223）;
cout< return0;
}
补充题目：
1、请说出const与#define相比，有何优点？
答：
（1）const定义常量是有效数据类型，而#define宏定义常量却没有；这样const定义
的常量编译器可以对其进行数据静态类型安全检查，而#define宏定义的常量只是进行简单
的字符替换，没有类型安全的检查。
（2）有些调试程序可对const进行调试，但不对#define进行调试。
（3）当定义局部变量时，const作用域仅限于局部变量的函数体内。
但是#define时其
作用域不仅定义于局部变量的函数体内，而是从定义点到整个程序的结束点。
但也可以用
#undef取消其定义从而限定其作用域范围；
2、main函数执行以前，还会执行什么代码？
执行一些预处理代码；
3、编写一个程序，设计一个类Trig，给定三角形的三条边长x,y,z，包含一个友元函数计算两个三角形面积之和。
#include
#include
usingnamespacestd;
classTrig{
public:
classTrig（doublex,doubley,doublez）:
m_x（x）,m_y（y）,m_z（z）{};
frienddoublegetArea（Trig&t,Trig&t2）;
private:
doublem_x;
doublem_y;
doublem_z;
};
doublegetArea（Trig&t,Trig&t2）
{
doublearea1,area2;
area1=0.5*t.m_x*t.m_y*sqrt（1-（（（t.m_x*t.m_x）+（t.m_y*t.m_y）-（t.m_z*t.m_z））/（2*t.m_x*t.m_y）））;
area2=0.5*t2.m_x*t2.m_y*sqrt（1-（（（t2.m_x*t2.m_x）+（t2.m_y*t2.m_y）-（t2.m_z*t2.m_z））/（2*t2.m_x*t2.m_y）））;
return（area1+area2）;
}
intmain（）
{
Trigt1（3,4,5）;
Trigt2（3,4,5）;
cout< return0;
}
4、设计一个程序，其中有三个类，CBank,BBank,GBank.分别为中国银行类，工商银行类，农业银行类。
每个类都包含一个私有数据balance,用于存放储户在该行的存款数，另有一个友元函数total，用于计算储户在这3家银行中的总存款数。
#include
usingnamespacestd;
classBBank;
classGBank;
classCBank{
public:
classCBank（doubleb=0）:
balance（b）{};
friendinttotal（CBank&t1,BBank&t2,GBank&t3）;
private:
doublebalance;
};
classBBank{
public:
classBBank（doubleb=0）:
balance（b）{};
friendinttotal（CBank&t1,BBank&t2,GBank&t3）;
private:
doublebalance;
};
classGBank{
public:
classGBank（doubleb=0）:
balance（b）{};
friendinttotal（CBank&t1,BBank&t2,GBank&t3）;
private:
doublebalance;
};
inttotal（CBank&t1,BBank&t2,GBank&t3）
{
return（t1.balance+t2.balance+t3.balance）;
}
intmain（）
{
doublet;
CBankt1（200）;
BBankt2（300）;
GBankt3（100）;
t=total（t1,t2,t3）;
cout< return0;
}
5、下面程序的输出结果是（ ）
#include
usingnamespacestd;
classSample
{
public:
friendlongfun（Samples）
{
if（s.x<2）
return1;
returns.x*fun（Sample（s.x-1））;
}
Sample（longa）
{
x=a;
}
private:
longx;
};
voidmain（）
{
intsum=0;
for（inti=0;i<4;i++）
{
sum+=fun（Sample（i））;
}
cout<}
A）12 B）16 C）10 D）34 （1+1+（2*1）+（3*2*1））=10；
6、 分析以下程序的执行结果
#include
classSample
{
intn;
staticintsum;
public:
Sample（intx）{n=x;}
voidadd（）{sum+=n;}
voiddisp（）
{
cout<<"n="< }
};
intSample:
:
sum=0;//静态数据成员赋初值
voidmain（）
{
Samplea
（2）,b（3）,c（5）;
a.add（）;
a.disp（）;
b.add（）;
b.disp（）;
c.add（）;
c.disp（）;
}
2235510
7.static全局变量与普通全局变量有什么区别？
static局部变量与普通局部变量有什么区别？
总结static的用法！
8.程序分析题
（1）#include
usingnamespacestd;
classmyClass
{
public:
myClass（）{number++;}
~myClass（）{number--;}
staticintnumber;
};
intmyClass:
:
number=0;
intmain（void）
{
myClass*ptr;
myClassA,B;
myClass*ptr_Arr=newmyClass[3];
ptr=ptr_Arr;
myClassC;
cout<:
number< delete[]ptr;
return0;
} 6
（2）#include
usingnamespacestd;
classTest
{
public:
staticintfunc（）;
staticvoidsfunc（Test&r）;
private:
staticintval;
inta;
};
intTest:
:
val=20;
intTest:
:
func（）
{
val+=val;
returnval;
}
voidTest:
:
sfunc（Test&r）
{
r.a=25;
cout<<"Result3="<}
intmain（void）
{
cout<<"Result1="<:
func（）< Testa;
cout<<"Result1="< Test:
:
sfunc（a）;
return0;
} 40 80 25
3.程序设计题
（1）编一个类，声明一个数据成员和一个静态数据成员，其构造函数初始化数据成员，并把静态数据成员加1，其析构函数把静态数据成员减1.
1>编写一个应用程序，创建该类的3个对象，然后显示其数据成员和静态数据成员，再析构每个对象，并显示它们对静态数据成员的影响
2>修改该类，增加静态成员函数并访问静态数据成员，并声明静态数据成员为保护成员，体会静态成员函数的使用，静态成员之间与非静态成员之间相互访问题。
（2）定义一个处理日期的类TDate，它有3个私有数据成员：
Month,Day,Year和若干个公有成员函数，并实现如下要求：
（1）成员函数设置缺省参数；
（2）定义一个友元函数来打印日期。
（3）某次歌手比赛中，有JudgeNum个评委给选手打分，参加比赛的选手有PlayerNum名，现为比赛记分编写一个CompetitionResult类，类的定义如下：
classCompetitionResult
{
shortnum; //选手号码
char name[10]; //选手姓名
floatscore[JudgeNum]; //记录各评委给选手的打分
floataverage; //选手最后得分，去掉一个最高分和最低分后的平均分
public:
CompetitionResult（）;
CompetitionResult（shortn,char*ps）;
floatMaxScore（）; //求评委打的最高分
floatMinScore（）; //求评委打的最低分
voidSetAvg（）; //求选手的最后得分
floatGetAvg（）; //读选手的最后得分
shortGetNo（）; //求选手的编号
voidsetNo（intj）; //设置选手的编号
char*GetName（）; //读选手的姓名
floatGetScore（intj）; //读第j个评委的打分
void SetScore（intk,floatav）; //记录第j个评委的打分
friendvoidSort（CompetitionResult*pr,intn）; //按最后得分从高到低排序
};
1>写出所有成员函数的实现代码
2>编写main（）函数对该类进行测试。
在函数体中定义CompetitionResult类的对象数组r[PlayerNum],它的每个元素记录每个选手的所有信息，各评委的打分通过键盘输入，在屏幕上应有提示信息进行交互式操作，比赛结果按选手得分从高到低排序输出。
升级会员 