有以下程序： class Date { public: Date(int y, int m, int d); year = y; month = m; day = d; Date(int y = 2000) year = y; month = 10; day = 1; Date(Date &d) { year = d.year; month = d.month; day = a.day; } void print() cout＜＜year＜＜"."＜＜month＜＜"."＜＜day＜＜end1; } pr
题目
有以下程序： class Date { public: Date(int y, int m, int d); year = y; month = m; day = d; Date(int y = 2000) year = y; month = 10; day = 1; Date(Date &d) { year = d.year; month = d.month; day = a.day; } void print() cout＜＜year＜＜"."＜＜month＜＜"."＜＜day＜＜end1; } private: int year, month,day; }; Date fun(Date d) Date temp; temp = d; return temp; } int main() { Date date 1 (2000,1,1),date2(0,0,0); Date date3(date 1); date2 = fun(date3); return 0; } 程序执行时，Date 类的拷贝构造函数被调用的次数是
A．2
B．3
C．4
D．5
相似考题
更多“有以下程序:class Date{public:Date(int y, int m, int d); year = y; month = m; day = d;Date( ”相关问题
-
第1题：
有以下程序：
class Date
{
public:
Date(int y,int m,int d);
{
year=y;
month=m
day=d;
}
Date(int y=2000)
{
year=y;
month=10;
day=1;
}
Date(Date &d)
{
year=d.year;
month=d.month;
day=d.day;
}
void print( )
{
cout＜＜year＜＜"."＜＜month＜＜"."＜＜day＜＜endl;
}
private:
int year,month,day;
};
Date fun(Date d)
{
Date temp;
temp=d;
return temp;
}
int main( )
{
Date datel(2000,1,1),date2(0,0,0);
Date date3(datel);
date2=fun(date3);
return 0;
}
程序执行时，Date类的拷贝构造函数被调用的次数是
A．2
B．3
C．4
D．5
正确答案：B
解析：本题考核拷贝构造函数。上述程序中，拷贝构造函数一共被调用了3次：第一次是在执行语句Date dare3(datel)；时，用已经建立的对象datel对正在建立的对象date3进行初始化；第二次是在调用fun函数时，由于是传值调用，因此实参对象date3要对形参对象d进行初始化；第三次是在执行fun函数中的返回语句return temp；时，系统初始化一个匿名对象时使用了拷贝构造函数。 -
第2题：
为使下列程序的正确输出结果为： Now is 2004-7-6 12:12:12 那么应该在程序划线处填入的语句是( )。 #include ＜iostream＞ using namespace std; class TIME; class DATE { public: DATE(int y=2004,int m=1,int d=1) { year=y; month=m; day=d; } void DateTime(TIME &t); private: int year,month, day; }; class TIME { public: TIME(int h=0,int m=0,int s=0) { hour=h; minute=m; second=s; } ______________; //将类 DATE 中成员函数 DateTime 声明为类 TIME 的友元函数 private: int hour,minute, second; }; void DATE: :DateTime(TIME &t) { cout＜＜"Now is "＜＜year＜＜'-'＜＜month＜＜'-'＜＜day＜＜ ' '＜＜t.hour＜＜":"＜＜t.minute＜＜': '＜＜t.seoond＜＜'.'＜＜end1; } int main ( ) { DATE d(2004,7,6); TIME t (12, 12, 12); d. DateTime (t); return 0; }
A．friend void DateTime(TIME &t);
B．friend void DATE::DateTime(TIME &0;
C．void DateTime(TIME &t);
D．friend void DateTime(TIME &t);
正确答案：B
解析：根据要求可知，在横线处是将类DATE中成员函数DateTime声明为类TIME的友元函数。由于函数DateTime是类DATE的成员函数，因此对DateTime函数的使用要加上“DATE：：”修饰。其他各声明的组成部分可参照函数DateTime在类体外的定义实现。 -
第3题：
在下面程序的画线处填上适当的内容,使程序执行后的输出结果为1／2005。 includeusin 在下面程序的画线处填上适当的内容，使程序执行后的输出结果为1/2005。
include ＜iostream＞
using namespace std；
class Date{
public：
Date(int m=1，int y=0)：month(m)，year(y){}
void Print( ){cout＜＜month＜＜"/"＜＜year＜＜endl；}
(9) operator+(const Date&dl，const Date& d2)；
private：
int month，year；
}；
(10) operator+(const Date& dl，const Date& d2){
int year，month；
year=d1．year+d2．year；
month=d1．month+d2．month；
year+=(month-1)/12；
month=(month-1)%12+1；
return Date(month，year)；
}
void main( ){
Date dl(3，2004)，d2，d3(10)；
d2=d3+dl；
d2．Print( )；
}
正确答案：friend：Date Date
friend：Date Date 解析：因为重载函数后面有两个形参，“+”运算符是二元运算符，故将“+”运算符重载为友元函数，重载为友元函数的一般格式为：
niend函数类型operator运算符(形参表){函数体} -
第4题：
为了使程序的输出的正确结果为： Now is 2004．7.10 10：10：10． 那么应在下列程序划线处填入的正确语句是( )。 那么应在下列程序划线处填入的正确语句是( )。 #include ＜iostream＞ using namespace std; class TIME; class DATE { public: DATE(int y=2004,int m=1,int d=1) { year=y; month=m; day=d; } friend void DateTime(DATE &d, TIME &t); private: int year, month, day; }; class TIME { public: TIME(iht h=0, int m=0,int s=0) { hour=h; minute=m; second=s; } friend void DateTime(DATE &d,TIME &t); private: int hour,minute, second; }; ______________________ //函数 DateTime 的首部 { cout＜＜"Now is"＜＜d.year＜＜'.'＜＜d.month＜＜'.'＜＜d.day＜＜ ' '＜＜t.hour＜＜":"＜＜t.minute＜＜':'＜＜t.second＜＜'.'＜＜end1; } int main ( ) { DATE d(2004,7,10); TIME t(10, 10, 10); DateTime(d,t); return 0; }
A．void DateTime(DATE &d,TIME &t)
B．void TIME::DateTime(DATE &d,TIME &t) const
C．friend void DateTime(DATE &d,TIME &t)
D．void DATE::DateTime(DATE &d,TIME &t)
正确答案：A
解析：本题程序中，分别在类DATE和TIME中将普通函数DateTime声明为友元函数，但该友元函数的定义是在类体外进行的。友元函数是一个普通函数，它虽然可以访问类对象的私有成员，但它毕竟不是类中的成员函数，因此在类体外定义友元函数时，不需要像成员函数一样在函数名前加上“类名：：”。函数首部的其他定义照抄类中友元函数的声明。所以函数DateTime的首部为voidDateTime(DATE&d；TIME&t)，即选项A。 -
第5题：
有以下程序： class Date { public： Date(int y,int m,int D) ； { year =y； month=m； day=d； } Date(int y=2000) { year=y； month=10； day=1； } Date(Date &D) { year=d.year； month=d.month； day=d.day； } void print () { cout＜＜year＜＜"．"＜＜month＜＜"."＜＜day＜＜end1； } private： int year,month,day； }； Date fun(Date D) { Date temp； temp=d； return temp； } int main() { Date date1(2000,1，1)，date2(0，0,0)； Date date3(date1)； date2=fun(date3)； return 0； } 程序执行时，Date类的拷贝构造函数被调用的次数是
A．2
B．3
C．4
D．5
正确答案：B
解析：本题考核拷贝构造函数。上述程序中，拷贝构造函数一共被调用了3次：第一次是在执行语句Datedate3(date1)；时，用已经建立的对象date1对正在建立的对象date3进行初始化：第二次是在调用fun函数时，由于是传值调用，因此实参对象date3要对形参对象d进行初始化；第三次是在执行fun函数中的返回语句returntemp；时，系统用返回初始化一个匿名对象时使用了拷贝构造函数。 -
第6题：
有以下程序includeusing namespace std;static int days[]= { 31,28,31,30,31,30,31 有以下程序 #include ＜iostream＞ using namespace std; static int days[]= { 31,28,31,30,31,30,31,31,30,31,30,31 }; class date { private: int month, day, year; public: date( int m, int d, int y ) { month = m; day = d; year = y; } date() {} void disp() { cout＜＜year＜＜"-"＜＜month＜＜"-"＜＜day＜＜end1; } date operator+( int day ) { date dt = *this; day+= dt.day; while ( day ＞ days[dt.month - 1 ] ) { day -= days[ dt.month - 1 ]; if ( ++dt.month == 13 ) { dt.month = 1; dt.year++; } } dt.day = day; return dt; }; int main() { date d1( 6, 20, 2004 ), d2; d2: d1 + 20; d2.disp(); return 0; } 执行后的输出结果是
A．2004-7-10
B．2004-6-20
C．2004-7-20
D．程序编译时出错
正确答案：A
解析：本题考核运算符的重载。本题通过将“+”运算符重载为类date的成员函数实现简单的对象加法。 -
第7题：
阅读以下说明和C++抖程序，将应填入(n)处的字句写在答题纸的对应栏内。
【说明】
下面程序的功能是计算并输出某年某月的天数。
【C++程序】
include＜iostream＞
using namespace std；
(1) Month{Jan，Feb，Mar,Art，May,Jun，Jul，Aug，Sep,Oct,Nov,Dec}；
class Date{
public：
Date(int year,Month m_month){
(2) =year；
if (m_month＜Jan‖m_month＞Dec) month=Jan；
else month=m_month；
}；
~Date(){}；
bool IsLeapYear(){
return ((year%4==0 && year%1001!=0)‖year%400==0)；
}；
int CaculateDays(){
switch( (3) ){
case Feb：{
if( (4) )return29；
e1Se return 28；
}
case Jan：case Mar：case May：case Jul：case AUg：case Oct：
case Dec：retllrn 31；
case Apr：case Jun：Case Sep：case Nov：roturu30；
}
}；
private：
int year；
Month month；
}；
void main(){
Date day(2000,Feb)；
tout＜＜day． (5) ()；
}
正确答案：(1)enum (2)this-＞year (3)month (4)IsLeapYear() (5)Cacu lateDays
(1)enum (2)this-＞year (3)month (4)IsLeapYear() (5)Cacu lateDays 解析：程序的空(1)所在行的目的是定义一枚举类型用来表示一年12个月，所以空1应填上enum；在类Data中定义了两个私有变量year和m_month分
别用来存储年份和月份，在Data类的构造函数中，要求给出年份和月份来构造一个Data类的对象，因为构造函数中参数名称和私有变量的名称
相同，为了在构造函数中使用私有变量year，必须加上 this指针，所以空(2)应填上this-＞year。
函数CaculateDays用宋计算某一年某个月的天数，不论是否是闰年，除2月份以外，所有的大月都是31天，小月都是30天；如果是闰年，2
月份是29天，否则是28天。根据分析，空(3)应填上m month用来判断月份是大月、小月或者二月，空(4)用来判断是否是闰年，调用函数
IsLeapYear()即可得到结果。 -
第8题：
有以下程序:includeusingnamespacestd;staticintdays[]={31,28,31,30,31,30,31,31,30 有以下程序： #include ＜iostream＞ using namespace std； static int days[]={ 31，28，31，30，31，30，31，31，30，31，30，31 }； class date { private： int month，day，year； public： date( int m，int d，int y ) { month = m; day = d; year = y; } date() {} void disp() { cout＜＜year＜＜"-"＜＜month＜＜"-"＜＜day＜＜end1; } date operator+( iht day ) { date dt = * this; day += dt.day; while ( day ＞ days[ dt.month - 1 ] ) { day -= days[ dt.month - 1 ]; if ( ++dt.month == 13 ) { dt.month = 1; dt.year++; } } dt.day = day; return dt; } }; int main() { date dl( 6, 20, 2004 ), d2; d2 = dt + 20; d2.disp(); return 0; } 执行后的输出结果是( )。
A．2004-7-10
B．2004-6-20
C．2004-7-20
D．程序编译时出错
正确答案：A
解析：本题通过将“+”运算符重载为类date的成员函数实现简单的对象加法。类date中的“+”运算符重载函数中，将传入的实参值day，加到类date的私有成员变量day上，并实现变量month和year的相应变化，从而达到日期对象相加的目的。 -
第9题：
有以下程序includeusing namespace std;static int days []={31,28,31,30,31,30,3l,3 有以下程序 #include＜iostream＞ using namespace std； static int days []={31,28,31,30,31,30,3l，31，30,31，30,31}； class date { private： int month，day，year； public： date(int m，int d，int y) { month=m； day=d； year=y； } date() {} void disp() { cout＜＜year＜＜"-"＜＜month＜＜"-"＜＜day＜＜end1； } date operator+(int day) { date dt=*this； day+=dt.day； while(day＞days[dt.month－1]) { day-=days[dt.month-1]； if(++dt.month==13) { dt.month=1； dt.year++； } } dt.day=day； retrn dt； } }； int main() { date d1(6，20，2004)，d2； d2=d1+20； d2.disp()； return 0； } 执行后的输出结果是
A．2004-7-10
B．2004-6-20
C．2004-7-20
D．程序编译时出错
正确答案：A
解析：本题考核运算符的重载。本题通过将“+”运算符重载为类date的成员函数实现简单的对象加法， -
第10题：
在下向程序和横线处填上适当的内容,使程序执行后的输出结果为1／2005。 includeusing 在下向程序和横线处填上适当的内容，使程序执行后的输出结果为1/2005。
include ＜iostream＞
using namespace std;
class Date
{
public:
Date(int m=1,int y=0):month(m),year(y){}
void Print() {cout＜＜month＜＜"/"＜＜year＜＜end 1; }
【 】 operator+(eonst Date& d1, const Date& d2);
private:
int month,year;
};
【 】 operator+(const Date& d1, const Date& d2)
{
int year,month;
year=d1.year+d2.year;
month=d1. month+d2.month;
year+=(month-1 )/12;
month=(month-1 )% 12+1;
return Date(month,year);
}
void main()
Date d1 (3,2004),d2,d3(10);
d2=d3+d1;
d2,Print();
}
正确答案：friend Date Date
friend Date Date 解析：重载及友元的相关内容。 -
第11题：
有以下程序： Class Date {public： Date(int y，int m，int d)； {year＝y； month=m； day＝d；} Date(int y＝2000) {year＝y； month＝10； day=1；) Date(Date &D) {year＝d.year； month＝d.month； day＝d.day；} void print() {cout＜＜year＜＜“.”＜＜mo
A．2
B．3
C．4
D．5
正确答案：B
解析： 本题拷贝构造函数一共被调用了3次：第一次是在执行语句Date date3(date1)；时，用已经建立的对象date1对正在建立的对象date3进行初始化；第二次是在调用fun函数时，由于是传住调用，因此实参对象date3要对形参对象d进行初始化，第三次是在执行fun函数中的返回语句returntemp；时，系统用返回初始化一个匿名对象时使用了拷贝构造函数。 -
第12题：
以下程序的运行结果是()。includemain(){st,uct date {int year,month,day;}today; pri 以下程序的运行结果是( )。 #include ＜stdio．h＞ main() { st，uct date {int year，month，day；}today； printf("%d\n"，sizeof(struct date))； }
A．6
B．8
C．10
D．12
正确答案：A
解析：结构体变量的长度是其内部成员总长度之和，在本题中，structdate中包含year，month，day三个整型变量。通常一个整型变量占2个字节，因此，用sizeof求得该结构体变量的长度为6个字节。 -
第13题：
阅读以下说明和C++程序，将应填入(n)处的字句写在对应栏内。
【说明】
设计一个日期类Date包括年、月、日等私有数据成员。要求实现日期的基本运算，如某日期加上天数、某日期减去天数、两日期相差的天数等。
在Date类中设计如下重载运算符函数：
Date operator + (int days) : 返回某日期加上天数得到的日期。
Date operator - (int days) : 返回某日期减去天数得到的日期。
int operator - (Date&b): 返回两日期相差的天数。
【程序】
include＜iostream.h＞
int day tab[2][12]={{31,28,31,30,31,30,31,31,30,31,30,31},
{31,29,31,30,31,30,31,31,30,31,30,31}};
//day_tab二维数组存放各月天数，第一行对应非闰年，第二行对应闰年class Date
{
int year, month, day //年，月，日
int leap(int); //判断是否闰年
int dton(Date&)
Date ntod(int)
public:
Date() { }
Date (int y, int mint d) I year = y; month = m; day = d;}
void setday(intd){day = d;}
void setmonth(int m) {month = m;}
void setyear(int y) {year =y;}
int getday() {return day;}
int getmonth() {return month:}
int getyear() {return yea;}
Date operator + (int days) //+运算符重载函数
{
static Date date;
int number =(1)
date = ntod(number)
return date
}
Date operator - (int days) //-运算符重载函数
{
staffs Date date;
int number=(2);
number - = days;
date = ntod(number)
return date;
}
int operator - (Date &b) //-运算符重载函数
{
int days=(3);
return days;
}
void disp()
{
cout＜＜year＜＜"."＜＜month＜＜". "＜＜day＜＜endl;
}
};
int Date: :leap( int year)
if((4)) //是闰年
return 1; //不是闰年
else
return0:
}
int Date:: dton( Date &d) //求从公元0年0月0日到d日期的天数
{
inty,m,days =0;
for(y=1;y＜=d. year;y++)
if((5))days+ =366; //闰年时加366天
else days + = 365; //非闰年时加365天
for(m =0;m＜d. month-1;m++)
if((6))
days += day_tab[1] [m];
else
days +=day_tab[0] [m];
days + = d. day;
return days;
}
Date Date::ntod(intn) //将从元0年0月0日的天数转换成日期
{
int y=1,m = 1,d,rest = n,lp;
while(1)
{ if(leap(y))
if(rest＜= 366) break;
else rest - = 366;
else //非闰年
if(rest = 365 ) break;
else rest-=365;
正确答案：(1)dton(*this)+days (2)dton(*this) (3)dton(*this)-(dton(b)-1 (4)year%4 == 0 && year%1O0! = 0‖year%400 =0 (5)leap(y) (6)leap(d.year)
(1)dton(*this)+days (2)dton(*this) (3)dton(*this)-(dton(b)-1 (4)year%4 == 0 && year%1O0! = 0‖year%400 =0 (5)leap(y) (6)leap(d.year) 解析：本题程序中对运算符进行重载。其中运算符+表示某日期加上若干天后的日期，第一个“-”表示某日期减去若干天后的日期，第二个“-”表示两日期相差的天数。
函数leap()判断指定的年份是否为闰年，闰年的条件有两个，一是能被4整除，但不能被100整除，或者既能被100整除，又能被400整除，所以(4)空应填入“year%4=0&&year%1001=0"year%400=0”。
函数dton()将指定的日期转换成从0年0月0日起的天数，(5)、(6)空用来判断当前的年份是否为闰年，调用函数leap()，所以分别填入“leap(y)”和“leap(d.year)”。函数ntod将指定的0年0月0日起的天数转换成对应的日期。
“+”运算符重载时，先将当前日期转换为从0年0月0日起的天数，再加上要加的天数，最后将天数再转换成对应的日期。所以(1)空应填入“dton(*this)+days”。
第—个“-”运算符重载时，先将当前日期转换为从0年0月0日起的天数，再减去要减的天数，最后将天数再转换成对应的日期。而天数的相减由语句“number-=days”完成，所以(2)空应填入“dton(*this)”。
第二个“-”运算符重载时，先将两个比较的日期都转换为从0年0月 O日起的天数，再相减，所以(3)空应填入“dton(*this)-dton(b)-1”。 -
第14题：
使用VC6打开考生文件夹下的工程MyProj1。此工程包含千个源程序文件 MyMainl.cpp，其中定义了用于表示日期的类Date，但类Date的定义并不完整。请按要求完成下列操作，将类Date的定义补充完成：
①定义私有数据成员year、month和day分别用于表示年、月、日，它们都是int型的数据。请在注释“//**1**”之后添加适当的语句。
②完成默认构造函数Date的定义，使Date对象的默认值为：year=1，month=1， day=1，请在注释“//**2**”之后添加适当的语句。
③完成重载构造函数Date(int y, int m, int d)的定义，把数据成员year、month和day分别初始化为参数y、m和d的值，请在注释“//**3**”之后添加适当的语句。
④完成成员函数print的类外定义，使其以“年-月-日”的格式将Date对象的值输出到屏幕上。请在注释“//**4**”之后添加适当的语句。
注意：除在指定位置添加语句之外，请不要改动程序中的其他内容。
源程序文件MyMain1.cpp清单如下：
//MyMainl. cpp
include ＜iostream＞
using namespace std;
class Date
{
public:
//* * 2 * *
Date(int y, int m, int d)
{
//* * 3 * *
}
void print() const;
private:
//data member
//* * 1 * *
};
void Date: :print () const
{
//* * 4 * *
}
int main ( )
{
Date national_day(1949,10,1);
national_day.print();
return 0;
}
正确答案：①int year month day； ②Date(){year=1；month=1；day=1；} ③year=y；month=m；day=d； ④coutyear"年"month"月"day"日"end1；
①int year, month, day； ②Date(){year=1；month=1；day=1；} ③year=y；month=m；day=d； ④coutyear"年"month"月"day"日"end1； 解析：这是一道综合应用题，主要考核类的定义。
①定义私有数据成员year、month和day分别用于表示年、月、日，它们都是血型的数据，所以在第1处填入：“int year, month, day；”。
②完成默认构造函数Date的定义，使Date对象的默认值为：year=1，month=1，day=1。
根据以上要求可知，类Date的默认构造函数为：“Date(){year=1；month=1；day=1}：”。
③完成重载构造函数Date(int y, int m, int d)的定义，把数据成员year、month和day分别初始化为参数y、m和d的值。其实也就是给私有成员year、month和day赋值。
所以在第3处应填入：“year=y；month=m；day=d；”。
④完成成员函数print的类定义，使其以“年-月-日”的格式将Date对象的值输出到屏幕上。函数print的功能是输出Date对象的值，此处主要考核C++的格式化输出。
所以在第4处应该填入：“coutyear"年"month"月"day"日"end1；”。 -
第15题：
下列程序运行后的输出结果是( )。#include#includeusing namespace std;class Person{public:Person(string n):name(n) { cout<<'P'; }private:string name;};class Date{public:Date(int y=2012,int m=12,int d=21):year(y),month(m),day(d) { cout<<'D'; }
private:int year,month,day;};class Student:public Person{public:Student(string n,int y,int m,int d,char c):birthday(y,m,d),sex(c),Person(n) { cout<<'S'; }private:Date birthday;char sex;};int main(){Student stu1("Zhang",1990,10,1,'F');return 0}
A. S
B.PS
C.DPS
D.PDS
参考答案：D
-
第16题：
在下面程序的横线处填上适当的内容,使程序执行后的输出结果果为1／2005。 includeusing 在下面程序的横线处填上适当的内容，使程序执行后的输出结果果为1/2005。
include＜iostmam＞
using namespace std;
class Date
{
public:
Date(int m=1,int y=0):month(m),year(y){}
void Print(){cout＜＜month＜＜"/"＜＜year＜＜endl;}
operator+(const Date&d1．const Date& d2);
private:
int month,year;
};
operator+(const Date&d1,const Date &d2)
{
int year,month;
year=d1.year+d2.year;
month=d1.month+d2.month;
year+=(month-1)/12;
month=(month-1)%12+1;
return Date(month,year);
}
void main()
{
Date d1(3,2004),d2,d3(10);
d2=d3+d1；
d2.Print();
}
正确答案：friend Date Date
friend Date Date -
第17题：
下面结构体的定义语句中，不正确的是______。
A．structdate { int month； int day； int year； } Struct date datel；
B．stmctdate { intmonth； int day； int year； } datel；
C．struct { int month; int day; int year; } date 1;
D．#define DATE stmct date DATE { int month; int day; int year; }datel;
正确答案：A
-
第18题：
有以下程序includeusingnamespacestd;static int days []={31,28.31,30,31,30,31,31 有以下程序 #include ＜iostream＞ using namespace std; static int days []={31,28.31,30,31,30,31,31,30,31,30,31}; class date { private: int month, day, year: public: date (int m, int d, int y { month = m; day = d; year = y; } date{} {} void disp {) { cout ＜＜year＜＜" - "＜＜month＜＜ "- "＜＜day＜＜end1; } date operator+(int day) { date dt = *this: day += dt.day; while { day ＞ days[ dt.month - 1 ] ) { day -= tays[ dt.month - 1 ]; if ( ++dt.month == 13 { dt.month = 1; dt.yeare++; } } dr. day = day; return dt; } }; int main() { date d1( 6, 20, 2004 ), d2; d2.= d1 + 20; d2.disp (); return 0; } 执行后的输出结果是
A．2004-7-10
B．2004-6-20
C．2004-7-20
D．程序编译时出错
正确答案：A
解析：本题考核运算符的重载。本题通过将“+”运算符重载为类date的成员函数实现简单的对象加法。 -
第19题：
在下面程序的横线处填上适当的内容,使程序执行后的输出结果为1／2005。includeusing n 在下面程序的横线处填上适当的内容，使程序执行后的输出结果为1/2005。
include ＜iostream.h＞
using namespace std:
class Date
public:
Date (int m=1,int y=0):month(m .year(y}{}
void Print() {cout＜＜month＜＜"/"＜＜year＜＜end1;}
______operator+(const Date& d1,const Date&d2;
private:
int month year;
};
______operaror+(const Date&d1,const Date& d2)
int year, month;
year=d1.year+d2.year;
month=d1.month+d2.month;
year+=(month-1)/12;
month=(month-1)%12+l;
return Date{month, year}:
}
void main()
{
Date d1(3,2004),d2,d3(10);
d2=d3+d1;
d2.Print();
}
正确答案：friend Date； Date
friend Date； Date 解析：本题考核类与对象、运算符的重载。题中运算“+”重载函数中的参数表中有两个参数，所以是作为友元函数重载(因为“+”是一个二元运算符，作为成员函数重载时参数表中只有一个参数，对应于第二个参数，而第一个操作数就是对象本身，仅以this指针的形式隐藏在参数表中)，实现的功能是将参数对象中的成员变量month、year的进行对应相加，实现年月的相加-题中运算符重载函数的返回值的类型是类Date，所以第一个空格处填入"friend Date"。第二个空格处完善运算符重载函数的定义，缺少的是函数返回值的类型“Date” -
第20题：
有以下程序： classDate {public： Date(inty，intm，intd)； {year=Y； month=m； day=d；} Date(inty=2000) {year=y； month=10； day=1；} Date(Date＆d) {year=d．year； month=d．month； day=d．day；} voidprint（） {cout<<year<<"．"<<month<"．"<< day<<endl；} private： intyear，month，day；}； Datefun(Dated) {Datetemp； temp=d； returntemp；} intmain（） {Datedatel(2000，1，1)，date2(0，0，O)； Datedate3(date1)； date2=fun(date3)； return0；} 程序执行时，Date类的复制构造函数被调用的次数是（ ）。
A.2
B.3
C.4
D.5
正确答案：B
B。【解析】本题复制构造函数一共被调用了三次：第一次是在执行语句Datedate3(datel)；时，用已经建立的对象datel对正在建立的对象date3进行初始化；第二次是在调用fun函数时，由于是传值调用，因此实参对象date3要对形参对象d进行初始化；第三次是在执行fun函数中的返回语句returntemp；时，系统初始化一个匿名对象时使用了复制构造函数。 -
第21题：
阅读以下说明和C++程序，将应填入(n)处的字句写在对应栏内。
【说明】
下面程序的功能是计算并输出某年某月的天数，函数IsLeap Year()能够判断是否是闰年。
【C++程序】
include ＜ iostream ＞
using namespace std;
(1) Month {Jan, Feb, Mar, Apr, May, Jun, Jul, Aug, Sep, Oct, Nov, Dec };
class Date {
public:
Date( int year, Month m_ month) {
this→year = year;
if( (2) ) month: Jan;
else month = m_ month;
};
～Date(){};
bool IsLeap Year( ) {
return ((year%4= =0 &&year% 100 ! =0)｜｜ year%400= =0);
};
int CaculateDays( ) {
switch(m_month ) {
case (3) ;{
if (4) return 29;
else return 28;
}
case Jan: case Mar: case May: case Jul: case Aug: case Oct: case Dec: return 31;
case Apr: case Jun: case Sop: case Nov: return 30;
}
}
private:
int year;
Month month;
};
void main( ) {
Date day(2000,Feb);
cout ＜ ＜day. (5) ( );
}
正确答案：(1)enum
(1)enum 解析：枚举类型变量month定义，这里填入enum。 -
第22题：
下列程序的运行结果为()。includemain(){struct date {int year,month,day; }today; pr 下列程序的运行结果为( )。 #include＜stdio.h＞ main() { struct date {int year,month,day; }today; printf("%d\n",sizeof(struct date)); }
A．8
B．6
C．10
D．12
正确答案：B
解析：解答本题需要注意两个知识点；①结构体变量的长度是其内部成员长度的总和，本题中，structdate中包含year、month、day这3个整型变量，一个整型变量占2个字节：②sizeof是求所占字节数的运算符。 -
第23题：
有以下程序： classDate { public： Date(inty，intm，intd)； { year=Y： month=m； day=d； } Date(inty=2000) { year=y; month=10； day=1； } Date(Date＆d)
{ year=d．year； month=d．month； day=d．day； } voidprint（ ） { cout<<year<<"．"<(month<<"．"<<day<<endl； } private： intyear，month，day； }； Datefun(Dated) { Datetemp； temp=d； returntemp； } intmain（ ） { Datedatel(2000，1，1)，date2(0，0，0)； Datedate3(datel)； date2=fun(date3)； return0； } 程序执行时，Date类的拷贝构造函数被调用的次数是（ ）。
A.2
B.3
C.4
D.5
正确答案：B
B。【解析】本题考核拷贝构造函数。上述程序中，拷贝构造函数一共被调用了3次：第1次是在执行语句Datedate3(date1)时，用已经建立的对象date1对正在建立的对象date3进行初始化；第2次是在调用fun函数时，由于是传值调用，因此实参对象date3要对形参对象d进行初始化；第3次是在执行fun函数中的返回语句returntemp；时，系统初始化一个匿名对象时使用了拷贝构造函数。