c期末考试复习题

一、填空题（每空1分，共15分，将正确答案写在（）中）

1.C++中有两种数据类型：（整型）和（字符型）可以使用signed修饰符。

在C++中，用数组、指针、和（引用）作为函数参数，能够将参数值带回。

2.为了降低函数调用的时间开销，建议将小的调用频繁的函数定义为（内联函数）,方法是在函数类型前加上（inline）

关键字。

3.面向对象的程序设计有四大特征，它们是抽象、封装、（继承）、（多态）。

4.拷贝构造函数是在用一个对象初始化另一个对象时被调用，系统缺省的拷贝构造函数的工作方法是（拷贝每一个数据成

员）。或逐一拷贝

5.用new申请某一个类的动态对象数组时，在该类中必须能够匹配到（默认）构造函数，否则应用程序会产生一个编译错

误。

6.静态数据成员必须在类外进行初始化，且静态数据成员的一个拷贝被类的所有对象（共享）。

7.在C++中，定义重载函数时，应至少使重载函数的参数个数或参数类型（有一个不同）。

8.在C++中，虽然友元提供了类之间数据进行访问的一种方式，但它破坏了面向对象程序设计的（封装）特性。

9.预编译指令由三种，它们是：文件包含、（宏定义）（条件编译）

10.静态的成员函数没有隐含的（this指针），所以，它们只能直接访问类的静态的数据成员。

11.在C++中，函数的参数有两种传递方式，它们是值传递和（引用传递）。

12.当非静态成员函数被调用时，该成员函数的（this指针）指向调用它的对象。

13.拷贝构造函数使用（一个已经存在的对象）作为参数初始化创建中的对象。

14.在公有继承的情况下，基类数据成员在派生类中的访问权限（保持不变）。

15.在C++中，构造派生类对象时，总是先从（基类）的初始化开始的。

16.当需要统计程序中某个类创建对象的个数时，需要给该类定义（静态数据

）成员。

17.在多个类之间有重复继承时，为避免被重复继承的基类数据成员在内存中有多个拷贝，应将该基类定义为（虚基

类）。

18.在C++类中，有一种不能定义对象的类，这样的类只能被继承，称之为（抽象类），定义该类至少具有一个（纯虚函数）。

19.在C++中构造一个对象时，其数据成员在构造函数中初始化。对于内嵌的对象、（常量）（基类）数据成员需要在构

造函数的成员初始化列表中初始化。

20.在类的定义中，说明为protected的数据成员称为保护成员。保护数据成员具有双重作用：对于其派生类而言，（是公

有的）；而对于其外部的程序而言，（是私有的）。

21.控制格式输出的操纵符中，（setprecision）是设置数据精度的，（hex）是设置十六进制的。

22.如果s是int型变量，且s=6,则下面s%2+（s+1）%2表达式的值为—1—。

23.已知字母a的ASCII码为十进制数97,且设ch为字符型变量，则表达式ch=3+4,的值为—j。

24.数组与函数参数联系密切，当用数组元素作函数参数时，这是属于值传递；当数组名作为参数时，这是属于引用

传递，对形参的改变可影响到实参。

25.利用“对象名.成员变量”形式访问的对象成员仅限于被声明为3^的成员；若要访问其他成员变量，需要通过3

员函数或友元函数函数。

26.一个一类—和对象—的关系，正如基本数据类型与该类型的变量一个。

27.类成员的默认访问方式是_私有__.

28.一个类有_多个一个构造函数，有——个一析构函数。

29.类的一静态—成员函数不能对类中的非静态成员进行默认访问。

30.如果说明类B是类A的友元类，则类B的所有成员函数都是类A的一友元函数一。

31.利用成员函数对二元运算符重载，其左操作数为this指针右操作数为成员函数参数。

32.类有两种用法：一种是类的实例化，即生成类的一对象；另一种是通过—继承派生出新的类。

33.运算函数中的关键字是一operator,它和运算符一起组成该运算符函数的函数名。

34.如果一个类中有一个或多个纯虚函数，则这个类称为_抽象类__。

35.文件的打开是通过通过使用类一fstream一的成员函数_open（）_来实现的。

36.设所有变量均为整型，则表达式（e=2,f=5,e++,f++,e+f）的值为_9一。

37.已知c的ASCH码为十进制数99,设k为字符型变量，则表达式k=，c，+l的值为_d___。

