【C/C++基础练习题】复习题卷一

定义变量时，变量的存储类说明符有的可以省略

在函数内，定义变量时储存类型符可以省略的是auto

增1和减1运算符只可以作用在在变量上，不可以用在表达式和常量上

在定义一个数组时，对其部分元素进行了初始化，没有初始化的元素的值不是无意义的

对象成员的表示方法与结构变量成员的表示方法相同

构造函数可以重载，析构函数不可以重载

友元函数是说明在类体内的非成员函数，它可以访问类中的所有成员。
派生类只继承基类中的公有成员和保护成员，而不继承私有成员。是×的

解析：私有成员也会继承，但是不能访问

虚函数是一种成员函数

含有纯虚函数的类称为抽象类

静态数据成员初始化不使用其构造函数
静态成员函数中不能直接引用非静态成员

扫描二维码关注公众号，回复： 15946399 查看本文章

---

1.静态成员是属于（） 的，它除了可以通过对象名来引用外，还可以使用 来引用（） 类，类名限定

2.已知：double dd[ ][3]={ {1.2, 2.4, 3.6}, {4.8, 5.2},{6.4}}; 这里dd是一个二维数组的数组
名，该数组共有（）个元素，每个元素的类型是（）。

答：要是说类型为 double 方括号那就是3个，要是说double就是9个
3.运行下面程序段后，k值为（） int k=1,n=263;do {k*=n%10;n/=10; } while(n);

答：k=k*（n/10）=1*3=3,n=n/10=26
k=3*6=18,n=26/10=2
k=18*2=36,n=2/10=0,    此时n=0，循环结束。输出k的值为36。

4.利用“对象名.成员变量”形式访问的对象成员仅限于被声明为（） 的成员；若要访问其他
成员变量，需要通过成员函数函数或（） 函数。

答：public 友元

5.已知a=4，b=6，c=8，d=9，则“（a++，b>a++&&c>d）？++d：a<b” 值为（0 ）

答：如果问号前面的表达式为真，则表示式的结果为++d的值，否则为a<b的值
首先看问号前面的表达式，是一个逗号表达式，首先a++先执行，++之后a的值为5 但是该表达式的结果取决于 b>a++&&c>d, 因为c等于8，d等于9，所以该表达式不成立，所以最后的结果是a < b的结果， 前面因为两次a++执行之后a的值为6 b的值为6,所以a < b的结果为0，整个表达式的结果为0

6.以下不正确的语句是（ B）。
A．if（x>y）；	B．if（x=y）&&（x!=0） x+=y；

7..在C++语言中，关于参数默认值的描述正确的是（B ）。
A．只能在函数定义时设置参数默认值
B．设置参数默认值时，应当从右向左设置
C．设置参数默认值时，应当全部设置
D．设置参数默认值后，调用函数不能再对参数赋值

8.如果x是整型变量，则合法的形式是( D)。
A．＆(x+5) B．*x C．&*x D．*&x

9.拷贝构造函数具有的下列特点中，（D ）是错误的。
A．如果一个类中没有定义拷贝构造函数时，系统将自动生成一个默认的
B．拷贝构造函数只有一个参数，并且是该类对象的引用
C．拷贝构造函数是一种成员函数
D．拷贝构造函数的名字不能用类名
10.关于友元的描述中，（ A ）是错误的。
A．友元函数是成员函数，它被说明在类体内
B．友元函数可直接访问类中的私有成员
C．友元函数破坏封装性，使用时尽量少用
D．友元类中的所有成员函数都是友元函数

11.下列虚基类的声明中，正确的是（ D ）。
A.class virtual B:public A B.virtual class B:public A
C.class B:public A virtual D.class B: virtual public A

12..要实现动态联编，必须通过（A ）调用虚函数。
A．对象指针 B．成员名限定 C．对象名 D．派生类名

13.下列关于抽象类的描述中，错误的是（ D ）。
A．抽象类中至少应该有一个纯虚函数 B．抽象类可以定义对象指针和对象引用
C．抽象类通常用作类族中最顶层的类 D．抽象类的派生类必定是具体类

14.下列描述中，（ D ）是抽象类的特征。
A．可以说明虚函数 B．可以进行构造函数重载
C．可以定义友元函数 D．不能说明其对象

---

 

