2007-2013全国计算机二级C++等级考试真题及答案

2007年9全国计算机等级考试二级笔试试卷

一、选择题（每小题2分，共70分）

（11）在函数中，可以用auto,extem,register,和static这四个关键字中的一个来说明变量的存储类型，如果不说明存储类型，则默认的存储类型是 A

A auto B extem C register D static （12）对于一个类定义，下列叙述中错误的是 B

A 如果没有定义拷贝构造函数，编译器将生成一个拷贝构造函数

B 如果没有定义缺省的构造函数，编译器将一定生成一个缺省的构造函数 C 如果没有定义构造函数，编译器将生成一个缺省的构造函数和一个拷贝构造函数 D 如果已经定义了构造函数和拷贝构造函数，编译器不会生成任何构造函数 （13）如果派生类以public方式继承基类，则原基类的protected成员和public成员在派生类中的访问类型分别是 D

A public和 public B public和protected

C protected 和 public D protected 和 protected （14）下列运算符函数中肯定不属于类FunNumber的成员函数的是 D A int operator-(FunNumber) B FunNumber operator-() C FunNumber operator-(int) D int operator – (FunNumber) （15）C++中的模板包括 C

A 对象模板和函数模板 B 对象模板和类模板 C 函数模板和类模板 D 变量模板和对象模板 (16)如果调用C++流进行输入输出，下面的叙述中正确的是 A

A 只能借助于流对象进行输入输出 B 只能进行格式化输入输出

C 只能借助于cin和cout进行输入输出 D 只能使用运算符 》和《 进行输入输出 （17）下列符号中不属于C++关键字的是 D

A friend B namespace C continue D byte （18）下列各组的量申明中，含义相同的一组是 B

A unsigned long int 和 long B signed short int 和 short B unsigned short 和 short D short int 和int (19) 必须用一对打括号括起来的程序段是 D

A switch 语句中的case标号语句 B if 语句的分支 C 循环语句的循环体 D 函数的函数体

（20）语句的int*p=&k定义于指针P，于这个语句等效的语句序列是 A A int*p;p=&k B int*p;p=k C int*p;*p=&k D int*p;*p=k (21)关于函数重载，下列叙述中错误的是 C A 重载函数的函数名必须相同

B 重载函数必须在函数个数或类型上有所不同 C 重载函数的返回值类型必须相同 D 重载函数的函数体可以有所不同 （22）有如下头文件

1

Int f1();

Static int f2(); Class MA{ Public

Int f3();

Static int f4();(静态函数) };

在所描述的函数中，具有隐含的this指针的是 C

A f1 B f2 C f3 D f4 （23）派生类的成员函数不能访问基类的 C

A 共有成员和保护成员 B 共有成员 C 私有成员 D 保护成员 （24）下列关于运算符重载的描述中，正确的是 A

A 运算符重载为成员函数时，若参数表中五参数，重载的是一元运算符 B 一元运算符只能作为成员函数重载

C 二元运算符重载为非成员函数时，参数表中有一个参数 D C++中可以重载所有的运算符

（25）下列关于类模板的模板参数的叙述中，错误的是 D A 模板参数可以作为数据成员的类型 B 模板参数可以作为成员函数的返回类型 C 模板参数可以作为成员函数的参数类型

D 模板函数不能作为成员函数的局部变量的类型 （26）已知一程序运行后执行的第一个输出操作是 B Cout<

A 1234 B ******1234 C **********1234 D 1234****** (27)有如下程序

#include Using namespace std; Class myclass{ Public:

MyClass(){++count;} ~MyClass(){--count;}

Static int getcount(){return count;} Private

Static int count; };