38.函数的形参在未被调用之前不会分配空间，函数的形参的

个数和类型耍和实参的相同O

39.类的成员分为数据成员和一成员函数。

40.类完成了面向对象程序设计的一封装—特性。

41.构造函数是—对象—被创建时自动执行，对象消失时自动执行的成员函数称为―析构函数对象

42.C++将类继承分为单继承和多继承两种。

43.在继承机制下，当对象消亡时，编译系统先执行派生类的析构函数,然后才执行派生类中子对象类的析构函数,

最后执行基类的析构函数。

44.类的一public.数据成员是类所有对象共享的成员。

45.友元函数一不是一类的成员函数。（是/不是）

46.如果类A继承了类B,则类A称为一派生类—，类B称为―基类。

47.运算符重载后，原运算符的优先级和结合特性_不会—改变。（会/不会）

48.__纯虚函数—是一个在基类中说明的虚函数，但未给出具体的实现，要求在其派生类实现。

49.文件的关闭是通过通过使用类—fstream_的成员函数__close（）_来实现的。

二、选择题

1.面向对象的（B）是一种信息隐蔽技术，目的在于将对象的使用者与设计者分开。不允许使用者直接存取对象的属

性，只能通过有限的接口与对象发生联系。

A.多态性B.封装性C.继承性D.重用性

2.C++的合法注释是（B）。

