【C++习题笔记】谭浩强C++程序设计(第三版)第九章

本文是谭浩强老师C++程序设计第三版第九章的习题笔记,主要设计类和对象的应用。

1. 构造函数和析构函数的作用是什么?什么时候需要自己定义构造函数和析构函数?

(1)构造函数:是一种特殊的成员函数,它来实现对象的初始化,它不光可以对数据成员进行赋值,还可以包含其他语句,如cout语句等。构造函数可以自己定义也可以由系统默认给出,当用户未定义构造函数时,系统会提供构造函数,只是该函数是空的,不起初始化作用;如果用户希望在建立对象时就能使用成员初值,就必须自己定义构造函数。

(2)析构函数:是与构造函数作用相反的函数,其作用并不是删除对象,二是在撤销对象占用存储空间之前完成一些清理工作,如释放资源,同时还可以用来执行“用户希望在最后一次使用对象之后所执行的任何操作”,如输出相关信息等。一般情况下,类的设计者应该在声明类的同时定义析构函数,以指定如何完成清理工作,若用户没有定义析构函数,系统也会自动生成,但是它只是徒有析构函数的名称和形式,其实什么操作都不执行,要想让析构函数完成任何工作,都需要在定义的析构函数中指定。

2. 分析下面的程序 写出其运行时的输出结果

#include <iostream>
using namespace std;
class Date
 {public:
   Date(int,int,int);
   Date(int,int);
   Date(int);
   Date();
   void display();
  private:
   int month;
   int day;
   int year;
 };
 
Date::Date(int m,int d,int y):month(m),day(d),year(y)
 { }
 
Date::Date(int m,int d):month(m),day(d)
 {year=2005;}
 
Date::Date(int m):month(m)
 {day=1;
  year=2005;
 }
 
Date::Date()
 {month=1;
  day=1;
  year=2005;
 }

void Date::display()
 {cout<<month<<"/"<<day<<"/"<<year<<endl;}
 
int main()
{
 Date d1(10,13,2005);
 Date d2(12,30);
 Date d3(10);
 Date d4;
 d1.display();
 d2.display();
 d3.display();
 d4.display();
 return 0;
 }

分析方法:这是构造函数的重载问题,原则是,同名的构造函数具有不同的参数,系统按调用时的参数形式来判断调用的是哪个构造函数,因此,上述程序按照构造函数的形式相同的来赋初值,可以得到下述结果:

10/13/2005
12/30/2005
10/1/2005
1/1/2005

3. 如果将第2题中程序的第5行改为用默认参数,即Date(int=1,int=1,int=2005); 分析程序有无问题。上机编译,分析出错信息,修改程序使之能通过编译。要求保留上面一行给出的构造函数,同时能输出与第2题的程序相同的输出结果。

编译出错,原因是构造函数使用默认参数后就不能再使用重载的构造函数,否则就会出现歧义,函数不知道调用的是谁。

修改方法:删去所有重载部分即可。

#include <iostream>
using namespace std;
class Date
 {public:
   Date(int=1,int=1,int=2005);
   //Date(int,int);
   //Date(int);
   //Date();
   void display();
  private:
   int month;
   int day;
   int year;
 };
 
Date::Date(int m,int d,int y):month(m),day(d),year(y)
 { }
 
//Date::Date(int m,int d):month(m),day(d)
// {year=2005;}
// 
//Date::Date(int m):month(m)
// {day=1;
//  year=2005;
// }
// 
//Date::Date()
// {month=1;
//  day=1;
//  year=2005;
// }

void Date::display()
 {cout<<month<<"/"<<day<<"/"<<year<<endl;}
 
int main()
{
 Date d1(10,13,2005);
 Date d2(12,30);
 Date d3(10);
 Date d4;
 d1.display();
 d2.display();
 d3.display();
 d4.display();
 return 0;
 }

4. 建立一个对象数组,内放5个学生的数据(学号、成绩),用指针指向数组首元素,输出第1,3,5个学生的数据。

