C++复习.docx
《C++复习.docx》由会员分享,可在线阅读,更多相关《C++复习.docx(40页珍藏版)》请在冰豆网上搜索。
![C++复习.docx](https://file1.bdocx.com/fileroot1/2023-1/23/e8dad920-13b8-4fc4-b2b7-060358ad801d/e8dad920-13b8-4fc4-b2b7-060358ad801d1.gif)
C++复习
C++方向考察题库V2.0版(11级用)
第一部分:
C++基础(80分左右)
说明:
复习时请在机器上进行输入,并采用单步调试加深理解。
考试时程序基本不变,但其中的数字或字符会有改变,所以需完全弄懂,不能死记硬背。
一、读程序
1.#include
classSample
{
public:
Sample();
Sample(int);
~Sample();
voiddisplay();
protected:
intx;
};
Sample:
:
Sample()
{
x=0;
cout<<"constructingnormally\n";
}
Sample:
:
Sample(intm)
{
x=m;
cout<<"constructingwithanumber:
"<}
voidSample:
:
display()
{
cout<<"displayanumber:
"<}
Sample:
:
~Sample()
{
cout<<"destructing\n";
}
voidmain()
{
Sampleobj1;//调用无参构造函数
Sampleobj2(20);//调用有一个参数的构造函数
obj1.display();//调用成员函数
obj2.display();
}//程序结束前调用析构函数
考查内容:
构造函数和析构函数
constructingnormallyconstructingwithanumber。
20displayanumber0displayanumber20.destructingdestructing
2.#include
classMyClass{
public:
intnumber;
voidset(inti);
};
intnumber=3;
voidMyClass:
:
set(inti)
{
number=i;
}
voidmain()
{
MyClassmy1;//调用默认构造函数
intnumber=10;//定义普通局部变量
my1.set(5);//调用成员函数,给成员变量赋值
cout<my1.set(number);
cout<my1.set(:
:
number);//:
:
numer表示全局变量
cout<}
考查内容:
普通局部变量、成员变量、全局变量的区别
5103
3.#include
#include
classstudentid{
public:
studentid(intid=0){
value=id;
cout<<”Assigningstudentid”<}
~studentid(){
cout<<”destructingid”<}
protected:
intvalue;
};
classstudent
{
public:
student(char*pname=”noname”,intssid=0):
id(ssid)
{
cout<<”constructingstudent”<strcpy(name,pname);
name[sizeof(name)-1]=’\0’;
}
~student()
{
cout<<”destructingstudent”<}
protected:
charname[20];
studentidid;
};
voidmain(){
students(“randy”,9818);
}
assigningstudentid9818
constructingstudentrandy
destructionstudent
destructingid9818
考查要点:
类的成员变量为对象时,构造函数析构函数的调用顺序
4.#includeclassA
{public:
intx;
A(inti){x=i;}
voidfun1(intj)
{x+=j;
cout<<”fun1:
”<}
voidfun2(intj)
{x+=j;
cout<<”fun2:
”<}
};
voidmain()
{Ac1
(2),c2(5);
void(A:
:
*pfun)(int)=A:
:
fun1;定义了pfun让该指针指向fun1
(c1.*pfun)(5);x=2,j=5.这里输出的就是2+5=7
pfun=A:
:
fun2;让指针指向fun2
(c2.*pfun)(10);x=5,j=10.输出的值就是5+10=15
}
输出的答案是7,15
考查要点:
指向类成员函数的指针的使用
5.#include
classR
{
public:
R(intr1,intr2){R1=r1;R2=r2;}
voidprint();
voidprint()const;
private:
intR1,R2;
};
voidR:
:
print()
{
cout<"<}
voidR:
:
print()const
{
cout<}
voidmain(){
Ra(5,4);
a.print();
constRb(20,52);
b.print();
}
5:
420;52
考查要点:
普通成员函数与常成员函数的区别
6.没看懂
#include
classOld{
public:
Old(inti=0)
{o=i;}
voidPrint()const
{cout<private:
into;
};
classNew{
public:
New(){
n=0;
cout<<"D-Constructor.\n";
}
New(inti,intj):
d(i){
n=j;
cout<<"Constructor.\n";
}
voidPrint()const{
d.Print();
cout<}
~New()
{cout<<"Destructor."<private:
intn;
Oldd;
};
Newm1(8,1);
voidfun(New&m)
{
Newm0;
m.Print();
m0.Print();
}
intmain(){
constNewm2(6,2);
staticNewm3(3,3);
New*p=newNew(5,4);
fun(m3);
m1.Print();
m2.Print();
(*p).Print();
deletep;
}
运行结果:
Constructor.
Constructor.
Constructor.
Constructor.
D-Constructor.
3,3
0,0
Destructor.0
8,1
6,2
5,4
Destructor.4
Destructor.3
Destructor.2
Destructor.1
考查要点:
常对象、静态对象、指向对象的指针的用法
7.#include
classX
{
friendclassY;
public:
voidSet(inti)
{x=i;}
voidDisplay()
{cout<<”x=”<private:
intx;
staticinty;
};
classY{
public:
Y(inti,intj);
voidDisplay();
private:
Xa;
};
intX:
:
y=10;
Y:
:
Y(inti,intj){a.x=i;X:
:
y=j;}
voidY:
:
Display()
{cout<<”x=”<:
y<
voidmain( ){
Xb;
b.Set(15);
b.Display();
Yc(16,19);
c.Display();
b.Display();}
X=15,y=10
X=16,y=19
X=15,y=19
考查内容:
友元类,友元类的所有函数都是友元函数
8.#include
#include
classassistant;
classprofessor
{
charpName[40];
intpAge;
longpPhone;
public:
professor(char*pn,intpa,longpp)
{
strcpy(pName,pn);
pAge=pa;
pPhone=pp;
}
voiddisplay(assistant&a);
};
classassistant
{
charaName[40];
intaAge;
longaPhone;
public:
assistant(char*an,intaa,longap)
{
strcpy(aName,an);
aAge=aa;
aPhone=ap;
}
friendvoidprofessor:
:
display(assistant&a);
};
voidprofessor:
:
display(assistant&a){
cout<<”\t\tName\t\tAge\t\tTelephone”<cout<<”Professor”;
cout<<”\t”<cout<<”Assistant”;
cout<<”\t”<}
intmain( )
{
professorp1(“Joseph”,52,1335);
assistanta1(“Jack”,25,8322);
p1.display(a1);
}
NameAgeTelephone
ProfessorJoseph521335
AssistantJack258322
考查内容:
类成员函数作为友元,引用作参数
9.#include
classB;
classA
{
inti;
public:
intset(B&);
intget(){returni;}
A(intx){i=x;}
};
classB
{
inti;
public:
B(intx){i=x;}
friendA;
};
intA:
:
set(B&b){returni=b.i;}
intmain(){
Aa
(1);
Bb
(2);
cout<a.set(b);
cout<}
1,2
考查内容:
友元类
10.#include
classTest1{
public:
Test1(){cout<<"CallCommonConstructor!
"<Test1(constTest1&a)
{cout<<"CallCopyConstructor!
"<~Test1(){cout<<"CallDestructor!
"<};
Test1fun1(Test1a);//对象名作形参,返回对象
Test1&fun2(Test1&a);//对象引用作形参,返回形参
voidmain(){
Test1a;//调用构造函数(分配空间后初始化)
cout<<"CallByValue"<fun1(a);//实参和形参都为对象,会调用拷贝构造函数;返回值为对象,也会调用拷贝构造函数
cout<<"CallByReference"<fun2(a);//实参为对象,形参为引用
}//程序结束,调用析构函数
Test1fun1(Test1a)
{
cout<<"Returnobject"<returna;
}
Test1&fun2(Test1&a)
{
cout<<"ReturnReference"<returna;
}
CallCommonConstruction!
CallByValue
CallCopyConstructor!
Returnobject
CallCopyConstructor!
CallDestructor!
CallDestructor!
//这两次调用是因为使用了两次拷贝构造函数
CallByReference
ReturnReference
CallDestructor!
//这次调用是因为使用的非默认构造函数
考察内容:
1)形参为对象和返回值为对象时,调用拷贝构造函数
2)形参为引用,只是给实参起一个别名
11.#include
classB{
intm;
public:
B(inti=0)
{m=i;cout<<"Constructorcalled."<voidPrint()const{cout<~B(){cout<<"Destructorcalled."<};
voidfun(constB&c)//形参为引用
{
c.Print();
}
voidmain(){
fun(10);//类型转换:
从普通变量到类对象,要调用带一个参数的构造函数
}
Constructorcalled.19
10
Constructorcalled.10
考查内容:
1)形参为引用
2)实参为普通变量,形参为类对象(或类引用),要调用带一个参数的构造函数
voidmain(){
int&rp=fun();//定义函数的引用
int*p=&rp;//定义指针,赋值为rp的指针
cout<<*p<//上一条语句的调用相当于:
cout<//因为返回值为引用,又相当于cout<