Int MyClass::count=0; Int main(){

Myclass obj;

Cout<

MyClass*ptr=new MyClass; Cout<

2

Delete ptr;

Cout<

程序的输出结果是 A

A 121 B 232 C 221 D 122

程序的输出结果是 C

A val=10 const:val=20 B const:val=10 const:val=20 C const:val=10 val=20 D val=10 val=20 (29)有如下程序

#include Using namespace std; Class part{ Public;

Part(int x=(\\):val(x){cout<

Class whole{ Public;

Whole(int x,int y,int z=0):p2(x),p1(y),val(z){cout<

Part p1,p2; Int val; };

Int maint{

Whole obj(1,2,3);

3

Resturn(); }

程序输出的结果是 D

A 123321 B 213312 C 213 (30) 有如下程序：

#include Using namespace std; Class base{ Public:

Base(int x=0){cout<

Class derived : public base{ Public:

Derivedrin(x=y){cout<

Base val; };

Int main(){

Derived d(!); Return(); }

程序的输出结果是 C

A 0 B 1 C 01 D 001 （31）若有如下类定义： Classs B {

Void fun1(){} Protected;

Double varl; Public:

Void fun2(){} };

Class D:public B{ Protected;

Void fun3(){} };

已知obj是类D的对象，下列语句中不违反成员访问控制的权限的是 C

A obj.fun1(); B obj.var1; C obj.fun2(); D obj.fun3(); (32)有如下程序：

#include Using namespace sid; Class base{ Public;

Void output(){cout<<1;}

Virtual void print() {cout<

4

};

Class derived:public base{ Public:

Void output(){cout<<2;} Void print(){cout<<’D’;} };

Int main()

Base * passnew derived; Ptr->output(); Ptr->print(); Delete ptr; Return(); }

程序的输出结果是 D

A 1B B 1D C 2B D 2D

33.下列是重载乘法运算的函数原型声明，其中错误的是 A A myclass operator*(double,double); B myclass operator*(double,myclass); C myclass operator*(myclass,double); D myclass operator*( myclass , myclass);

*是二元运算符，而且标准库里面已经有double*double的运算符定义，返回值为double，所以A的重载是错误的 34.A

(35) 有如下程序：

#include using namespace std; class B{ public:

virtual void show(){cout<<\ };

class D:public B { public:

void show(){cout<<\ };

5

void fun1(B*ptr){ptr->show();} void fun2(B &ref){ref.show();} void fun3(B b){b.show();} void main(){

B b,*p=new D; D d; fun1(p); fun2(b); fun3(d); }

程序的输出结果是 D

A DBD B BBD C DBB D Dbb 二、填空题（每空2分，共三十分）

(6).在有定义语句：int a=3,b=2,c=1;则表达式a

For (int j=I;j<=I;j++) For (int j=I;j<=I;j++) Sum++;

(8).已知有函数f的定义如下： Int f(){

Static int -6; s-2; return s }

则在某程序中第二次执行函数用语句f();时,函数f的返回值是_____. (9)已知如下程序得输出结果时23，请将划线处缺失得部分补充完整。 #include Using namespace std; Class myclass{ Public:

Void print() cout{cout<<23;} }

Int main(){

Myclass*p=new myclass(); ______print(); Return(); Class sample{ Public:

Sample(){} _________ }

6

(14)请将如下程序补充完整，使得输出结果为bbaa #include Using namespace std; Class A { Public:

_____{cout<<”aa”;} };

Class B :public A{ Public:

~B(){cout<<”bb”;} };

Int main (){

B*p=new B; Delete p; Return(); }

(15)请将下列栈类stack补充完整 Class stack{ Private;

Int plist[100]; //int 数组，用于存放栈的元素 Int top; //栈顶元素（数组下标） Public:

Stack():top(0){}

Void push(sons int &item); //新元素item压入栈 Int pop(void); //将栈顶元素弹出栈 };

Void stack::pbsh(const int &item){

If (top ==99) //如果栈满，程序结束 Exit(1);

Top++; //栈顶指针增1 ___【15】____; }

7

Int stack::pop(){

If (top<0) //如果栈空，程序结束 Exit(1);

Return plish[top--]; } 参考答案

6.2 7.6 8.4 9.(*p) 10.ABBA 11.void Base::fun() 12.virtual display()==0; 14.-A() 15.pList[top]=item

2008年9月计算机等级考试

一、选择题（每小题2分，共70分）

（11）在下列原型所示的 C++函数中，按“传值”方式传递参数的是（A）。 A）void f1(int x); B）void f2(int*x); C）void f3(const int*x); D）void f4(int&x);

（12）在 C++中，编译系统自动为一个类生成缺省构造函数的条件是（A）。 A）该类没有定义任何有参构造函数 B）该类没有定义任何无参构造函数 C）该类没有定义任何构造函数 D）该类没有定义任何成员函数

（13）在一个派生类的成员函数中，试图调用其基类的成员函数“void f();”，但无法通过编译。这说明（C）。

A）f()是基类的私有成员 C）派生类的继承方式为私有 B）f()是基类的保护成员 D）派生类的继承方式为保护 （14）下列关于运算符重载的叙述中，错误的是（B）。 A）有的运算符可以作为非成员函数重载

B）所有的运算符都可以通过重载而被赋予新的含义 C）不得为重载的运算符函数的参数设置默认值 D）有的运算符只能作为成员函数重载

（15）下列关于模板的叙述中，错误的是（D）。

A）调用模版函数时，在一定条件下可以省略模板实参 B）可以用 int、double 这样的类型修饰符来声明模版参数

C）模板声明中的关键字 class 都可以用关键字 typename 替代 D）模板的形参表中可以有多个参数

（16）要利用 C++流进行文件操作，必须在程序中包含的头文件是（B）。 A）iostream B）fstream C）strstream D）iomanip （17）下列字符串中不能作为 C++标识符使用的是（B）。 A）WHILE B）user C）_lvar D）9stars （18）下列语句中错误的是（D）。 A）const int a; B）const int a=10; C）const int*point=0; D）const int*point=new int(10);

（19）有如下程序： #include using namespace std; int main(){ int sum;

8

for(int i=0; i<6; i+=3){ sum=i;

for(int j = i; j<6; j++)sum+=j; }

cout<

运行时的输出结果是（A）。 A）3 B）10 C）12 D）15 （20）下列语句中，正确的是（D）。

A）char*myString=\ B）char myString=\

C）char myString[11]=\ D）char myString[12]=\

（21）若已经声明了函数原型“void fun(int a, double b=0.0）;”，则下列重载函数声明中正确的是（C）。

A）void fun(int a=90, double b=0.0); B）int fun(int a, double B);

C）void fun(double a, int B); D）bool fun(int a, double b = 0.0); （22）有如下程序： #include using namespace std; class Sample{ public:

Sample(){}

~Sample(){cout<<'*';} };

int main(){

Sample temp[2], *pTemp[2]; return 0; }

执行这个程序输出星号（*）的个数为（B）。 A）1 B）2 C）3 D）4 （23）下列选项中，与实现运行时多态性无关的是（A）。 A）重载函数 B）虚函数 C）指针 D）引用 （24）下列运算符函数中，肯定不属于类 Value 的成员函数的是（B）。 A）Value operator+(Value); B）Value operator-(Value, Value); C）Value operator*(int); D）Value operator/(Value); （25）下列模板声明中，有语法错误的是（D）。 A）templateT fun(T x){return x;}

B）templateT fun(T x, int n){return x*n;} C）templateT fun(T *p){return *p;} D）templateT classA{T n;};

（26）在语句“cout<<'A';”中，cout 是（B）。 A）类名 B)对象名 C）函数名 D)C++的关键字 （27）有如下程序： #include

9

using namespace std； class MyClass{ public:

MyClass(int i=0){cout<<1;}

MyClass(const MyClass&x){cout<<2;} MyClass& operator=(const MyClass&x) {cout<<3; return*this;} ~MyClass(){cout<<4;} };

int main(){

MyClass obj1(1),obj2(2),obj3(obj1); return 0: }

运行时的输出结果是（A）。 A）112444 B）11114444 C）121444 D）11314444 （28）有如下程序： #include using namespace std; class MyClass{ public:

MyClass(int x):val(x){} void Set(int x){val=x;}

void Print()const{cout<<\private: int val; };

int main(){

const MyClass obj1(10); MyClass obj2(20); obj1.Print(); //语句 1 obj2.Print(); //语句 2 obj1.Set(20); //语句 3 obj2.Set(30); //语句 4 return 0; }

其主函数中错误的语句是（C）。 A）语句 1 B）语句 2 C）语句 3 D）语句 4 （29）在类声明中，紧跟在“public:”后声明的成员的访问权限是（A）。 A）私有 B）公有 C）保护 D）默认

（30）对于通过公有继承定义的派生类，若其成员函数可以直接访问基类的某个成员，说明该基类成员的访问权限是（D）。 A）公有或私有 B）私有 C）保护或私有 D）公有或保护

（31）定义派生类时，若不使用关键字显式地规定采用何种继承方式，则默认方式为（A）。 A）私有继承 B）非私有继承 C）保护继承 D）公有继承

10

（32）建立一个有成员对象的派生类对象时，各构造函数体的执行次序为（C）。 A）派生类、成员对象类、基类 B）成员对象类、基类、派生类 C）基类、成员对象类、派生类 D）基类、派生类、成员对象类

（33）如果表达式 a>=b 中的“>=”是作为非成员函数重载的运算符，则可以等效地表示为（A）。

A）a.operator>=(b) B）b.operatotr>=(a) C）operator>=(a,b) ）operator>=(b,a) （34）当使用 ofstream 流类定义一个流对象并打开一个磁盘文件时，文件的默认打开方式为（B）。 A）ios base::in B）ios_base::binary C）ios_base::in|ios_base::out D）ios_base::out （35）在一个抽象类中，一定包含有（C）。

A）虚函数 B）纯虚函数 C）模板函数 D）重载函数 二、填空题（每空2分，共30分）

（6）当使用关键字__void__作为函数返回类型时，该函数不返回任何值。

（7）已知数组 a 中有 n 个元素，下列语句将数组 a 中从下标 x1 开始的 k 个元素移动到从下标 x2 开始的 k 个元素中，其中 0<=x1=x1; i--) a[_x2+k-1_]=a[i]; （8）有如下程序： #include using namespace std;

int fun1(int x) {return++x;} int fun2(int &x) {return++x;} int main(){ int x=1,y=2; y=fun 1(fun2(x)); cout<

程序的输出结果是_2,3_。 （9）有如下程序： #include using namespace std; class pumpkin{ public:

pumpkin(){++count;} ~pumpkin(){--count;} static void total_count(){

cout<

private:

static int count; };

int pumpkin::count=0; int main(){

11

pumpkin pl[10];

pumpkin::total_count(); return 0; }

这个程序的输出结果是__10pumpkin(s)__。 （10）有如下递归函数： int Fun(int n){ if(n<=1) return 1;

__else return n*Fun(n-1);__ }

请补充完整，使得函数 Fun 能够正确计算形参 n 的阶乘。 （11）请在下列程序中的空格处填写正确的语句： class Sample{ public:

Sample(){} ~Sample(){}

void SetData(int data)

{ //将 Sample 类成员变量 data 设置成形参的值 __Sample::data=data__ //注意形参与成员同名 }

private: int data; };

（12）有如下类定义，请将Sample类的拷贝构造函数补充完整。 class Sample{ public: Sample(){)

~Sample() {if(p) delete p;) Sample (const Sample& s){ __p=new int;*p=s.*p__ }

void SetData(int data) {p=new int(data);} private: int*p; };

（13）重载加法运算符“+”，其函数名是__operator +_。 （14）有如下程序： #include using namespace std; class Wages{ //\工资\类 double base; //基本工资 double bonus; //奖金 double tax; //税金 public:

Wages(double CBase, double CBonus,

12

double CTax)

:base(CBase), bonus(CBonus), tax(CTax){}

double getPay()const; //返回应付工资额

Wages operator+(Wages w)const; //重载加法 };

double Wages::getPay()const {return base+bonus-tax;}

Wages Wages::operator+(Wages w)const

{ return Wages(base+w.base, bonus+w.bonus, tax+w.tax); }

int main(){

Wages wl(2000,500,100),w2(5000,1000,300); cout<<(wl+w2).getPay()<

}（15）有如下程序： #include using namespace std; class Pet{

char name[10]; public:

Pet(char*name){strcpy(this->name, name);} const char*getName()const {return name;} virtual void call()const=0; };

class Dog: public Pet{ public:

Dog(char*name):Pet(name){}

void call()const{cout<<\汪汪叫\};

class Cat:public Pet{ public:

Cat(char*name):Pet(name){}

void call()const{cout<<\喵喵叫\};

int main(){

Pet *pet1=new Dog(\哈克\ *pet2=new Cat(\吉米\cout<getName(); pet1->call(); cout<

cout<getName(); pet2->call();

13

cout<

程序的输出结果是__哈克汪汪叫__ __吉米喵喵叫__

2008年9月二级 C++笔试试卷参考答案 二、填空题 （6）void （7）X2+k-1 （8）2,3 （9）10pumpkin(s) （10）else return n*Fun(n-1); （11）Sample::data （12）p=new int; *p=s.*p; （13）operator + （14）8100

2009年9月全国计算机二级笔试C++

一、选择题（1-10,21-40每题2分，11-20每题1分）

（11）已知函数FA调用FB，若要把这两个函数定义在同一个文件中，则 D A）FA必须定义在FB之前 B）FB必须定义在FA之前

C）若FA定义在FB之后，则FA的原型必须出现在FB的定义之前 D）若FB定义在FA之后，则FB的原型必须出现在FA的定义之前 （12）有如下两个类定义 C class AA{}; class BB{ AA v1,*v2; BB v3; int *v4; };

其中有一个成员变量的定义是错误的，这个变量是 A）v1 B）v2 C）v3 D）v4

由于AA和BB都是类的定义，在类定义中无法声明一个自己的对象，所以在BB的类定义中，企图声明一个BB类的对象，是非法的。 （13）有如下类定义： B class XX{ int xdata; public:

XX(int n=0) : xdata (n) { } };

class YY : public XX{ int ydata; public:

YY(int m=0, int n=0) : XX(m), ydata(n) { } };

YY类的对象包含的数据成员的个数是 A）1 B）2 C）3 D）4

（14）下列有关运算符函数的描述中，错误的是 C A）运算符函数的名称总是以operator为前缀

14

B）运算符函数的参数可以是对象

C）运算符函数只能定义为类的成员函数(友元函数)

D）在表达式中使用重载的运算符相当于调用运算符重载函数 （15）下列关于模板形参的描述中，错误的是 B A）模板形参表必须在关键字template之后 B）模板形参表必须用括弧( )括起来 C）可以用class修饰模板形参

D）可以用typename修饰模板形参

（16）在下列枚举符号中，用来表示“相对于当前位置”文件定位方式的是 A

A）ios_base::cur B）ios_base::beg C）ios_base::out D）ios_base::end （17）下列字符串可以用作C++标识符的是 D

A）2009var B）goto C）test - 2009 D）_123 （18）下列枚举类型的定义中，包含枚举值3的是 A A）enum test {RED, YELLOW, BLUE, BLACK}; B）enum test {RED, YELLOW=4, BLUE, BLACK}; C）enum test {RED=-1, YELLOW,BLUE, BLACK}; D）enum test {RED, YELLOW=6, BLUE, BLACK}; （19）有如下程序段： C int i=1; while (1) { i++;

if(i == 10) break;

if(i%2 == 0) cout << '*'; }

执行这个程序段输出字符*的个数是

A）10 B）3 C）4 D）5 （20）已知数组arr的定义如下： D int arr[5] = {1,2,3,4,5};

下列语句中输出结果不是2的是 A）cout << *arr+1 <

（21）计算斐波那契数列第n项的函数定义如下：B Int fib(int n){

if (n == 0) return 1; else if (n == 1) return 2;

else return fib(n-1)+fib(n-2); }

若执行函数调用表达式fib(2)，函数fib被调用的次数是 A）1 B）2 C）3 D）4

（22）Sample是一个类，执行下面语句后，调用Sample类的构造函数的次数是 D Sample a[2], *p = new Sample;

A）0 B）1 C）2 D）3 （23）下列关于虚基类的描述中，错误的是 C

A）使用虚基类可以消除由多继承产生的二义性

15

B）构造派生类对象时，虚基类的构造函数只被调用一次 C）声明“class B : virtual public A”说明类B为虚基类 D）建立派生类对象时，首先调用虚基类的构造函数

（24）将运算符重载为类成员函数时，其参数表中没有参数，说明该运算是 B

A）不合法的运算符 B）一元运算符 C）无操作数的运算符 D）二元运算符 （25）有如下模板声明： D

template class A; 下列声明中，与上述声明不等价的是 A）template class A; B）template class A; C）template class A; D）template class A; （26）下列关于C++流的描述中，错误的是 A

A）cout>>'A'表达式可输出字符A B）eof()函数可以检测是否到达文件尾 C）对磁盘文件进行流操作时，必须包含头文件fstream

D）以ios_base::out模式打开的文件不存在时，将自动建立一个新文件 27）有如下程序：C #include using namespace std; class Toy{ public:

Toy(char* _n) { strcpy (name,_n); count++;} ~Toy(){ count--; }

char* GetName(){ return name; } static int getCount(){ return count; } private:

char name[10]; static int count; };

int Toy::count=0; int mail(){

Toy t1(“Snoopy”),t2(“Mickey”),t3(“Barbie”); cout<

运行时的输出结果是

A）1 B）2 C）3 D）运行时出错

（28）有如下程序 B #include using namespace std; class A { public:

A(int i):rl(i) { }

void print( ) {cout<<'e'<

void print( ) const {cout<<'C'<

16

private: int rl; };

int main(){

A al(2); const A a2(4); al.print(); a2.print(); return 0; }

运行时的输出结果是

A）运行时出错 B）E2-C16- C）C4-C16- 29）有如下程序： D #include using namespace std; class Name{

char name[20]; public: Name(){

strcpy(name,\cout<<'?'; }

Name(char *fname)){

strcpy(name,fname); cout<'?'; } };

int main(){

Name names[3]={Name(“张三”),Name(“李四”)}; Return 0; }

运行此程序输出符号？的个数是

A）0 B）1 C）2 D）3 （30）有如下程序： A #include using namespace std; public:

AA(){ cout<<'1'; } };

class BB: public AA{ int k; public:

BB():k(0){ cout<<'2'; } BB(int n):k(n){ cout<<'3';} }

int main(){ BB b(4), c; return 0;

17

D）E2-E4-

}

运行时的输出结果是

A）1312 D）132 C）32 D）141 （31）有如下程序：B #include using namespace std; class C1{ public:

~C1(){ cout<<1; } };

Class C2: public c1{ public:

~c2(){ cout<<2; } };

int main(){ C2 cb2; C1 *cb1; return 0; }

运行时的输出结果是

A）121 B）21 C）211 D）12 （32）有如下程序 D #include using namespace std;

class Publication{ //出版物类 char name[30]; public:

Publication(char *name=\未知名称\strcpy(this->name,name); }

const char * getName()const{ return name; }

virtual const char * getType()const{ return \未知类型\};

class Book: public Publication{ //书类 public:

Book(char *name): Publication(name){}

virtual const char * getType()const{ return \书\};

void showPublication( Publication &p){

cout<

int main(){

Book book(\精彩人生\showPublication(book);

18

return 0; }

运行时的输出结果是

A）未知类型：未知名称 B）未知类型：精彩人生 C）书：未知名称 D）书：精彩人生 （33）下列关于运算符重载的描述中，错误的是 C A）::运算符不能重载

B）类型转换运算符只能作为成员函数重载

C）将运算符作为非成员函数重载时必须定义为友元 D）重载[]运算符应完成“下标访问”操作 （34）有如下程序： B #include #include Using namespace std; int main(){

int s[]={123, 234};

cout<

for(int i=0; i<2; i++) { cout<

运行时的输出结果是

A）123 B）***123 C）***123 D）***123 234 234 ***234 234*** （35）有如下类定义 A class A { char *a; public: A():a(0){}

A(char *aa){ //把aa所指字符串拷贝到a所指向的存储空间 a= ; strcpy(a,aa); strcpy(a,aa); }

~A() {delete []a;} };

横线处应填写的表达式是

A）nes char[strlen(aa)+1] B）char[strlen(aa)+1] C）char[strlen(aa)] D）new char[sizeof(aa)-1] 二、填空题(每空2分,共30分)

（6）若表达式(x+(y-z)*(m/n))+3中的变量均为double型，则表达式值的类型为 【6】 。 （7）有如下循环语句：

For(int i=50; i>20; i-=2) cout<

（8）利用表达式a[i]可以访问int型数组a中下标为i的元素。在执行了语句int *p=a;后，

19

利用指针p也可访问该元素，相应的表达式是 【8】 。

（9）下面是一个递归函数，其功能是使数组中的元素反序排列。请将函数补充完整。 void reverse(int *a, int size){ if(size<2) return; int k=a[0]; a[0]=a[size-1]; a[size-1]=k;

reverse(a+1, 【9】 ); }

（10）类Sample的构造函数将形参data赋值给数据成员data。请将类定义补充完整。 class Sample{ public:

Sample(int data=0); Private: Int data; };

Sample::Sample(int data){ 【10】 }

（11）有如下类定义： class Sample{ public: Sample(); ~Sample(); Private:

Static int date; };

将静态数据成员data初始化为0的语句是 【11】 。 （ 12）“图形”类Shape中定义了纯虚函数CalArea()，“三角形”类Triangle继承了类Shape，请将Triangle类中的CalArea函数补充完整。 class Shape{ public:

virtual int CalArea()=0; }

class Triangle: public Shape{ public:

Triangle{int s, int h}: side(s),height(h) {} 【12】 { return side*height/2 ; } private: int side; int height; };

（13）有如下程序：

20

#include using namespace std; class GrandChild{ public:

GrandChild(){ strcpy (name,\const char * getName()const { return name; } virtual char * getAddress()const=0; private:

char name[20]; };

class GrandSon : public GrandChild{ public:

GrandSon{char *name} {}

Char * getAddress() const { return \};

int main(){

GrandChild *gs=new GrandSon(\

cout<getName()<<\住在\delete gs; return 0; }

运行时的输出结果是 【13】 。

（14）如下程序定义了“单词”类word，类中重载了<运算符，用于比较“单词”的大小，返回相应的逻辑值。程序的输出结果为：After Sorting: Happy Welcome，请将程序补充完整。

#include #include using namespace std; class Word{ public:

Word(string s) : str(s) { } string getStr(){ return str; }

bool operator < (Word w) const { return (str

friend ostream& operator << (ostream& output, const Word &w) { output<

Int main(){

Word w1(\Cout<<\

if(w1

21

}

（15）请将下列模板类Data补充完整。 template class Data{ public:

void put (T v) { val=v; }

T get() //返回数据成员val的值，返回类型不加转换 { return val; } private: T val; };

2009年9月全国计算机等级考试二级C++笔试参考答案

(6)double (7)15 (8)*(p+i) (9)size-1 (10)this->data=data; (11)int Sample::data = 0; (12)int CalArea(size,height) (13)Unknown住在Shanghai

2012年3月全国计算机等级考试二级笔试试卷

一、选择题(每小题2分，共70分) (1)下列叙述中正确的是 A

A)循环队列是队列的一种链式存储结构 B)循环队列是一种逻辑结构

C)循环队列是队列的一种顺序存储结构 D)循环队列是非线性结构 (2)下列叙述中正确的是 D

A)栈是一种先进先出的线性表 B)队列是一种后进先出的线性表

C)栈与队列都是非线性结构 D)以上三种说法都不对

(3)一棵二叉树共有25个结点，其中5个是叶子结点，则度为1的结点数为 A

A)4 B)16 C)10 D)6 (4)在下列模式中，能够给出数据库物理存储结构与物理存取方法的是 B

A)逻辑模式 B)概念模式 C)内模式 D)外模式 (5)在满足实体完整性约束的条件下 A

A)一个关系中可以没有候选关键字 B)一个关系中只能有一个候选关键字

C)一个关系中必须有多个候选关键字 D)一个关系中应该有一个或多个候选关键字

(6)有三个关系R、S和T如下： D

R s t A B C A B C A B C a 1 2 a 1 2 b 2 1 b 2 1 d 2 1 c 3 1 c 3 1 则由关系R和S得到关系T的操作是 A)并 B)差 C)交 D)自然连接 (7)软件生命周期的活动中不包括 A A)软件维护 B)需求分析 C)市场调研 D)软件测试 (8)下面不属于需求分析阶段任务的是 D