A./*ThisisaCprogram/*B.//ThisisaCprogram

C."ThisisaCprogram"D./*ThisisaCprogram//

3.关于C++和C语言的描述中，（D）是错误的？

A.C是C++的一个子集B.C程序在C++环境可以运行

C.C++程序在C环境可以运行D.C++是面向对象的而C是面向过程的

4.运算符+、＜=、=、％中，优先级最低的运算符是（C）。

A.+B.<=C.=D.%

5.已知a=4,b=6,c=8,d=9,则“(a++,b>a++&&c>d)?++d：a<b“值为(D),,

A.9B.6C.8D.0（假）

6.对while、do...while循环结构，下面说法正确的是（B）。

A.只是表达形式不同B.do…while结构中的语句至少执行一次（先执行后判断）

C.while结构中的语句至少执行一次D.条件成立时，它们有可能一次也不执行

7.对中断语句的说法下面不正确的是（_5）。

A.用户可以指定中断的位置B.用户可以指定转移的位置

C.break语句可以跳出本循环D.continue语句可以结束本次循环

8.以下正确的说法是（）。

A.用户若需要调用标准函数，调用前必须重新定义

B.用户可以直接调用所有标准库函数

C.用户可以定义和标准库函数重名的函数，但是在使用时调用的是系统库函数

D.用户可以通过文件包含命令将系统库函数包含到用户源文件中，然后调用系统库函数

9.下列哪个不是重载函数在调用时选择的依据（）。

A.参数类型B.参数个数C.函数类型D.函数名

10.对数组名作函数的参数，下面描述正确的是（B）。

A.数组名作函数的参数，调用时将实参数组复制给形参数组

B.数组名作函数的参数，主调函数和被调函数共用一段存储单元

C.数组名作参数时一，形参定义的数组长度不能省略

D.数组名作参数，不能改变主调函数中的数据

11.如果x是整型变量，则合法的形式是（D）。

A.&（x+5）B.*xC.&*xD.*&x

12.在定义一个共用体变量时，系统为其分配存储空间的原则是（B）。

A.按所有成员需要的存储空间总和分配。B.按成员中占存储空间最大者分配。

C.按成员占存储空间最小者分配。D.按第一个成员所需的存储空间分配。

13.下面（B）项是对构造函数和析构函数的正确定义。

A.voidX::X（）,voidX::~X（）

B.X::X（参数），X::~X（）（析构括号没参数）

C.X::X（参数），X::~X（参数）

D.voidX::X（参数），voidX::~X（参数）

14.拷贝构造函数具有的下列特点中，（D）是错误的。

A.如果一个类中没有定义拷贝构造函数时，系统将自动生成一个默认的

B.拷贝构造函数只有一个参数，并且是该类对象的引用

C.拷贝构造函数是一种成员函数

D.拷贝构造函数的名字不能用类名

15.类的析构函数的作用是（D）。

A.一般成员函数B.类的初始化C.对象初始化D.删除对象

16.下列对派生类的描述中，（D）是错误的。

A.一个派生类可以作为另一个派生类的基类

B.派生类至少有一个基类

C.派生类的成员除了它自己的成员外，还包含了它的基类成员

D.派生类中继承的基类成员的访问权限到派生类保持不变

17.继承具有（B）,即当基类本身也是某一个类派生类时，底层的派生类也会自动继承间接基类的成员。

A规律性B.传递性C.重复性D.多样性

18.C++类体系中，能被派生类继承的是（B）»

A.构造函数B.虚函数C.析构函数D.友元函数

19.下列关于动态联编的描述中，错误的是（D）。

A.动态联编是以虚函数为基础

B.动态联编是运行时确定所调用的函数代码的

C.动态联编调用函数操作是指向对象的指针或对象引用

D.动态联编是在编译时确定操作函数的（如果已经确定还谈什么动态）

20.关于纯虚函数和抽象类的描述中，错误的是（C）。

A.纯虚函数是一种特殊的虚函数，它没有具体的实现

B.抽象类是指具有纯虚函数的类

C.一个基类中说明有纯虚函数，该基类派生类一定不再是抽象类（如果派生类没有重新定义纯虚函数，而派生类只是

继承基类的纯虚函数，则这个派生类仍然还是一个抽象类）

D.抽象类只能作为基类来使用，其纯虚函数的实现由派生类给出

21.C++源文件的扩展名为（A）„

A.cppB.cC.txtD.exe

22.在C++语言中，（A）的陈述是正确的。

A.能使用关键字并区分大小写B.能使用关键字并不区分大小写

C.不能使用关键字并区分大小写D.不能使用关键字并不区分大小写

23.运算符+、=、*、>=中，优先级最高的运算符是（C）.

A.+B.=C.*D.>=

24.下列不合法的变量名为（A）。

A.intB.intiC.name_lD.narneO

25.已知x=43,ch='A',y=0：则表达式（x>=y&&ch<'B'&&!y）的值是（C）。

A.0B.语法错C.1（!y=!0=l只有！0为1,其他都为0）D.“假”

26.以下不正确的是（C）。

A.语句for（i=0；；i++）表示无限循环B.for（；：）表示无限循环

C.for（）也表示无限循环（B才对）D.while（1）表示无限循环

27.在函数的返回值类型与返回值表达式的类型的描述中，错误的是（）。

A.函数返回值的类型是在定义函数时确定，在函数调用时是不能改变的

B.函数返回值的类型就是返回值表达式的类型（看ACD）

C.函数返回值表达式类型与返回值类型不同时，函数表达式类型应转换成返回值类型

D.函数返回值类型决定了返回值表达式的类型

28.如果一个函数无返回值，定义时它的函数类型应是（C）。

A.任意B.intC.voidD.无

29.在C++语言中，关于参数默认值的描述正确的是（B）。

A.只能在函数定义时设置参数默认值

B.设置参数默认值时，应当从右向左设置（如ima,b,c=l,d=33）

C.设置参数默认值时，应当全部设置

D.设置参数默认值后，调用函数不能再对参数赋值

30.若有以下定义，则说法错误的是（D）。

inta=100,*p=&a;

A.声明变量p,其中*表示p是一个指针变量

B.变量p经初始化，获得变量a的地址

C.变量p只可以指向一个整形变量

D.变量p的值为100（获得变量a的地址）

31.列关于结构体的说法错误的是（D）。

A.结构体是由用户自定义的一种数据类型

B.结构体中可设定若干个不同数据类型的成员

C.结构体中成员的数据类型可以是另一个已定义的结构体

D.在定义结构体时，可以为成员设置默认值

32.下列有关类的说法不正确的是（C）。

A.对象是类的一个实例

B.任何一个对象只能属于一个具体的类

C.一个类只能有一个对象

D.类与对象的关系和数据类型与变量的关系相似

33.（C）的功能是对象进行初始化。

A.析构函数B.数据成员C.构造函数D.静态成员函数

34.关于友元的描述中，（A）是错误的。

A.友元函数是成员函数（不能），它被说明在类体内

B.友元函数可直接访问类中的私有成员

C.友元函数破坏封装性，使用时尽量少用

D.友元类中的所有成员函数都是友元函数

35.了使类中的某个成员不能被类的对象通过成员操作符访问，则不能把该成员的访问权限定义为（A）。

A.publicB.protectedC.privateD.static

36.派生类的对象对它的（A）是可以访问的。

A.公有继承的基类的公有成员B.公有继承的基类的保护成员

C.公有继承的基类的私有成员D.保护继承的基类的公有成员

37.多继承派生类构造函数构造对象时，（B）被最先调用。

A.派生类自己的构造函数B.虚基类的构造函数

C.非虚基类的构造函数D.派生类中子对象类的构造函数

38.C++类体系中，不能被派生类继承的有（A）。

A.构造函数（构造函数和析构函数都不可被派生类继承）B.虚函数C.静态成员函数D.赋值操作函数

39.编译时的多态性可以通过使用（C）获得。

A.虚函数和指针B.重载函数和析构函数

C.虚函数和对象D.虚函数和引用

40.下列描述中，（D）是抽象类的特征。

A.可以说明虚函数B.可以进行构造函数重载

C.可以定义友元函数D.不能说明其对象

三、指出并改正下列程序段中的语法错误。（6x2,12分）

题目答案

1.1.float&refl=x;

floatx=3.26f;

int&refl=x;

2.2.去掉const

intdl=3,d2=2;

int*constdp=&dl;

dp=&d2;

*dp=5;

3.//Nums为已定义的类3.int改为Nums

Nums*fp;

fp=newint[4];

4.4.voidfunc(intfirst,intsecnd);

voidfunc(intfirst,int2_secnd);数字不能在开头

5.5.Pixel&Pixel::operator=(Pixel&pl);

voidPixel::operator=(Pixel&pl,Pixel&p2);

6.//Pixel有两个整型成员x和y6.去掉const

PixelPixel::operator+=(Pixle&p)const

(

x+=p.x;y+=p.y;

return*lhis;

)

2、指出并改正下列程序段中的语法错误。（6x2,12分）

题目答案

1.1.去掉const

intx=13;

constint&ref=x;

ref=10;

2.double改成int

2.

double*fp;

fp=newint(3);

3.voidfunc(first,intsecnd);3.voidfunc(intfirst,intsecnd);

4.//Pixel有两个整型成员x和y,其拷〃拷贝构造4Pixel(constPixie<&p);

函数定义如下：

voidPixel(constPixle&p);

5.5.Pixel&operator=(Pixel&pl);

friendPixel&operator=(Pixel&pl,Pixel&p2);

6.//Pixel有两个整型成员x和y6.PixelPixel::operator-H-(int)

PixelPixel::operator++(int){

{Pixeltemp;

x++;temp.x=x++;

y++;temp.y=y++;

return*this;returntemp;

}(返回值不能确定是哪个)}

四、程序填空

1.编写函数将字符串按逆序存放。

#include<iostream.h>

#include<stdio.h>//put()

#include<string.h>

voidmain()

{inti,n;

chars[100],temp;

cout«ninputstring:n«endl;

cin»s;〃(1)注意它的用法!

n=$trlen(s);(2)__________

for(i=0;i<n/2;i++)

{temp=s[i];s[i]=s[n-i-1];s[n-i-1]=temp;}〃前后调换

cout«"Now,string:"«endl;

puts(s);//输出新排列的字符串S

}

2.下列程序定义了类Pixel,请完成前置++和后置++的运算符函数的定义。(注意这道题！)

classPixel{

intx,y;

public:

Pixel(intxx=O,intyy=O){x=xx;y=yy;}

Pixeloperator++();

Pixeloperator++(int);

voiddisplayO;

)；

PixelPixel::operator++()

(

x++;y++;

return*this(3)____________

)

PixelPixel::operator++(int)

{s

Pixeltemp=*this;(4)

x++;y++;

return(5)temp;____________

)

voidPixel::display()

(

cout«H(，，«x«,,,',«y«,,),,«endl;

)

3.根据给定的程序执行结果，将下列程序补充完整。

#include<iostream.h>

classBase{

public:

virtual~Base()fcoutvv“DeleteBa$e"vvendl;1(6)

)；

classDerived:publicBase{

public:

~Derived()(coutvv”DeleteDerived,,«endl:}(7)

);

voidmain()

Base*pl=newDerived;(8)____________

deletepl;

〃Derived先得出结果，故可能为析构函数。

〃释放了P1就自动调用〜Derived。析构函数。就不执行〜BaseO，故〜Base。是虚函数。

)

程序的执行结果如下：

DeleteDerived

DeleteBase

4.定义一个字符串类String,有两个私有数据成员：char*content和intlen;要求

1)在构造函数中提示用户输入字符串，；

2)用户能提取和显示字符串；(分别由两个函数完成)

3)实现对字符串中所有小写字母变成大写，并显示。

注意内存的分配与释放。

类定义的部分代码如下，请补充代码使类的定义完整。

#include<iostream.h>

#include<string>

#include<stdlib.h>

classString{

char*content;

intlen;

public:

StringO;

〜String。{deletedcontent;(1)}

voiddisplayO;

voidupper_str();

char*get_str()const{returncontent;(2)}

)；

String::String(){

charch[50];

cout«nenterastring:\n";

cin»ch;

len=strlen(ch);

content=newchar|len+l|:(3)

if(!content)

cout«"Memoryallocationeror!";

exit(l);

)

strcpy(content,ch);

)

voidString::display(){cout«content«Mhave,r«len«"characters.u«endl;}

voidString::upper_str(){

for(inti=0;i<len;i++)

if(conteiitv='z'&&coiiteiit>='a')(4)

contentfil=touppec(conteiit[i]);(5)___________________

)

5.下列程序定义了类Point,请完成前置-和后置-的运算符函数的定义。

classPoint{

floatx,y;

public:

Point(floatxx=0,floatyy=0){x=xx;y=yy;}

Pointoperator—();

Pointoperator-(int);

voiddisplayO;

)；

PointPoint::operator—()

(

x-;y-;

return*this;(6)______________

)

PointPoint:operator—(int)

(

Pointtemp=*this;(7)

x--;y=y-;

returntemp;(8)

)

voidPoint::display()

cout«n(',«x«',,,,«y«,'),,«endl;

6、程序填空，直接将答案写在空行上（6x2,12分）

1.2.

#include〈iostream.h>//_1_#include<iostream.h>

classA{#include<math.h>

inta;classComplex{

public:doublereal,image;

A(inti){a=i;}public:

voidprint(){cout«a«endl;}Complex(doubler=0,doublei=0){real=r;

);image=i;};

classB{friendostream&operator«(ostream

Aobj_a;&output,Complex&obj);

intb;);

public:ostream&operator«(ostream&output,Complex

__B(intj,inti)：obj_aG)/Z2_&obj)

{b=i;}(

voidprint();output«obj.real«obj.image;

);returnoutput;6:

voidB::printO〃3)

(intmain()

obj_a.print();cout«b«endl;(

)Complexc;

intmain()cout«c;

{Bobj_b(3,4)；return0;

obj_b.print();return0;}}//重教<<

五、写出程序的运行结果

1.(3分)

#include<iostream.h>

intmain(void){

charstr[]=Hconfiguration";

char*p=str;

cout«p«endl;

for(inti=0;i<sizeof(str);i=i+2)

cout«str[i];

cout«endl;〃字符c的ASCII码是99

for(i=0;i<4;i++)

cout«*p+i«'〃如果是*(p+i)就是输

出字符，否者输出ASCII码

cout«endl;

return0;

2.(4分)3.(3分)

#include<iostream.h>#include<iostream.h>

classNode{classConstTest{

public:intml,m2;

intdata;public:

Node*next;ConstTest(intx,inty){ml=x;m2=y;}

Node(intd,Node*q=0)voidprint(){cout«m1<<","«m2«endl;}

{data=d;next=q;)voidprint()const;

)；)；

intmain()voidConstTest::print()const

({

intn;cout«uconstfun:"«m1+m2«endl;

Node*p;)

Node*q=0;intmain()

while(cin»n){(

p=newNode(n,q);ConstTesta(6,9);

q=p；a.print();

)constConstTestb(2,5);

for(;p;p=p->next)b.print();

cout«p->data«,,->H;return0;

cout«n*\nH;

return0;

}〃假定，输入如下3个数据：234567/

4.(8分)intmain()

#include<iostream.h>(

classPlane{Planed1(3,6);

protected:Solidd2(2,7,9);

intx,y;Plane*ptr;

public:ptr=&dl;ptr->print();

Plane(inta,intb){x=a;y=b;)plr=&d2;ptr->print();

virtualvoidprint()ptr->increase(4);

{cout«'('«x«,,'«y«'),«endl;}ptr->print();

virtualvoidincrease(intd);d2.print();

)；)

classSolid:publicPlane(第4题

intz;运行结果：

public:

Solid(inta,intb,intc):Plane(a,b){z=c;}

voidprint()Plane设为虚，则相同函数取不为虚的即

{cout«'('«x«),,«y«',,«z«,),«endl;}solid,即两个都为(6,H,13)。但如果变

voidincrease(intd);量不同则虚函数不执行还是原来的如

)；(3,6)

voidPlane::increase(intd){x+=d;y+=d;}(2,7,9)

voidSolid::increase(intd){x+=d;y+=d;z+=d;}5.去掉上题（即第4小题）程序中的“virtual”

〃接右边的代码关键字，运行结果如何？（8分）

第5题

运行结果：

如果没有虚函数则以第一个为基础，第二个

不执行,即第二个的printf和increase不执

行

6.(3分)

#include<iostream.h>

classCount{

staticintcount;

public:

Count(){count++;)

staticintGetc(){returncount;}

-Count(){count-;}

)；

intCount::count=100;

intmain(void)

(

Countcl,c2;第6题的运行结果:

cout«Count::Getc()«endl;

{//执行完里面才执行析构函数

Countc[3];

cout«Count::Getc()«endl;

}//执行虚构函数

cout«Count::Getc()«endl;

return0;

1.(3分)2.(3分)

#include<iostream.h>#include<iostream.h>

voidmain(void)〃里面的void有没有一样voidmain(){

(inta;

charstring[]=,'fortunatecout«"pleaseinputanumber:M;

char*p=string;cin»a;

cout«string«endl;switch(a%2)

cout<<*p<<*(p+2)<<*(p+4)v<*(p+6)<<endl;(

fbr(inti=l;i<sizeof(string);i+=2)case0:cout«"a是偶数"wendl;〃少了

cout«string[i];break,程序会自动自行下一个语句

)default:cout«"a是奇数"<<endl;

)

a=a/4;

cout«a«endl;

｝如果输入数为6,则输出结果是什么？

3.(3分)4.(3分)

#include<iostream.h>#include<iostream.h>

classCount{classPoint

staticintcount;(

public:intx,y;

Count(){count++;}public:

staticintGetc(){returncount;}Point(inta=0,intb=0){x=a;y=b;}

-Count(){count—;}voidmove(intxoffset,intyoffset){x+=xoffset;

);y+=yoffset;}

intCount::count=10;intgetx(){returnx;}

voidmain(void)intgety(){returny;}

();

Countcl,c2;classRectangle:publicPoint

cout«Count::Getc()«endl;{

{intlength,width;

Countc3;public:

cout«Count::Getc()«endl;Rectangle(intx,inty,int1,intw):Point(x,y)

{length=l;width=w;}

}intgetlength(){returnlength;}

cout«Count::Getc()«endl;intgetwidth(){returnwidth;}

));

答案前面提到过类似题目！voidmain()

(

Rectangler(0,0,4,9);

r.move(33,66);

cout«r.getx()«,,,u«r.gety()«u,"«r.getlength()«,',',«r.g

etwidth()«endl;

)

5.(6分)voidmain()

#include<iostream.h>(

classBaseBaseb;

(Derived1dl;

public:Derived2d2;

virtualvoidBase*ptr[3]={&b,&d1,&d2};

show(){cout«"Base::show()u«endl;}for(inti=0;i<3;i++)

);ptr[i]->show();

classDerived1:publicBase)

(

public:

voidshow(){cout«nDerivedl::show()"«endl;}

i.

h

classDerived2:publicDerived16.去掉上题（即第5小题）程序中的“virtual”关

(键字，运行结果如何？（6分）

public:

voidshow(){cout«MDerived2::show()u«endl;}

);

1.(3分)2.(3分)

#include<iostream.h>#include<iostream.h>

voidmain(void){voidmain(){

charstr口=“safety”;inta,b;

char*p=str;intn=0;

cout«str«endl;for(a=l,b=l;a<=100;a++){

cout«*p«*(p+2)«*(p+4)«endl;if(b>=10)break;

for(inti=l;i<sizeof(str)-l;i+=2)if(b%3==l){

cout«str[i];b+=3;

)n++;

continue;

)

}