1.关于函数<返回值类型>,下列表述错误的是:
1 2 3 4 A <返回类型>中有可能包含关键字int B <返回类型>中有可能包含自定义标识符 C <返回类型>中有可能包含字符 * D <返回类型>中有可能包含 []
注意:这里的类型可以是预定义类型(如int),复合类型(如double*),用户自定义类型(如枚举类),若返回值只做更新(或设置)等操作,则该函数返回类型是void,函数类型和内置数组不能作为返回值类型
2.程序阅读
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 int main () { long a = 10 , b = 30 , l = 0 ; if (a % 2 == 0 ) a++; for (long m=a;m<=b;m+=2 ) if (fun (m)) { if (l++ % 10 == 0 ) cout << endl; cout << setw (5 ) << m; } return 0 ; } bool fun (long n) { int sqrtm = (int )sqrt (n); for (int i = 2 ; i <= sqrtm; i++) if (n % i == 0 ) return false ; return true ; }
3.假定一个类的构造函数为“A(int
i=4,int j=0){a=i;n=j;}”,则执行"A
x(1);"语句后,x.a和x.b的值分别为()
1 2 3 4 5 A 1 和0 B 1 和4 C 4 和0 D 4 和1
4.派生类构造函数的成员初始化列表中,不能包含的初始化项是:
A:
基类的构造函数
B:
基类的子对象 //B
C:
派生类的子对象
D:
派生类自身的数据成员
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 class A {protected : int n; public : A (); A (int temp):n (temp){} }; class B :class A { public : B (int temp){n=temp}; }; int main () { B (1 ); return ; }
5.多继承派生类构造函数构造对象时,(B)被最先调用
A:
派生类自己的构造函数
B:
虚基类的构造函数
C:
非虚基类的构造函数
D:
派生类中子对象类的构造函数
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 ;最后调用派生类构造函数 class Base1 { public : Base1 (int i){ a=i; cout<<"Constructing Base1 a=" <<a<<endl; } private : int a; }; class Base2 { public : Base1 (int i){ b=i; cout<<"Constructing Base1 b=" <<b<<endl; } private : int b; }; class Derivedclass :public Base1,public Base2{ public : Derivedclass (int i,int j,int k); private : int d; }; Derivedclass::Derivedclass (int i,int j,int k):Base2 (i),Base1 (j) { d=k; cout<<"Constructing Derivedcalss d=" <<d<<endl; } int main () { Derivedcalss x (4 ,5 ,6 ) ; return 0 ; }
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 例如; 带有基类的多层派生类构造函数的成员初始化列表中都要列出虚基类的构造函数,这样将对虚基类的子对象初始化1 次 class Base1 { public : Base1 (){cout<<"Constructing Base1" <<endl; } class Base2 { public : Base1 (){cout<<"Constructing Base2" <<endl; } class Derived1 :public Base2,virtual public Base1{ public : Derived1 (){cout<<"Constructing Derived1" <<endl; } class Derived2 :public Base2,virtual public Base1{ public : Derived1 (){cout<<"Constructing Derived2" <<endl; } class Derived3 :public Derived1,virtual public Derived2{ public : Derived1 (){cout<<"Constructing Derived3" <<endl; } int main () { Derived3 obj; return0; } Constructing Base1 Constructing Base2 Constructing Derived2 Constructing Base2 Constructing Derived1 Constructing Derived3
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 class X { 类名1 对象成员名1 ; 类名2 对象成员名2 ; … 类名n 对象成员名n; }; X∷X (参数表0 ):对象成员名1 (参数表1 ),对象成员名2 (参数表2 ),…,对象成员名n (参数表n) { 类X的构造函数体 }
6.程序阅读题
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 #include <iostream> using namespace std;class Base { public : Base (int i) { cout << i; } ~Base () { } }; class Base1 : virtual public Base { public : Base1 (int i, int j=0 ) : Base (j) { cout << i; } ~Base1 () {} }; class Base2 : virtual public Base { public : Base2 (int i, int j=0 ) : Base (j) { cout << i; } ~Base2 () {} }; class Derived : public Base2, public Base1 { public : Derived (int a, int b, int c, int d) : mem1 (a), mem2 (b), Base1 (c), Base2 (d), Base (a) { cout << b; } private : Base2 mem2; Base1 mem1; }; void main () { Derived objD (1 , 2 , 3 , 4 ) ; }
CSDN_1683445174034
7.不能在类声明中给成员赋值
1 2 3 4 5 6 7 8 9 class abc { private :char a='q' ; int b=33 ; public : … };
注意:声明了一个类便声明了一种类型,这时没有给它分配存储空间,只有定义了对象后,系统才为对象分配存储空间
8.数据成员是按照它们在类中声明的顺序进行初始化的,与它们在成员初始化列表中列出的顺序无关
1 2 3 4 5 6 7 8 9 10 11 12 #include <iostream> using namespace std; class D { int mem1; int mem2; public : D (int i):mem1 (i),mem2 (mem1+1 ) { cout<<"mem1: " <<mem1<<endl; cout<<"mem2: " <<mem2<<endl; } }; void main () { D d (15 ) ; }
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 #include <iostream> using namespace std; class D { int mem1; int mem2; public : D (int i):mem2 (i),mem1 (mem2+1 ) { cout<<"mem1: " <<mem1<<endl; cout<<"mem2:" <<mem2<<endl; } }; void main () { D d (15 ) ; } 1. mem1=mem2+1 =随机数2. mem2=i=15
9.在一个类中定义了全部是默认参数的构造函数后,
不能同时再声明无参数的默认构造函数,或其他重载构造函数。
1 2 3 4 5 6 7 Box (int h=10 ,int w=10 ,int len=10 ); Box ( ); Box box1;
10.对象数组
定义一维对象数组的格式如下:
类名 数组名[下标表达式];
例如:
exam ob[4];
说明:共建立了四个对象,即每一个数组元素是一个对象(即ob[0]、ob[1]、ob[2]、
ob[3]),共调用了4次构造函数。
1 2 3 4 5 6 7 8 9 10 11 12 13 #include <iostream.h> class exam { int x; public : exam ( ){ x=123 ;} exam (int n) { x=n;} int get_x () { return x; }}; int main () { exam ob[4 ]={55 ,66 }; int i; for (i=0 ;i<4 ;i++) cout<<ob[i].get_x ()<<' ' ; return 0 ; }
11.对象指针
声明对象指针的一般语法形式为:
类名* 对象指针名;
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 #include <iostream> using namespace std;class Rectangle { public : void setRec (int len,int wid) { length=len; width=wid; } void disp () { cout<<length<<" " <<width<<endl; } private : int length,width; }; int main () { Rectangle rec ; Rectangle *pr; rec.setRec (20 ,30 ); pr=&rec; pr->disp (); return 0 ; } 程序的运行结果如下: 20 30
12.静态数据成员的应用(在类Student中,声明数据成员count,希望每定义一个对象count加1,从而达到统计学生的总数的目的。)
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 #include <iostream.h> class Student { int count; public : Student ( ) { count++; } void print ( ) { cout<<"count= " << count <<endl; } }; main ( ) { int count=0 ; Student Stu1; Student Stu2; Stu1.print (); Stu2.print (); return 0 ; }
更改后为:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 #include <iostream.h> class Student { static int count; public : Student (){ count++;} void print () { cout<<"count= " << count <<endl; } }; int Student::count=0 ; int main ( ) { Student Stu1; Stu1.print (); Stu2.print (); return 0 ; }
静态数据成员属于类(准确地说,是属于类中一个对象集合),而不像普通数据成员那样属于某一对象,因此可以使用“类名∷”访问静态的数据成员。用类名访问静态数据成员的格式如下:
类名::静态数据成员名
静态数据成员初始化应在类外单独进行,而且应在定义对象之前进行。一般在主函数main
之前,类声明之后的特殊地带为它提供定义和初始化(如果末对静态数据成员赋初值,则编译系统会自动赋予初值0)
公有静态数据成员可以在对象定义之前被访问
公有静态数据成员可通过对象进行访问
13.调用拷贝构造函数的时机
下列情况中,哪种情况不会调用拷贝构造函数
1 2 3 MyClass a (b) ;或者 MyClass a=b;
程序中需要创建一个新的对象,并用另一个对象对它初始化
函数的参数为类的对象
函数的返回值是类的对象
14.下列关于对象的描述错误的是
15.程序阅读题
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 #include <iostream> using namespace std;class point { public : static int number; point (){number++;} ~point (){number--;} }; int point::number=0 ;void main () { point *ptr; point A,B; { point *ptr_point=new point[3 ]; ptr=ptr_point; } point C; delete []ptr; cout<<point::number<<endl; }
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 #include <iostream> using namespace std;class CT {public : CT () { cout << "Default constructor called" << endl; } CT (const CT &rhs) { cout << "Copy constructor called" << endl; } }; int main () { CT ct; CT *p; cout << "Step1" << endl; p = new CT; CT ct3 (*p) ; cout << "Step2" << endl; delete p; return 0 ; }
16.理解int(* p)[3]和int
*p[3]的意思
1 2 3 4 5 6 7 8 9 10 11 12 13 #include <iostream> using namespace std;void main () { int n[][3 ]={10 ,20 ,30 ,40 ,50 ,60 }; int (*p)[3 ]; p=n; cout<<p[0 ][0 ]<<"," <<*(p[0 ]+1 )<<"," <<(*p)[2 ]<<endl; }
17.程序阅读
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 #include <iostream> using namespace std;class Base { protected : Base () { cout << 'A' ; } Base (char c) { cout << c; } }; class Derived :public Base{ public : Derived (char c) { cout << c; } }; int main () { Derived d1 ('B' ) ; return 0 ; }
18.带有基类的多层派生类构造函数的成员初始化列表中都要列出虚基类的构造函数,这样将对虚基类的子对象初始化()
19.程序阅读
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 #include <iostream> using namespace std;class A { public : A (int i) :a (i) { cout << "A:constructor called." << endl; } ~A () { cout << "A:Destructor called." << endl; } void Print () { cout << a << endl; } int Geta () { return a; } private : int a; }; class B :public A{ public : B (int i = 0 , int j = 0 ) :A (i),a (j), b (i + j) { cout << "B:Constructor called." << endl; } ~B () { cout << "B:Destructor called." << endl; } void Print () { A::Print (); cout << b << ',' << a.Geta ()<< endl; } private : int b; A a; }; int main () { B b1 (8 ) , b2 (12 , 15 ) ; b1.Print (); b2.Print (); return 0 ; }
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 #include <iostream> using namespace std;class test { private : int x; public : test (int i=0 ):x (i){} virtual void fun1 () { cout << "text::x" << x << endl; } }; class ft :public test{ int y; public : void fun1 () { cout << "ft::y=" << y << endl; } ft (int i=2 ):test (i),y (i){} }; int main () { ft ft1 (3 ) ; void (test:: * p)(); p = test::fun1; (ft1.* p)(); return 0 ; }
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 #include <iostream> using namespace std;class A { public : virtual ~A () { cout << "A::~A() called" << endl; } }; class B :public A{ char * buf; public : B (int i) { buf = new char [i]; } virtual ~B () { delete []buf; cout << "B::~B() called" << endl; } }; void fun (A* a) { delete a; } int main () { A* a = new B (10 ); fun (a); return 0 ; }
20.运算符的使用
插入符<< 和 提取符>>
下列关于C++程序中使用提取符和插入符的输入/输出语句的描述中,错误的是(C
)
注意:操作数是指,参与运算操作的源数据,通常由指令的地址部分标识出来
提取符和插入符都是单目运算符
不能用浮点数操作的运算符
1.& 双目
2.%
3.== !=
类型转换运算符的使用
注意:类型转换运算符通常用于赋值中
21.返回类型
关于函数中的<返回类型>,下列表述中错误的是( B )
注意:<返回类型>又称函数类型,表示一个函数所计算(或运行)的结果值类型,这里的类型可以是预定义类型(如int),复合类型(如double*),用户定义类型(如枚举类),若返回值只做更新(或设置)等操作,则该函数返回值类型为void类型,函数类型和内置数组不能作为返回类型,但类类型可以被直接返回
22.虚函数
下列关于虚函数的说明中,正确的是( B )
注意:1.虚函数是被virtual关键字修饰的成员函数,且不能是静态成员函数
2.实现多态性之后不再定义声明,继承也为虚函数
3.动态联编只能通过指针或引用标识对象操作虚函数
23.函数模板,关于函数模板,描述错误的是(
)。
注意:成员函数模板当编译器遇到程序中对函数模板的调用是,由编译器 实例化为可执行的模板函数
24.已知fun(int)是类Test的公有成员函数,p是指向成员函数fun()的指针,采用(D)是正确的:
注意:首先fun是类Text的成员函数,因此在使用时需要加上类名,否则当类外有同名的fun函数的时候,p将指向类外的fun函数。其次,fun的函数名代表的是2函数的首地址,用首地址赋值给指针变量是正确的。而B,是缺少实参的函数调用
25.程序设计结果
1 2 3 4 5 6 7 8 9 10 11 12 13 14 using namespace std;#include <iostream> void main () { struct num { int x; int y; }sa[] = { {2 ,32 },{8 ,16 },{4 ,48 } }; struct num * p = sa + 1 ; int x; x = p->y / sa[0 ].x * ++p->x; cout << "x=" << x << "p->x=" << p->x << endl; }
1 2 3 4 5 6 7 8 9 10 11 12 13 14 #include <iostream.h> void main () { int x=3 ,y=3 ; switch (x%2 ) { case 1 : switch (y) { case 0 :cout<<"first\t" ; case 1 :cout<<"second\t" ;break ; default : cout<<"hellow\t" ; } case 2 :cout<<"third\n" ; }