22

A)确定软件系统的性能需求 B)确定软件系统的功能需求 C)制定软件集成测试计划 D)需求规格说明书评审 (9)在黑盒测试方法中，设计测试用例的主要根据是 D A)程序外部功能 B)程序数据结构 C)程序流程图 D)程序内部结构

(10)在软件设计中不使用的工具是 A

A)系统结构图 B)程序流程图 C)PAD图 D)数据流图(DFD图) (11)若一个函数的原型为\则该函数的返回值类型为 B

A)int * B)int C)int& D)char

(12)若AA为一个类,a为该类的私有整型数据成员,getA()为该类的一个非静态公有成员函数,功能是返回a的值。如果x为该类的一个对象,要在类外访问x对象中a的值,正确的访问格式为 A

A)AA.getA() B)x.getA() C)x.a D)AA::a (13)当派生类继承一个基类时,默认的继承方式为 C

A)public B)protected C)private D)不确定

(14)若需要为XV类重载乘法运算符,运算结果为XV类型,在将其声明为类的成员函数时,下列原型声明正确的是 D

A)XV operator *(XV,XV) B)XV *(XV)

C)operator *(XV) D)XV operator *(XV); (15)在定义函数模板或类模板时,开头的保留字是 A

A)typename B)template C)class D)typedef