//建立一个对象数组,内放5个学生的数据(学号、成绩),用指针指向数组首元素,输出第1,3,5个学生的数据。
#include <iostream>
using namespace std;
class Student
{
public:
	Student(int n,float s):num(n),score(s){};
	void display();
private:
	int num;
	float score;
};
void Student::display()
{cout<<num<<" "<<score<<endl;}

int main()
{
	Student stu[5] = {Student(101,78.5),Student(102,85.5),Student(103,98.5),Student(104,100.0),Student(105,95.5)};
	Student *p=stu;
	for(int i = 0; i<=2;p=p+2,i++)
		 p->display();
	return 0;
}

5. 建立一个对象数组,内放5个学生的数据(学号、成绩),设立一个函数max,用指向对象的指针作函数参数,在max函数中找出5个学生中成绩最高者,并输出其学号。

//建立一个对象数组,内放5个学生的数据(学号、成绩),设立一个函数max,用指向对象的指针作函数参数,在max函数中找出5个学生中成绩最高者,并输出其学号。
#include <iostream>
using namespace std;
class Student
{
public:
	Student(int n, float s):num(n),score(s){};
	int max(Student *arr);
	int num;
	float score;
};
int Student::max(Student *arr)
{
	float max_score=arr[0].score;
	int k=0;
	for(int i=1;i<5;i++)
		if(arr[i].score>max_score) {max_score=arr[i].score;k=i;}
	return(k);
}
int main()
{
	Student stu[5] ={Student(101,78.5),Student(102,85.5),Student(103,98.5),Student(104,100.0),Student(105,95.5)};
	int k;
	k = stu[5].max(stu);
	cout<<stu[k].num<<" "<<endl;
	return 0;
}

6. 阅读下面程序,分析其执行过程,写出输出结果。

#include <iostream>
using namespace std;
class Student
 {public:
   Student(int n,float s):num(n),score(s){}
   void change(int n,float s) {num=n;score=s;}
   void display(){cout<<num<<" "<<score<<endl;}
  private:
   int num;
   float score;
 };

int main()
{Student stud(101,78.5);
 stud.display();
 stud.change(101,80.5);
 stud.display();
 return 0;
}

程序分析:第一次dispay执行的是stud的初始值,即101,78.5,然后经过change函数,将第二次的101,80.5传入了change,因此第二次展示的结构是101,80.5

因此输出结果是:

101 78.5
101 80.5