#include <iostream.h>
#include <math.h>
class Complex
{p
ublic:
Complex(double r,double i);
~Complex();
double abscomplex();
private:
double real;
double imag;
};
Complex::Complex(double r,double i)
{
cout<<"Executing constructor..."<<endl;
real=r;
imag=i;
cout<<"real="<<real<<",imag="<<imag<<endl;
}C
omplex::~Complex()
{
cout<<"Executing destructor...";
cout<<"real="<<real<<",imag="<<imag <<endl;
}d
ouble Complex::abscomplex()
{
double t;
t=real*real+imag*imag;
return sqrt(t);
}i
nt main()
{
Complex A(3,4);
Complex B(6,8);
cout<<"|A|="<<A.abscomplex()<<endl;
cout<<"|B|="<<B.abscomplex()<<endl;
return 0;
}

程序运行结果：
Executing constructor...
real=3,imag=4
Executing constructor...
Real=6,imag=8
|A|=5
|B|=1

---

#include<iostream.h>
class Point
{p
ublic:
Point()
{
x=0;y=0;
cout<<" Call Default Constructor."<<endl;
cout<<x<<","<<y<<endl;
}
Point(int x1,int y1)
{
x=x1;
y=y1;
cout<< " Call Constructor."<<endl;
cout<<x<<","<<y<<endl;
}
~Point()
{
cout<<" Call Destructor."<<endl;
}
int Getx() {return x;}
int Gety() {return y;}
private:
int x,y;
};
void main()
{
cout<<"Object One:"<<endl;
Point *Ptr1=new Point;
delete Ptr1;
cout<<"Object Two:"<<endl;
Ptr1=new Point(1,2);
delete Ptr1;
}

Object One:

Call Default Constructor. 0,0 Call Destructor. Object Two:

(1分) (1分) (1分)

Call Default Constructor. 1,2 Call Destructor.

(1分) (1分) (1分

---

#include <iostream.h>
class BaseA1
{p
ublic:
BaseA1(int i)
{
cout<<"Constructing BaseA1 "<<endl;
x1=i;
} v
oid print()
{
cout<<"x1="<<x1<<endl;
}
protected:
int x1;
};
class BaseA2
{p
ublic:
BaseA2(int j)
{
cout<<"Constructing BaseA2 "<<endl;
x2=j;
} v
oid print()
{
cout<<"x2="<<x2<<endl;
}protected:
int x2;
};
class BaseA3
{p
ublic:
BaseA3()
{
cout<<"Constructing BaseA3"<<endl;
} v
oid print()
{
cout<<"Costructing BaseA3 No Value!"<<endl;
}
};
class MDerivedB: public BaseA2, public BaseA1, public BaseA3
{p
ublic:
MDerivedB(int a, int b, int c, int d):BaseA1(a),A2(d),
A1(c),BaseA2(b){}
void print()
{
BaseA1::print();
BaseA2::print();
BaseA3::print();
}
private:
BaseA1 A1;
BaseA2 A2;
BaseA3 A3;
};
void main()
{
MDerivedB obj(1,2,3,4);
obj.print();
}

程序运行结果：
Constructing BaseA2
Constructing BaseA1
Constructing BaseA3
Constructing BaseA1
Constructing BaseA2
Constructing BaseA3
x1=1
x2=2
Constructing BaseA3 No Value!
 

---

定义一个点类Point，其私有数据包含点的平面坐标x、y，利用有参构造函数实现对象坐标的确定。编写一友元函数Distance计算任意两点的距离。在主函数中定义两个点P1、P2，坐标分别为（0,0）和
（10,20），计算并输出这两个点的距离

#include <iostream.h>
#include <math.h>
class Point
{p
ublic:
Point(double x1,double y1)
{
x=x1;
y=y1;
} f
riend double Distance(Point &p1,Point &p2); //友元函数的声明
private:
double x,y;
};
double Distance(Point &p1,Point &p2) //普通函数作为友元函数
{
double deltax,deltay;
deltax=p1.x-p2.x; //访问私有成员
deltay=p1.y-p2.y; //访问私有成员
return sqrt(deltax*deltax+deltay*deltay);
}v
oid main()
{
Point p1(0,0);
Point p2(10,20);
cout<<"以上两给定点之间的距离是:"<<Distance(p1,p2)<<endl;
}