(16)若需要向一个二进制文件尾部添加数据,则该文件的打开方式为 A A)ios_base::app

B)ios_base::binary | ios_base::out C)ios_base::out

D)ios_base::binary | ios_base::app

(17)在开发一个c++程序的整个过程中,第3个步骤为 C A)链接 B)运行 C)编辑 D)编译

(18)若有定义\则表达式\的值为 C A)3 B)4 C)5 D)6 (19)有如下程序:

#include using namespace std; int main(){ int i,s=0;

for(i=1;s<20;i+=2)s+=i*i; cout<

运行这个程序的输出结果是 D

A)3 B)5 C)7 D)9

(20)若字符指针p所指向的字符串为\在执行语句char *ap=new char[strlen(p)+1];之后,ap指向的字符数组的元素个数为 B

23

A)9 B)8 C)7 D)6 (21)有如下程序:

#include using namespace std; void fl(int& x){x++;} void f2(int x){++x;} int main(){

int x=10,y=12; f1(x); f2(y);

cout<

运行这个程序的输出结果是 D

A)22 B)23 C)24 D)25 (22)有如下程序:

#include using namespace std; class XA{ int a; public:

static int b;

XA(int aa):a(an){b++;} int getA(){return a;} };

int XA::b=0; int main(){

XA d1(4),d2(5);

cout<

运行这个程序的输出结果是 B

A)9 B)11 C)13 D)15 (23)有如下程序:

#include using namespace std; class XX{ int x; public:

XX(int xx=0):x(xx){} int getX(){return x;} };

class YY:public XX{ int y;

24

public:

YY(int xx,int yy):x(xx),y(yy){} int getV(){return getX()+y;} };

int main(){ YY c(3,4);

cout<

运行这个程序的输出结果是 B A)3 B)4 C)7 D)10

(24)在类中重载赋值运算符时,应将其声明为类的 B

A)静态函数 B)友元函数 C)成员函数 D)构造函数 (25)若有函数模板mySwap和一些变量定义如下: template

void mySwap(T X,T Y); double d1,d2;int i1,i2;

下列对mySwap的调用中,错误的是 A A)mySwap(i1,i2) B)mySwap(d1,d2)

C)mySwap(i1,d1) D)mySwap(i2,d2)

(26)在C++中,打开一个文件时与该文件建立联系的是 B A)流对象 B)模板 C)函数 D)类

(27)已知类IMS中两个成员函数的声明为\与\speak();\另有两个对象的定义为\与\则下列语句中,产生编译错误的是 B

A)obj1.listen(); B)obj1.speak(); C)obj2.listen(); D)obj2.speak(); (28)有如下程序:

#include using namespace std; class Monkey{ public:

Monkey() {cout<<'M';} Monkey(char n){cout<

int main(){

Monkey p1,*p2;

p2=new Monkey('X'); delete p2; return 0; }

运行这个程序的输出结果是 A

25

A)MYX B)MYMY C)MXY D)MXYY (29)有如下程序: #include using namespace std; class Boat; class Car{ public:

Car(int i):weight(i){ }

friend int Total(const Car &c.const Boat &b); //① private:

int weight; };

class Boat{ public:

Boat(int i):weight(i){ }

friend int Total(const Car &c,const Boat &b); private:

int weight; };

int Total(const Car &c,const Boat &b){ //② return c.weight+b.weight; }

int main(){ Car c(10); Boat b(8);

cout<<\ return 0; }

下列关于程序的描述中,正确的是 D

A)程序编译正确 B)程序编译时语句①出错 C)程序编译时语句②出错 D)程序编译时语句③出错 (30)有如下程序: #include using namespace std; class Media{ public:

void Name(); void Show(); protected: int page; };

class Book:private Media{ public:

void Print(){cout<

26

③

void Show() {Media::Show();} //① };

int main(){ Book Bible;

Bible.Name(); //② Bible.Print(); //③ Bible.Show(); //④ return 0; }

编译时有错误的是 A

A)语句① B)语句② C)语句③ D)(31)有如下程序:

#include using namespace std; class Base{ public:

virtual void Show(){cout<<'B';} };

class Derived:public Base{ public:

void Show(){cout<<'D';} };

int main(){

Base *p1=new Derived; Derived *p2=new Derived; p1->Show(); p2->Show(); delete p1; delete p2; return 0; }

运行这个程序的输出结果是 D A)BB B)BD C)DB D)DD (32)有如下类定义: class Animal{ public:

virtual void Name()=0; };

class Koala:public Animal{ public:

void Name(){/*函数体略*/} };

关于上述类定义,下列描述中错误的是 B A)类Koala是类Animal的派生类

27

语句④

B)类Koala中的Name函数是一个虚函数 C)类Animal中的Name函数是一个纯虚函数

D)语句\能够建立类Animal的一个对象a

(33)已知类MyClock中未显式定义构造函数,并重载了加法运算符,使得下面的语句

序列能够正确执行: MyClock c1,c2; //...... c2=c1+10;

由此可知,为类MyClock重载的\运算符函数的声明是 C A)friend MyClock operator+(MyClock,int);

B)friend MyClock operator+(MyClock,MyClock); C)friend MyClock operator+(int,MyClock); D)MyClock operator+(MyClock);

(34)下列控制对齐方式的操作符中,错误的是 C

A)internal B)center C)left D)right (35)有如下程序:

#include using namespace std; class Mountain{ int height; public:

Mountain(int h=0):height(h){ } virtual char *GetName()const {return \山\

int GetHeight() const{return height;} };

class Lushan:public Mountain{ public:

Lushan(int d):Mountain(d){ } char *GetName()const {return \庐山\ };

int main(){

Mountain *p= new Lushan(1000);

cout<GetName()<<\海拔\米\ return 0; }

运行这个程序的输出结果是 D

A)庐山海拔1000米 B)庐山海拔0米 C)山海拔1000米 D)山海拔0米 二、填空题(每空2分,共30分)

(1)在长度为n的顺序存储的线性表中删除一个元素,最坏情况下需要移动表中的元素个数为_____1_____。

28

(2)设循环队列的存储空间为Q(1:30),初始状态为front=rear=30。现经过一系列入队与退队运算后,front=16,rear=15,则循环队列中有___2___个元素。 (3)数据库管理系统提供的数据语言中,负责数据的增、删、改和查询的是___3___ 。

(4)在将E-R图转换到关系模式时,实体和联系都可以表示成___4___ 。 (5)常见的软件工程方法有结构化方法和面向对象方法,类、继承以及多态性等概念属于___5___。

(6)如果a为int型变量,b为double型变量,则表达式a+b的值的类型为___6___。

(7)break语句可用于循环语句和___7___语句中。

(8)如果P是指向一个动态数组空间的指针变量,则释放该数组空间的语句是___8____ 。

(9)如果一个函数在其函数体内直接或间接地调用自己,则该函数称为___9___函数。

(10)调用时不必提供参数的构造函数称为___10___构造函数。 (11)有如下程序:

#include using namespace std; class Machine{ static int num; public:

Machine(){num++;}