7. 将第6题的程序分别作以下修改,分析所修改部分的含义以及编译和运行的情况。 
(1) 将main函数第2行改为const Student stud(101,78.5);
(2) 在(1)的基础上修改程序,使之能正常运行,用change函数修改数据成员num和score的值。
(3) 将main函数改为
int main( )
{Student stud(101,78.5);
Student *p=&stud;
p->display( );
p->change(101,80.5);
p->display( );
return 0;
其他部分仍同第6题的程序。
(4) 在(3)的基础上将main函数第3行改为const Student *p=&stud;
(5) 再把main函数第3行改为Student *const p=&stud;

程序分析:

(1)改变是Student变为了常对象,由常对象的性质,它只能调用对象中的常函数而不能调用普通函数,因此display()函数需改为常函数;同时由于在其生命周期内,对象中所有的数据成员不能被修改,因此change函数没有意义,可以去掉。

因此程序修改如下:

#include <iostream>
using namespace std;
class Student
 {public:
   Student(int n,float s):num(n),score(s){}
   void change(int n,float s) {num=n;score=s;}
   //void display() {cout<<num<<" "<<score<<endl;}
   void display() const {cout<<num<<" "<<score<<endl;}
  private:
   int num;
   float score;
 };

int main()
{const Student stud(101,78.5);
 stud.display();
 //stud.change(101,80.5);
 //stud.display();
 return 0;
}

(2)若一定要修改常对象中的数字成员,除了将其成员函数变为const类型之外,还要将待修改的数据成员声明为mutable类,如 mutable int count; 即可改变常对象中的数据成员,程序修改如下:

#include <iostream>
using namespace std;
class Student
 {public:
   Student(int n,float s):num(n),score(s){}
   void change(int n,float s) const{num = n;score = s;}
   //void display() {cout<<num<<" "<<score<<endl;}
   void display() const {cout<<num<<" "<<score<<endl;}
  private:
   mutable int num;
   mutable float score;
 };

int main()
{const Student stud(101,78.5);
 stud.display();
 stud.change(101,80.5);
 stud.display();
 return 0;
}

(3)第三小题的改法没有问题,是用指针指向对象的过程,程序正常运行,结果如下

101 78.5
101 80.5

(4)第四小题的改法是用了指向常对象的指针变量,对于它而言,只有用指针访问常对象期间它不可以被改变,而不用指针访问则可以被改变,因此修改如下:

#include <iostream>
using namespace std;
class Student
 {public:
   Student(int n,float s):num(n),score(s){}
   void change(int n,float s) {num = n;score = s;}
   //void display() {cout<<num<<" "<<score<<endl;}
   void display() const {cout<<num<<" "<<score<<endl;}
  private:
   int num;
   float score;
 };

int main( )
{Student stud(101,78.5);
const Student *p=&stud;
p->display( );
stud.change(101,80.5);
p->display( );
return 0;
}

(5)第四小题的改法是将p定义为指向对象的常指针,这种情况下,指针的值不可改变,也就是指向不能改变,但是可以改变指向对象的值,在题中,这种修改只是改变了stud的值,而p指向stud的指向始终没变,因此这种情况下程序正常运行,完整代码如下:

#include <iostream>
using namespace std;
class Student
 {public:
   Student(int n,float s):num(n),score(s){}
   void change(int n,float s) {num = n;score = s;}
   //void display() {cout<<num<<" "<<score<<endl;}
   void display() {cout<<num<<" "<<score<<endl;}
  private:
   int num;
   float score;
 };

int main( )
{Student stud(101,78.5);
Student *const p=&stud;
p->display( );
p ->change(101,80.5);
p->display( );
return 0;
}

8. 修改第6题的程序,增加一个fun函数,改写main函数。在main函数中调用fun函数,在fun函数中调用change和display函数。在fun函数中使用对象的引用(Student &)作为形参。

这个问题考的是对象的应用,也就是用变量的别名来表示它,此时在fun的形参里是对象Student的引用(别名),而在实参里则是类对象,程序如下:

#include <iostream>
using namespace std;
class Student
 {public:
   Student(int n,float s):num(n),score(s){}
   void change(int n,float s) {num=n;score=s;}
   void display() {cout<<num<<" "<<score<<endl;}
  private:
   int num;
   float score;
 };

int main()
{Student stud(101,78.5);
 void fun(Student&);
 fun(stud);
 return 0; 
}
 
void fun(Student &stu)
{stu.display();
 stu.change(101,80.5);
 stu.display();
}

9. 商店销售某一商品,商店每天公布统一的折扣(discount)。同时允许销售人员在销售时灵活掌握售价(price),在此基础上,对一次购10件以上者,还可以享受9.8折优惠。现已知当天3名销货员的销售情况为:
   销货员号(num)    销货件数(quantity)       销货单价(price)
     101                   5                    23.5
     102                  12                    24.56
     103                 100                    21.5

请编程序,计算出当日此商品的总销售款sum,以及每件商品的平均售价。要求用静态数据成员和静态成员函数。

#include <iostream>
using namespace std;
class Product
 {public:
   Product(int n,int q,float p):num(n),quantity(q),price(p){};
   void total();
   static float average();
   static void display();

  private:
   int num;
   int quantity;
   float price;
   static float discount;
   static float sum;
   static int n;
 };

void Product::total()
 {float rate=1.0;
  if(quantity>10) rate=0.98*rate;
  sum=sum+quantity*price*rate*(1-discount);
  n=n+quantity;
 }

void Product::display()
 {cout<<sum<<endl;
  cout<<average()<<endl;
 }

float Product::average()
 {return(sum/n);}
 
 
float Product::discount=0.05;
float Product::sum=0;
int Product::n=0;

int main()
 {
   Product Prod[3]={
     Product(101,5,23.5),Product(102,12,24.56),Product(103,100,21.5)
    };
   for(int i=0;i<3;i++)
     Prod[i].total();
   Product::display();
   return 0;
 }

10. 将例9.13程序中的display函数不放在Time类中,而作为类外的普通函数,然后分别在Time和Date类中将display声明为友元函数。在主函数中调用display函数,display函数分别引用Time和Date两个类的对象的私有数据,输出年、月、日和时、分、秒。请读者自己完成并上机调试。

#include <iostream>
using namespace std;
class Date;
class Time
 {public:
   Time(int,int,int);
   friend void display(const Date &,const Time &);
  private:
   int hour;
   int minute;
   int sec;
 };
 
 Time::Time(int h,int m,int s)
 {hour=h;
  minute=m;
  sec=s;
 }
 
class Date
 {public:
   Date(int,int,int);
   friend void display(const Date &,const Time &);
  private:
   int month;
   int day;
   int year;
 };
 
Date::Date(int m,int d,int y)
 {month=m;
  day=d;
  year=y;
 }
 
void display(const Date &d,const Time &t)
 {
  cout<<d.month<<"/"<<d.day<<"/"<<d.year<<endl;
  cout<<t.hour<<":"<<t.minute<<":"<<t.sec<<endl;
 }
 
   
int main()
{
 Time t1(10,13,56);
 Date d1(12,25,2004);
 display(d1,t1);
 return 0;
}

11. 将例9.13中的Time类声明为Date类的友元类,通过Time类中的display函数引用Date类对象的私有数据,输出年、月、日和时、分、秒。

#include <iostream>
using namespace std;
class Time;
class Date
 {public:
   Date(int,int,int);
   friend Time;
  private:
   int month;
   int day;
   int year;
 };
 
Date::Date(int m,int d,int y):month(m),day(d),year(y){ }

class Time
 {public:
   Time(int,int,int);
   void display(const Date &);
  private:
   int hour;
   int minute;
   int sec;
 };
 
Time::Time(int h,int m,int s):hour(h),minute(m),sec(s){ }
 
void Time::display(const Date &d)
 {
  cout<<d.month<<"/"<<d.day<<"/"<<d.year<<endl;
  cout<<hour<<":"<<minute<<":"<<sec<<endl;
 }
 
   
int main()
{
 Time t1(10,13,56);
 Date d1(12,25,2004);
 t1.display(d1);
 return 0;
}

12. 将例9.14改写为在类模板外定义各成员函数。

#include <iostream>
using namespace std;
template<class numtype>
class Compare
 {public:
   Compare(numtype a,numtype b);
   numtype max();
   numtype min();
  private:
   numtype x,y;
 };
template <class numtype>
Compare<numtype>::Compare(numtype a,numtype b)
  {x=a;y=b;}
template <class numtype>
numtype Compare<numtype>::max()
 {return (x>y)?x:y;}
template <class numtype>
numtype Compare<numtype>::min()
  {return (x<y)?x:y;}

int main()
{Compare<int> cmp1(3,7);
 cout<<cmp1.max()<<" is the Maximum of two integer numbers."<<endl;
 cout<<cmp1.min()<<" is the Minimum of two integer numbers."<<endl<<endl;
 Compare<float> cmp2(45.78,93.6);
 cout<<cmp2.max()<<" is the Maximum of two float numbers."<<endl;
 cout<<cmp2.min()<<" is the Minimum of two float numbers."<<endl<<endl;
 Compare<char> cmp3('a','A');
 cout<<cmp3.max()<<" is the Maximum of two characters."<<endl;
 cout<<cmp3.min()<<" is the Minimum of two characters."<<endl;
 return 0;
}

 

相关推荐
©️2020 CSDN 皮肤主题: 大白 设计师:CSDN官方博客 返回首页