static void showNum() {cout<

int Machine::num=0; int main(){

Machine a[10],b; Machine::showNum(); return 0; }

运行这个程序的输出结果是___【11】___ 。

(12)类Base、Component和Derived的定义如下,请将横线处缺失部分补充完整。

class Base{ double data; public:

Base(double d):data(d){ } };

class Component{ int data; public:

Component(int d):data(d){ } };

29

class Derived:public Base{ Component com; char character; public:

Derived(double a,int b,char c):

//使用参数a初始化基类成员,使用参数b初始化成员对象com ___【12】___,character(c){ } };

(13)形状类Shape中包含一个纯虚函数draw,它无形参和返回值,则draw函数在Shape类中的原型声明是___【13】___ 。

(14)正方形类的定义如下,请将横线处缺失部分补充完整。 class Square{ private: double width; public:

Square(double w):width(w){}

//重载大于运算符\用于比较两个正方形的大小,函数结果类型为bool类型

___【14】___(Square& s); };

(15)有如下程序,请将横线处缺失部分补充完整。 #include using namespace std; template class Dataset{ T *data; int size; public:

Dataset(T* arr,int length):size(1ength){ data=new T[length];

for(int i=0;i

int main(){

int arr[]={2,4,6,8,10};

//利用数组arr初始化类模板Dataset的对象 set

___【15】___ return 0; }

2012年3月计算机等级考试二级C++笔试真题答案 参考答案：

30

ADABA DADDA BACDA ACCDB DBBBA BBADA DBCCD ADCAC

n 29 数据操作语言 关系 面向对象方法 a=1,b=2 2 3 k<=n 074 rgb 572 *a[i] cab test 2012年9月全国计算机等级考试二级笔试试卷

一、选择题（每小题2分，共70分）

（1）下列链表种，其逻辑结构属于非线性结构的是 D

A）循环链表 B）双向链表 C）带链的栈 D）二叉链表

（2）设循环队列的存储空间为Q(1:35)，初始状态为front=rear=35，现经过一系列入队与退队运算后，front=15，rear=15，则循环队列中的元素个数为 C

A）16 B）20 C）0或35 D）15 （3）下列关于栈的叙述中，正确的是 B

A）栈顶元素一定是最先入栈的元素 B）栈操作遵循先进后出的原则 C）栈底元素一定是最后入栈的元素 D）以上三种说法都不对 （4）在关系数据库中，用来表示实体间联系的是 A

A）二维表 B）树状结构 C）属性 D）网状结构

（5）公司中有多个部门和多名职员，每个职员只能属于一个部门，一个部门可以有多名职员，则实体部门和职员间的联系是 B

A）m:1联系 B）1:m联系 C）1:1联系 D）m:n联系 （6） 有两个关系R和S 如下: R A a b c B 1 2 3 C 2 1 1 A c S B 3 C 1 则由关系R得到关系S的操作是 B A）自然连接 B）选择 C）并 D）投影 （7）数据字典（DD）所定义的对象都包含于 B

A）程序流程图 B）数据流图（DFD图） C）方框图 D）软件结构图

（8）软件需求规格说明书的作用不包括 A

A）软件可行性研究的依据 B）用户与开发人员对软件要做什么的共同理解s C）软件验收的依据 D）软件设计的依据 （9）下面属于黑盒测试方法的是 D

A）逻辑覆盖 B）语句覆盖 C）路径覆盖 D）边界值分析 （10）下面不属于软件设计阶段任务的是 D

A）数据库设计 B）算法设计 C）软件总体设计 D）制定软件确认测试计划 （11）下列关于函数重载的叙述中，错误的是 C

A）重载函数的参数个数可以不同 B）重载函数的参数类型可以不同

31

C）重载函数的返回值类型必须不同

D）重载函数的参数个数或参数类型必须有所不同

（12）下列关于类成员对象构造函数调用顺序的叙述中，正确的是 B

A）与它们在初始化列表中顺序相同 B）与它们在类中声明的顺序相同 C）与析构函数的调用顺序相同 D）顺序不确定

（13）下列关于派生类的叙述中，错误的是 D

A）派生类至少要有一个基类

B）派生类中包括了从基类继承的成员

C）一个派生类可以作为另一个派生类的基类

D）基类成员被派生类继承以后访问权限保持不变 （14）下列关于运算符重载的叙述中，正确的是 B

A）通过运算符重载机制可以为C++语言扩充新的运算符 B）运算符重载的作用是使已有的运算符作用于类的对象 C）重载运算符的操作数类型可以全部为基本类型 D）所有运算符都可以重载

（15）下列关于模板的叙述中，错误的是 C

A）调用模板函数时，有时可以省略模板实参 B）函数模板的每个实例就是一个函数定义 C）类模板的每个实例就是一个类定义 D）类模板的实例是一个类对象

（16）下列关于输入输出流的叙述中，正确的是 A

A）一个文件流可以与一个数据文件相联系 B）cin是专门从键盘输入数据的输入流类 C）流运算符<<用来从输入流中读取数据 D）宽度设置的效果永久有效

（17）下列选项中可以做C++标识符的是 A

A）_256 B）fat/pig C）delete D）5char （18）关键字unsigned不能修饰的类型是 A

A）char B）int C）float D）long int （19）有如下程序：

#include using namespace std; int main(){ char a; cin>>a;

if(a='*') cout<<\ else cout<<\ return 0; } B

A）*** B）### C）***### D）无输出 （20）下列对一维数组a的定义中，语法正确的是 D

32

A）int a(10) B）int n=7,a[n]; C）int n;cin>>n;int a[n]; D）const int size=10;int a[size]; （21）假设函数fun已经定义，其原型为”void fun(int a,int b=7,char *p=”**”);”,下列函数调用中错误的是 C

A）fun(5) B）fun(5,8) C）fun(6,”##”) D）fun(0,0.”==”) （22）已经函数print()没有返回值，如果在类中将之声明为常成员函数，正确的是 A

A）void print()const; B）const void print(); C）void const print(); D）void print(const); （23）已知基类Employees只有一个构造函数，其定义如下：

Employee::Employee(int n):id(n){}

Manager是Employees的派生类，则下列对Manager的构造函数的定义中，正确的是 C

A）Manager::Manager(int n):id(n){} B）Manager::Manager(int n){id=n;}

C）Manager::Manager(int n):Employee(n){} D）Manager::Manager(int n){Employee(n);}

（24）已知将运算符“+”和“*”作为类Complete的成员函数重载，设c1和c2是类Complex的对象，则表达式c1+c2*c1等价于 B

A）c1.operator*(c2.operator+(c1)) B）c1.operator+(c2.operator*(c1))

C）c1.operator*(c1.operator+(c2)) D）c2.operator+(c1.operator*(c1))

（25）下列类模板的定义中语法格式错误的是 D

A）templateclass Buffer{/*…*/};

B）templateclass Buffer{/*…*/};

C）templateclass Buffer{/*…*/}; D）templateclass Buffer{/*…*/};

（26）在C++中既可以用于文件输入又可以用于文件输出的流类是 A

A）fstream B）ifstream C）ofstream D）iostream （27）有如下类定义： B

class MyClass{

int b;char a;double c; public:

MyClass():c(0.0),b(0),a(','){} };

创建这个类的对象时，数据成员的初始化顺序是

A）a,b,c B）c,b,a C）b,a,c D）c,a,b （28）有如下类定义 A

class MyClass{ int x; public:

MyClass():x(0),y(0){} int GetX(){return x;}

33

void SetX(int xx){x==xx;} int y; };

已知obj是类MyClass的对象，下列语句中违反类成员访问控制权限的是 A）obj.x; B）obj.y; C）obj.GetX(); D）obj.SetX(0);

（29）有如下类定义

class Test{

char a; const char b;

public:Test(char c){a=c;b=c;} //第1行 void f(char a)const{this->a=a;} //第2行 void g(char b){this->b=b;} //第3行 char h()const{return a;} //第4行 };

编译时没有错误的行是 C

A）第1行 B）第2行 C）第3行 D）第4行 （30）有如下程序：

#include using namespace std; class A{ public:

A(){cout<,'A';} ~A(){cout<<'C';} };

class B:public A{ public:

B(){cout<<'G';} ~B(){cout<<'T';} };

int main(){ B obj; return 0; }

运行这个程序的输出结果是 B

A）GATC B）AGTC C）GACT D）AGCT （31）有如下程序：

#include using namespace std； class Base{ public； void fun(){cout<<'B';} };

class Derived:public Base{ public;

34

void fun(){ cout<<'D';} };

int main(){ Derived d; d.fun(); return 0; }

若程序的输出结果是BD，则划线处缺失的部分是 C

A）fun() B）Base.fun() C）Base::fun() D）Base->fun() （32）有如下程序：

#include using namespace std; class B{ public;

virtual void f() {cout<<\ void g(){cout<<\ }

class D;public B { public;

void f(){cout<<\ void g(){coun<<\ }

void h(B*p){p->f();p->g();} int main(){ D obj; h(&obj); return 0; }

运行这个程序的输出结果是： D

A）DD B）BB C）BD D）DB （33）有如下程序：

#include #include using namespace std; class MyString{ public;

char str[80];

MyString(const char*s) {strcpy(str,s);} MyString&operator+=(MyString a){ strcat(str,a.str); return*this; } };

ostream&operator<<(ostream&s,const MyString&z){return s << z.str}

35

int main(){ MyString x(\，y(\； cout<<(x+=y)<

运行这个程序的输出结果是 D

A） abc B） cde C） abcde D） abccde

（34）有如下程序： A

#include #include using namespace std; int main(){ cout<

A） ##OK123 B） ##OK#123 C） OK##123 D） OK##123#

（35）有如下语句序列：

ifstream infile(\ if(infile.good())cout<<\ else{

cout<<\

ofstream outfile(\

if(outfile.fail())cout<<\ }

若执行这个语句序列显示的是BD,则说明文件DATA.DAT C A）以读方式打开成功

B）以读方式打开失败，但以写方式打开成功 C）以读方式打开失败，以写方式打开也失败 D）以读方式打开成功，以写方式打开也成功

二、填空题（每空2分，共30分）

（1）一棵二叉树共有47个结点，其中有23个度为2的结点，假设根结点在底1层，则该二叉树的深度为【1】 。

（2）设栈的存储空间为S(1:40)，初始状态为bottom=0，top=0，现经过一系列入栈与出栈运算后，top=20，则当前栈中有【2】个元素。

（3）数据独立性分为逻辑独立性和物理独立性。当总体逻辑结构改变时，其局部逻辑结构可以不变，从而根据局部逻辑结构编写的应用程序不必修改，称为【3】 。

（4）关系数据库中能实现的专门关系运算包括【4】、连接和投影。

（5）软件按功能通常可以分为应用软件、系统软件和支撑软件（或工具软件），Unix操作系统属于【5】软件。

（6）若有定义语句“int x=10；”，则表达式“x<=10?20:30”的值为【6】。 （7）下列语句的作用是计算正整数n的各位数字之和，例如：n=123，sum=1+2+3，请将下列语句补充完整。

36

do{

sum+=; n=n/10; }while(n1=0)

（8）有如下程序：

#include using namespace std; void fun(int&x,int y){ y=y+x; x=y/4; x++; }

int main(){

int x=4,y=5; fun(x,y); cout<

运行这个程序的输出结果是【8】。 （9）有如下程序：

#include using namespace std; class A{ pubic;

A(){cout<<1;}

A(const A&){cout<<2;} -A(){cout<<3;} };

int main(){ A obj1;

A obj2(obj1); return 0; }

运行这个程序的输出结果是【9】。

（10）若下列程序的输出结果是20，请将横线处缺失部分补充完整。

#include using namespace std; class MyClass{ pubic;

MyClass(int x=)10:value(x){}

void SetValue(int x){value=x;cout<

int value; };

37

int main(){ MyClass*ptr=new MyClass; 【10】 //通过对象指针ptr调用SetValue函数 delete ptr； return 0; }

（11）有下列程序的输出结果是2334，请将横线处缺失部分补充完整。

#include using namespace std; class Base{ int m； pubic;

Base(int k)：m(k){}

int getM()const{return m;} }

class Derived:public Base{ int n; public;

Derived(int k)：【11】,n(k){} int getN()const{return n;} }

int main(){ Derived d1(3),d2(4); cout<

（12）在C++中，编译时的多态性是通过模板或函数【12】实现的。

（13）有些运算符既可以作为成员函数重载，也可以作为非成员函数重载。若在一个重载的运算符函数的定义中成功地使用了this指针，说明它是作为【13】重载的。

（14）有如下程序：

#include using namespace std; template

T Add(Tv1,Tv2){return v1+v2;} int main(){ cout<

运行这个程序的输出结果是【14】。 （15）有如下程序：

#include using namespace std; class Point{

38

double x,y; public;

Point(double xx=0.0,double yy=0.0):x(xx),y(yy){} double getX()const{return x;} double getY()const{return y;}

void show()const{cout<<'('<

class Line{

Point p1,p2; public;

Line(Point pp1,Point pp2):p1(pp1),p2(pp2){} Point LeftMost()const{

if(p1.getX()<=P2.getX())return p1; return p2; } }

int main(){ Line line(Point(3.1,5.2),Point(8.2,4.4)); line.LeftMost().show(); return 0; }

运行这个程序的输出结果是【15】。

2012年9月全国计算机等级考试二级笔试答案

二、填空题答案 1、6 2、21 3、物理独立性 4、选择 5、系统 6、 20 7、8、 8 9、1233 10、 ptr->setvalue(20); 11、base(k-1) 12、重载 13、成员函数 14、5,5.8 15、(3.1,5.2)

39

n

本文来源：https://www.bwwdw.com/article/vlj3.html