当前位置：文档库 › c++补考题目(附答案)

c++补考题目(附答案)

选择题

若定义：string str; 当语句cin>>str; 执行时，从键盘输入：Microsoft Visual Studio 6.0!所得的结果是str=（ B ）。

A、Microsoft Visual Studio 6.0

B、Microsoft Visual Studio 6.0!

C、Microsoft

D、Microsoft Visual

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

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

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

C、抽象类是指具有纯虚函数的类

D、一个基类中说明有纯虚函数，该基类的派生类一定不再是抽象类

先加一然后再使用的++运算符的重载形式是（ D ）。

A、operator ()++

B、operator ++() int

C、operator ++() char

D、operator ++()

派生类的对象可访问：( A )

A、公有继承的基类公有成员

B、私有继承的基类保护成员

C、私有继承的基类公有成员

D、公有继承的基类私有成员

若派生类的成员函数不能直接访问基类中继承来的某个成员，则该成员一定是基类（D） A、保护成员或私有成员 B、保护成员

C、公有成员

D、私有成员

下列对基类和派生类关系的描述中，错误的是（ D ）。

A、派生类是基类定义的延续

B、派生类是基类的组合

C、派生类是基类的具体化

D、派生类是基类的子集

下面关于类的成员访问属性的说法中，正确的说法是( A )

A、在类中，未设置访问属性的成员均为私有类型

B、在类中，未设置访问属性的成员均为公有类型

C、在类中，未设置访问属性的成员均为保护类型

D、在类中，未设置访问属性的成员均为不可访问类型

类的析构函数的作用通常是( D )

A、一般成员函数

B、对象的初始化

C、类的初始化

D、释放对象占用的资源（空间）

在下列关键字中, 用以说明类中公有成员的是( A )。

A、public

B、protected

C、private

D、friend

对于在类中定义的静态数据成员，下面正确的说法是（ C ）。

A、该类的每个对象中都有一个静态数据成员

B、既可以在类外初始化，也可以在类内初始化

C、在类外进行初始化

D、对象创建时产生

设有基类定义：

class Cbase

{ private: int a;

protected: int b;

public: int c;

};

派生类采用何种继承方式可以使成员变量b成为自己的私有成员( A )

A、私有继承

B、保护继承

C、私有、保护、公有均可

D、公有继承

试题2：派生类的对象对它的哪一类基类成员是可以访问的？（ C ）

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

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

C、公有继承的基类的公有成员

D、公有继承的基类的私有成员

有如下程序：

#include

using namespace std;

class Base{

private:

void fun1( ) const {cout<<”fun1”;}

protected:

void fun2( ) co nst {cout<<”fun2”;}

public:

void fun3( ) const {cout<<”fun3”;}

};

class Derived : protected Base{

public:

void fun4( ) const {cout<<”fun4”;}

};

int main(){

Derived obj;

obj.fun1( ); //①

obj.fun2( ); //②

obj.fun3( ); //③

obj.fun4( ); //④

}

其中没有语法错误的语句是（ D）。

A、④

B、①

C、③

D、②

试题4：有如下类定义：

class XA{

int x;

public:

XA(int n) {x=n;}

};

class XB: public XA{

int y;

public:

XB(int a,int b);

};

在构造函数XB的下列定义中，正确的是（ D）。

A、XB::XB（int a，int b）：XA(a)，XB(b){ }

B、XB::XB（int a，int b）：x(a)，XB(b){ }

C、XB::XB（int a，int b）：x(a)，y(b){ }

D、XB::XB（int a，int b）：XA(a)，y(b) { }

类O定义了私有函数F1。P和Q为O的派生类，定义为class P: protected O{…}；class Q: public O{…}。( A )可以访问Fl。

A、O类内

B、Q类内

C、O的对象

D、P类内

程序如下：

#include

using namespace std;

class A {

public:

A( ) {cout<<”A”;}

};

class B {public:B( ) {cout<<”B”;} };

class C: public A{

B b;

public:

C( ) {cout<<”C”;}

};

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

执行后的输出结果是（ A）。

A、ABC

B、ACB

C、CBA

D、BAC

在公有派生情况下，有关派生类对象和基类对象的关系，不正确的叙述是（ B ）

A、派生类的对象可以初始化基类的引用

B、派生类的对象可以直接访问基类中的成员

C、派生类的对象的地址可以赋给指向基类的指针

D、派生类的对象可以赋给基类的对象

当保护继承时，基类的（ B ）在派生类中成为保护成员，不能通过派生类的对象来直接访问。

A、任何成员

B、公有成员和保护成员

C、私有成员

D、公有成员和私有成员

下面对派生类的描述中，错误的是（ C ）

A、派生类至少有一个基类

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

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

D、一个派生类可以作为另外一个派生类的基类

下述静态数据成员的特性中，错误的是( A )。

A、静态数据成员不是所有对象所共用的

B、说明静态数据成员时前边要加修饰符static

C、引用静态数据成员时，要在静态数据成员名前加上<类名>和作用域运算符

D、静态数据成员要在类体外进行初始化

派生类的对象对它的基类成员中( C )是可以访问的

A、公有继承的私有成员

B、公有继承的保护成员

C、公有继承的公有成员

D、私有继承的公有成员

C++语言建立类层次结构是通过（ D ）。

A、抽象类

B、类的嵌套

C、虚函数

D、类的继承

print函数是一个类的常成员函数，它无返回值，下列表示中正确的是（B）。

A、void const print()

B、void print()const

C、void print(const)

D、const void print()

若类Ａ和类Ｂ的定义如下：

class A

{

int i,j;

public:

void get();

//...

};

class B: A

{

int k;

public:

void make(int );

//...

};

void B::make(int j)

{

k = i*j;

}

则上述定义中，非法的表达式是( A )。

A、k=i*j;

B、void get();

C、int k;

D、void make(int )

在多基继承的构造函数定义中，几个基类的构造函数之间用( A )分隔。

A、,

B、;

C、:

D、::

在下列各函数中, 不是类的成员函数的是（D）。

A、拷贝构造函数

B、析构函数

C、构造函数

D、友元函数

对于任意一个类，析构函数的个数有( D )。

A、不确定

B、2

C、0

D、1

在C++程序中，对象之间的相互通信通过( A )。

A、调用成员函数实现

B、函数重载实现

C、继承实现

D、封装实现

下列有关类的说法不正确的是( C )。

A、类是一种用户自定义的数据类型

B、只有类中的成员函数才能存取类中的私有数据

C、在类中，如果不作特别说明，所有的成员函数均为公有类型

D、在类中，如果不作特别说明，所有的数据均为私有类型

类中定义的各个成员需要设置被访问的权限，以下给出的关键字中，( D )不能用于限定成员的访问权限。

A、public

B、protected

C、private

D、extern

在下列函数中，（ B ）不能重载。

A、非成员函数

B、析构函数

C、构造函数

D、成员函数

构造函数的功能是（ B ）

A、建立对象并初始化成员函数

B、建立对象并初始化数据成员

C、为类的实例分配存储空间

D、为类名分配存储空间

下列关于对象的描述不正确的是( A )。

A、现实世界中的一切事物都可以看作对象,但只有在具体的系统中加以论述才有实际的意义

B、对象可以描述任何东西

C、对象的属性是对象的静态特征,服务是动态特征,并且对象的属性只能由本对象的服务来操作

D、对象具有属性和服务两个主要因素

对于一个C++的类（ D ）

A、可有一个构造函数和多个析构函数

B、只能有一个构造函数和一个析构函数

C、可有多个构造函数和多个析构函数

D、可有多个构造函数和一个析构函数

关于析构函数，以下说法正确的是( D )

A、当对象调用了构造函数之后，立即调用析构函数

B、析构函数与构造函数的唯一区别是函数名前加波浪线~，因此，析构函数也可以重载

C、类中定义了构造函数，就必须定义析构函数，否则程序不完整，系统无法撤消对象

D、定义类时可以不说明析构函数，此时系统会自动产生一个缺省的析构函数

关于构造函数，以下正确的说法是( C )

A、构造函数没有返回值，因为系统隐含指定它的返回值类型为void

B、无参构造函数和参数为缺省值的构造函数符合重载规则，因此这个类中可以含有这两种构造函数

C、对象一经说明，首先调用构造函数，如果类中没有定义构造函数，系统会自动产生一个不做任何操作的缺省构造函数

D、定义类的成员时，必须定义构造函数，因为创建对象时，系统必定要调用构造函数执行以下程序后，输出结果依次是( C )

class test

{ int x;

public:

test(int a ),x=a;cout<

~test(),cout<

};

void main()

{ test x(1);x=5;}

A、1 构造函数1 构造函数5 析构函数5析构函数

B、1 构造函数5 析构函数5 构造函数5析构函数

C、1 构造函数5 构造函数5析构函数5析构函数

D、1 构造函数1 析构函数5 构造函数5析构函数

下列叙述中，不正确的是：( A )

A、类的析构函数可以重载

B、类的构造函数可以重载

C、一个类可以不定义析构函数

D、一个类可以不定义构造函数

关于成员函数特征的下述描述中，（ D ）是错误的。

A、成员函数可以是静态的

B、成员函数可以重载

C、成员函数可以设置参数的默认值

D、成员函数一定是内联函数

在下列函数原型中，可以作为类AA构造函数的是（ A ）。

A、AA(int) const

B、AA(int) const

C、int AA( )

D、void AA(int)

（ B ）是析构函数的特征。

A、析构函数的定义只能在类体内

B、一个类中只能定义一个析构函数

C、析构函数名与类名不同

D、析构函数可以有一个或多个参数

类的构造函数被自动调用执行的情况是在创建该类的（ D ）。

A、数据成员时

B、友元函数时

C、成员函数时

D、对象时

在下面的类定义中，错误的语句是（C ）。

class sample{

public:

sample(int val); //①

~sample( ); //②

private:

int a=2.5; //③

public: sample( ); //④

A、③

B、④

C、②

D、①

下列说法中正确的是（ D ）。

A、类中的函数成员在类体之外定义时必须要与类声明在同一文件中

B、类定义中只能说明函数成员的函数头，不能定义函数体

C、在类体之外定义的函数成员不能操作该类的私有数据成员

D、类中的函数成员可以在类体中定义，也可以在类体之外定义

类的实例化是指（D ）。

A、定义类

B、指明具体类

C、调用类的成员

D、创建类的对象

数据封装就是将一组数据和与这组数据有关操作组装在一起，形成一个实体，这实体也就是

( A )

A、类

B、对象

C、函数体

D、数据块

A、int &xx=x;

B、int xx;

C、int &xx;

D、int xx=&x;

以下关于枚举的叙述不正确的是（ D ）

A、枚举变量只能取对应枚举类型的枚举元素表中元素

B、可以在定义枚举类型时对枚举元素进行初始化

C、枚举元素表中的元素有先后次序，可以进行比较

D、枚举元素的值可以是整数或字符串

以下对枚举类型名的定义中正确的是( C )

A、enum a={one,two,three};

B、enum a {"one","two","three"};

C、enum a {one=9,two=1,three};

D、enum a={"one","two","three"}; 设有如下枚举类型定义:

enum language { Basic=3,Assembly,Ada=100,COBOL,Fortran};

枚举量Fortran的值为( A )

A、102

B、4

C、7

D、103

已知有职工情况结构变量emp定义为：

struct Date

{ int year;

int month;

int day;

};

strnct Employee

{ char name[20] ;

long code ;

Date birth

};

Employee emp ;

下列对emp的birth的正确赋值方法是( B )。

A、year=1980; month=5; day=1;

B、emp.birth.year=1980; emp.birth.month=5; emp.birth.day=1;

C、emp.year=1980; emp.month=5; emp.day=1;

D、birth.year=1980; birth.month=5; birth.day=1;

枚举类型中的每个枚举常量的值都是一个（ D ）

A、逻辑

B、浮点数

C、字符

D、整数

以下程序的运行结果是（C）

typedef union{long a[2];

int b[4];

char c[8];

}TY;

TY our;

main(){ cout<

A、24

B、16

C、32

D、8

使用typedef定义一个新类型的正确步骤是（C ）

1.把变量名换成新类型名。

2.按定义变量的方法写出定义体。

3.用新类型名定义变量。

4.在最前面加上关键字typedef。

A、2，4，1，3

B、4，2，3，1

C、2，1，4，3

D、1，3，2，4

以下程序的运行结果是（）

main()

{ union{ long a;

int b;

char c;

}m;

cout<

}

A、2

B、6

C、8

D、4

若有以下定义，则以下叙述不正确的是（）：

union data

{ int i;

char c;

float f;

} un;

A、un可以作为函数参数

B、不能对un赋值，但可以在定义un时对它初始化

C、un的地址和它的各成员地址都是同一地址

D、un所占的内存长等于成员f的长度

若有以下定义和语句：

union data

{ int i;

char c;

float f;

} a;

int n;

则以下语句正确的是（ D）。

A、cout《a;

B、n=a;

C、a={2,'a',1.2};

D、a=5;

以下对共用体类型数据的叙述正确的是（ C ）。

A、共用体类型定义中不能出现结构体类型的成员

B、一个共用体变量中可以同时存放其所有成员

C、一个共用体变量中不能同时存放其所有成员

D、可以对共用体变量名直接赋值

当说明一个共用体变量时系统分配它的内存是（ D ）

A、结构中第一个成员所需内存量

B、结构中最后一个成员所需内存量

C、成员中占内存量最大者所需的容量

D、各成员所需内存量的总和

若有以下说明和语句：

struct student

{int age;

int num;

}std,*p;

p=&std;

则以下对结构体变量std中成员age的引用方式不正确的是（ C）。

A、(*p).age

B、p->age

C、*p.age

D、std.age

下面程序的运行结果是（ A ）

main()

{

struct cmplx{int x;

int y;

} cnum[2]={1,3,2,7};

cout<

}

A、6

B、3

C、

D、1

根据下面的定义，能打印出字母M的语句是（ C ）

struct person{char name[9];

int age;

};

struct person class[10]={"John",17,"Paul",19,"Mary",18,"adam",16};

A、cout《class[3].name;

B、cout《class[3].name[1];

C、cout《class[2].name[0];

D、cout《class[2].name[1];

以下程序的运行结果是（ C ）

#include

int main()

{

struct date

{int year,month,day;} today;

cout<

return 0;

}

A、10

B、8

C、12

D、6

结构体类型变量在程序执行期间（ A ）

A、所有成员一直驻留在内存中

B、没有成员驻留在内存中

C、只有一个成员驻留在内存中

D、部分成员驻留在内存中

设有以下说明语句

struct stu

{int a;

float b;

} stutype;则下面的叙述不正确的是（ C）。

A、stutype是用户定义的结构体类型名

B、a和b都是结构体成员名

C、struct stu是用户定义的结构体类型

D、struct是结构体类型的关键字

当说明一个结构体变量时系统分配给它的内存是（ D ）。

A、结构中最后一个成员所需内存量

B、成员中占内存最最大者所需的容量

C、结构中第一个成员所需内存量

D、各成员所需内存量的总和

已有定义int (*p)()；指针p可以（ A ）

A、指向函数的入口地址

B、代表函数的返回值

C、表示函数的类型

D、表示函数返回值的类型

若有函数max(a,b)，并且已使函数指针变量p指向函数max，当调用该函数时，正确的调用方法是（ A ）。

A、(*p)(a,b);

B、(*p)max(a,b);

C、*pmax(a,b);

D、*p(a,b);

语句int (*ptr)()；含义是（ C）。

A、ptr是指向int型数据的指针变量

B、ptr是指向一维数组的指针变量

C、ptr是一个函数名，该函数的返回值是指向int型数据

D、ptr是指向函数的指针，该函数返回一个int型数据

若有说明：char *language[]={"FORTRAN","BASIC","PASCAL","jAVA","c"}; 则language[2]的值是（ A ）。

A、一个字符串

B、一个不定值

C、一个地址

D、一个字符

若以下main函数经过编译、连接后得到的可执行文件名为echo.exe，若希望在系统的命令状态下输入某一命令行后得到输出是china tianjin，则命令行的内容应是（ B）。

main(int argc, char *argv[])

{

int i;

for(i=1; i

cout<

}

A、echo chinatianjin

B、echo china Tianjin

C、echo

D、china tianjin

若有以下定义，则*(p+5)表示（ B ）。

A、元素a[6]的值

B、元素a[5]的地址

C、元素a[6]的地址

D、元素a[5]的值

若有定义：int *p[4]；则标识符p( C )。

A、说明不合法

B、是一个指针，它指向一个含有四个整型元素的一维数组

C、是一个指针数组名

D、是一个指向整型变量的指针

以下与int *q[5]；等价的定义语句是（ A ）。

A、int *(q[5]);

B、int (*q)[5];

C、int *q;

D、int q[5];

若有定义：int (*p)[4]；则标识符p（ D ）。

A、是一个指针数组名

B、是一个指向整型变量的指针

C、定义不合法

D、是一个指针，它指向一个含有四个整型元素的一维数组

若有定义：int a[5]; 则a数组中首元素的地址可以表示为（ B）。

A、&a

B、a

C、a+1

D、&a[1]

填空题：

使程序的输出结果为：

the worker is Zhang San

the manager is Liu Ping

#include

//删除【】左边的下划线并填入适当的语句，使它能调试并得到正确的结果。

//注意：不要改动main函数，不得增行或删行，也不得更改程序的结构

class manager;

class worker

{

char *name;

public:

worker(char *str)

{

name=str;

}

friend void print(worker &, manager &);

};

class manager

{

char *name;

public:

manager(char *str)

{

name=_str_;//【1】

}

friend void print(worker &, manager &);

};

void print(worker _&a_, manager _&b_) //【2】

{

cout<<"the worker is "<

cout<<" the manager is "<

}

void main()

{

worker w("Zhang San");

manager m("Liu Ping");

print(_w,m_); //【3】

}

题目描述：仔细阅读下列求两个点之间距离的程序，程序的输出结果是50，根据程序的输出结果在划线处填入正确语句。

#include

using namespace std;

class point

{

public:

point(float a,float b) { x=a; y=b; }

float Distance(point &p)

{

float dx=p.x-x;

float dy=p.y-y;

return (float)sqrt(dx*dx+dy*dy);

}

private:

float x,y;

};

int main()

{

point p1(2,3),p2(32,43);

cout<

return 0;

}

下列程序中声明了类girl，其中函数“display”是类girl的友元函数，请在（1）、（2）和（3）处各填入正确的内容，使程序能正常运行。

#include

using namespace std;

class girl

{

private:

char name;

int age;

public:

girl(char n, int d) //构造函数

{

name= n;

age=d;

}

friend void display(girl &x); //声明友元函数

};

void display(girl &x) //类外定义友元函数

{

cout<<"Girl's name is :"<

//girl类的友元函数能访问girl类对象的私有成员

}

int main( )

{

girl e('z',18);

display(e); //调用友元函数

return 0;

}

后置自增运算符“++”重载为类的成员函数（设类名为A）的形式为A operator++(int)。

假定AB为一个类，则语句AB(AB&x)；为该类拷贝构造函数的原型说明。

定义类时，在类头中将使用关键字 class 来表示类定义的开始。

C++中，友元不是（是、不是）该类的成员函数

C++类的组成包括数据成员和成员函数。

new的功能是分配内存空间,delete的功能是释放内存空间。

无论是什么继承方式，派生类的成员不能访问基类私有属性的成员。

如果一个类包含一个或多个纯虚函数，则该类称为抽象类。

从实现的角度来讲，多态性可以划分为两类：静态多态性和动态多态性

如果只想保留公共基类的一个复制，就必须使用关键字virtual把这个公共基类声明为虚基类。

C++中两种用户自定义的数据类型有结构体和结构体类型变量。

通过关键字template 可以声明模板，通过关键字class(或typename)指定函数模板的类型参数，有几个类型参数就有几个类型关键字。

运算符重载要求保持其原来的操作数个数、结合性、优先级和语法结构。

类的静态成员分为静态数据成员和静态函数成员。

如果只想保留公共基类的一个复制，就必须使用关键字virtual把这个公共基类声明为虚基类。

在C++中，三种继承方式的说明符号为public、private和protected，如果不加说明，则默认的继承方式为private。

类和对象的关系可表述为：类是对象的抽象，而对象则是类的实例。

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

下列程序的功能是通过重载运算符“+=”，实现复数的相加赋值操作，请完善程序。

class Complex

{ double real,imag;

public:

Complex( ) { real=0; imag=0; }

Complex( double r, double i) { real=r; imag=i; }

Complex operator+=( Complex&x)

{ real +=x.real;

imag +=x.imag;

return Complex(real,imag);

}

};

下列程序第一行输出结果为8，第二行输出结果为9，请完善程序。

class B

{ int a,b;

public:

B(int aa=0,int bb=0) { a=aa; b=bb; }

B operator+( B b,int x);

void show( ) , cout<

};

B operator+( B b, int x)

{ B r;

r.a=_b.a+x_;

r.b=_b.b+x-1_;

return r;

}

void main( )

{ B x(3,5), y(8,4),z1;

z1=x+5;

z1.show( );

}

以下程序实现动态数组类的功能，通过重载“＝”实现动态数组对象的赋值，add函数实现元素的追加，试完成该程序。

class array

{ int num;

float *p;

public:

array( ) { num=0; p=0; }

array (int n, float *a)

{ num=n;

if(num= =0) p=0;

else { p=new float[num];

for(int i=0; i

p[i]=a[i];

}

~array( ) { if(p) delete []p; }

array& operator=(array &arr)

{ if(num= =arr.num)

{ for(int i=0; i

p[i]=_ arr.p[i]_;

}

else { if(p) delete []p;

p=new float[arr.num];

num=arr.num;

for(int i=0; i

}

return this;

}

void add(float x)

{ num++;

float *pt=new float[num];

for(int i=0; i

pt[_num-1_ ]=x;

if(p) delete []p;

_ p=pt _;

}

void show( )

{ for(int i=0; i

cout<

}

};

void main( )

{ float x[4]={10,11,12,13};

array a1(2,x), a2;

a2=a1; a1.show( ); a2.show( );

a2.add(14); a2.add(35); a2.show( );

}

下列程序的功能是通过重载运算符“＝＝”，实现字符串的比较运算，请完善程序。class String

{ char *st;

public:

int operator= =(String &);

String( );

String(char *);

~String( );

void show( ) { cout<

};

String ::String( )

{ st=’\0’;}

String ::String(char *s)

{ st=new char[_strlen(s)+1_ ];

strcpy(st,s);

}

String ::~String( )

{ delete _[]st_; }

int String ::operator= =(_String_ &tar)

{ return strcmp(_st_, tar.st) = =0; }

void main( )

{ String youname(“zhang”);

String myname(“Lou”);

cout<<(myname= = youname);

}

运算符重载有两种实现方法，一种是通过友元函数来实现，另一种通过（成员）函数来实现。运算符重载有两种实现方法，一种是通过成员函数来实现，另一种则通过_友元函数_ 来实现。

为了满足运算符“+”的可交换性，必须将其重载为_友元函数_。

运算符重载仍然保持其原来的优先级、操作个数和结合性。

利用成员函数对双目运算符重载，其左操作数为_this指针_，右操作数为__成员函数参数_。类的构造函数__不可以_(可以/不可以)是虚函数，类的析构函数_可以_ (可以/不可以)是虚函数。当类中存在动态内存分配时经常将类的__析构函数_函数声明成虚函数。

纯虚函数是一种特别的虚函数，它没有函数的_函数体_部分，也没有为函数的功能提供实现的代码，它的实现版本必须由_派生类_给出，因此纯虚函数不能是友元函数。拥有纯虚函数的类就是_抽象类_类，这种类不能实例化。如果纯虚函数没有被重载，则派生类将继承此纯虚函数，即该派生类也是_抽象_类。

虚函数的声明方法是在函数原型前加上关键字_virtual_。在基类中含有虚函数，在派生类中的函数没有显式写出virtual关键字，系统依据以下规则判断派生类的这个函数是否是虚函数：该函数是否和基类的_虚函数_同名；是否与基类的虚函数_参数个数相同、类型_ ；是否与基类的虚函数_相同返回类型_ 。如果满足上述3个条件，派生类的函数就是虚函数。并且该函数覆盖基类的虚函数。

C++支持两种多态性,分别是编译时和运行时。

C++将类继承分为_单继承__和_多继承_两种。

派生类的构造函数一般有3项工作要完成：首先基类初始化，其次成员

对象初始化，最后执行派生类构造函数体。

当公有派生时，基类的公有成员成为派生类的公有成员；保护成员成为派生类的保护成员；私有成员成为派生类的不能直接访问成员。

当保护派生时，基类的公有成员成为派生类的保护成员；保护成员成为派生类的保护成员；私有成员成为派生类的不能直接访问成员。

在C++中，三种派生方式的说明符号为public 、 private 、 protected不加说明，则默认的派生方式为 private。

补充以下程序，使其输出结果为20，40。

#include

class A

{

__public:___

int x;

public:

A(int x=20){___A::x=x ___;}

};

class B:public A

{

int y;

public:

B(int i=30,intj=40) ___{A::X=20;y=j}_____

void print()

{_cout<

};

void main()

{

B b;

b.print();

}

补充以下类，使其能正确运行。

#include

class P

{

private:

int x1,x2;

static int y;

public:

P(_int i=0,int j=0_){x1 = i; x2 = j; }

};

_int P::y _=0; //对静态成员y赋值

void main()

{

P data[20];

}

类CPoint中的成员函数Init的功能是用已知对象给另一对象赋值，请将其补充完整。 class CPoint

{

int x,y;

public:

CPoint(int i,intj){ x = i; y = j; }

void Init(CPoint& k)

{

if(_this==&k_) return; //防止自身赋值

_*this _=k;

}

};

如果在定义类时没有定义构造函数，则编译系统会默认构造函数。如果用一个已经定义的对象去初始化另一个对象，则系统会调用拷贝构造函数。

类具有继承、封装、多态的性质,所以所编出的程序安全性好，重用性好。对象是类的实例。

类的成员的访问属性有三种，分别是公共成员、私有成员、保护成员。

类是对象的集合,分类的依据是具有相同的结构和特性。

构成对象的两个主要因素是属性和行为 ,其中行为属于动态属性, 属性属于静态属性, 成员数据只能由成员函数来操作。

写出程序程序执行结果( 5 10 3):

#include

using namespace std;

class MyClass {

public:

int number;

void set(int i);

};

int number=3;

void MyClass::set (int i){

number=i;

}

void main( ){

MyClass my1;

int number=10;

my1.set(5);

cout<

my1.set(number);

cout<

my1.set(::number);

cout<

}

写出程序程序执行结果( 5,7 ):

#include

using namespace std;

class AA{

int n;

public:

AA(int k):n(k){}

int get( ) {return n;}

int get( ) const{ return n+1;}

};

int main( )

{

AA a(5);

const AA b(6);

cout<

return 0;

}

写出程序程序执行结果( n=0):

#include

using namespace std;

class Test {

public:

Test( ) { n+=2; }

~Test( ) { n-=3;}

static int getNum( ) { return n;}

private:

static int n;

};

int Test::n=1;

int main( ){

Test* p = new Test;

delete p;

cout<<”n=”<

return 0;

}

类的访问限定符包括public、private 和(potected) 。类成员默认的访问方式是(private) 。访问限定符在类中无先后次序，各限定符(允许)(允许/不允许)多次出现。

类定义的关键字是（class），类的数据成员通常指定为（私有），类的函数成员通常指定为（公有），指定为（公有）的类成员可以在类对象所在域中的任何位置访问它们。

定义语句int *f()；和int (*f)()；的含义分别为_f表示一个函数名，其返回值类型为int *_和_表示f是函数指针，它可以指向一个返回值为int类型。

设main函数的说明为：main( int argc, char *argv[])，且有命令行为：FILE1 1 2 3(代表回车)，则argc的值是_4_，argv[1]的值是_1_。

判断题

试题1：运算符重载是通过函数来实现的，定义运算符重载函数时，函数名中要使用关键字operator。（ T ）

试题2：在c++中，只能重载已有的运算符。（ T ）

试题3：私有继承中，基类中所有成员对派生类的对象都是不可见的。（ F ）

试题4：类成员的默认访问模式是private。（ T ）

试题5：一个类只能拥有一个对象。（ F ）

试题6：友元是可以继承的。（ F ）

试题7：对象是类的模板，类是对象的实例化。（ F ）

试题8：构造函数名字和类名相同，构造函数可以带默认参数，可以重载，在创建对象时自动执行。（ T ）

试题9：结构体变量能整体进行输入输出。（ F ）

试题10： C++语言结构体类型变量在程序执行期间，所有成员驻留在内存中。（ T ）

试题1：使用关键字class定义的类中默认的访问权限是私有的（private）。（ T ）

试题2：静态类标识符在它的作用域之外是不存在的。（F）

试题3：函数形参的作用域是该函数的函数体。（ T ）

试题4：在设置了参数默认值后，调用函数的对应实参就必须省略。（F）

试题5：使用内置函数是以增大空间开销为代价的。(T）

试题6：基类中被说明为protected和private的成员只能被其派生类的成员函数访问，不能被其他的函数访问。( F )

试题7：说明函数原型时不需要指明每个函数参数的名字，只需说明每个参数的类型和返回值类型就可以了。( T )

试题8：函数重载既要求两函数参数对应的类型不同又要求参数个数不同。( F )

试题9：程序的编译是以文件为单位的，因此将程序分到多个文件中可以减少每次对程序修改所带来的编译工作量。( T )

试题10：派生类的成员函数可以直接访问基类的所有成员。( F )

试题1：在类Time中的析构函数可以声明为：void ~Time(int); （ F ）

试题2：一个派生类不能作为基类被别的派生类继承。（F ）

试题3：类中所提供的成员函数可以直接访问私有成员。（ T ）

试题4：如果在一个类的对象之间要进行数据交换，可以使用该类的静态数据成员来完成。

（ T ）

试题5：友元关系是单向的，不可交换的。（ T ）

试题6：每个类都必须自己定义构造函数和析构函数。（ F ）

试题7：析构函数没有形参，没有返回值，不能重载。（ T ）

试题8：内联函数中不可以包括复杂语句，如switch及循环语句等。（ T ）

试题9：结构体中的成员(域)，不可以单独使用。（ T ）

试题10：结构体的定义不为它分配具体的内存空间。（ T ）

试题1：用new动态申请的内存空间，必须用delete来释放。( T )

试题2：说明函数原型时不需要指明每个函数参数的名字，只需说明每个参数的类型和返回值类型就可以了。( T )

试题3：无论什么方式的继承，基类的私有成员都不能被派生类访问。（ T ）

试题4：类的私有成员只能被类中的成员函数访问，任何以外的函数对它们的访问都是非法的。（ F ）

试题5：派生类的成员除了它自己的成员外，还包含了它的基类的所有成员。（T）

试题6：用new运算符来创建对象时不会调用构造函数。（ F ）

试题7：构造函数的名字不一定要和类的名字一样。（ F ）

试题8：任何一个对象只能属于一个具体的类。（ T ）

试题9：对抽象类不能定义对象。（T）

试题10：使用关键字class定义的类中默认的访问权限是私有(private)的。（ T ）

历年二级C语言笔试真题及答案

1 2009年9月全国计算机等级考试二级笔试试卷 1）下列数据结构中，属于非线性结构的是 A ）循环队列 B) 带链队列 C) 二叉树 D ）带链栈 2）下列数据结果中，能够按照“先进后出”原则存取数据的是 A) 循环队列 B) 栈 C)队列 D)二叉树 3）对于循环队列，下列叙述中正确的是 A ）队头指针是固定不变的 B ）队头指针一定大于队尾指针 C ）队头指针一定小于队尾指针 D ）队头指针可以大于队尾指针，也可以小于队尾指针 4）算法的空间复杂度是指 A ）算法在执行过程中所需要的计算机存储空间 B ）算法所处理的数据量 C ）算法程序中的语句或指令条数 D ）算法在执行过程中所需要的临时工作单元数 5）软件设计中划分模块的一个准则是 A) 低内聚低耦合 B) 高内聚低耦合 C) 低内聚高耦合 D) 高内聚高耦合 6）下列选项中不属于结构化程序设计原则的是 A) 可封装 B) 自顶向下 C) 模块化 D) 逐步求精 7）软件详细设计产生的图如下：该图是 A) N-S 图 B) PAD 图 C) 程序流程图 D) E-R 图 8）数据库管理系统是 A ）操作系统的一部分B) 在操作系统支持下的系统软件C) 一种编译系统 D) 一种操作系统 9）在E-R 图中，用来表示实体联系的图形是 A) 椭圆图B) 矩形C) 菱形D) 三角形 10）有三个关系R ，S 和T 如下：其中关系T 由关系R 和S 通过某种操作得到，该操作为 A) 选择 B) 投影 C) 交 D) 并 11）以下叙述中正确的是 A ）程序设计的任务就是编写程序代码并上机 B ）程序设计的任务就是确定所用数据结构 C ）程序设计的任务就是确定所用算法 D ）以上三种说法都不完整 12）以下选项中，能用作用户标识符的是 A ）void B ）8_8 C ）_0_ D ）unsigned 13）阅读以下程序 #include main() { int case; float printF; printf(“请输入2个数：”); scanf(“%d %f”,&case,&pjrintF); printf(“%d %f \n”,case,printF); } 该程序编译时产生错误，其出错原因是 A ）定义语句出错，case 是关键字，不能用作用户自定义标识符B ）定义语句出错，printF 不能用作用户自定义标识符 C ）定义语句无错，scanf 不能作为输入函数使用 D ）定义语句无错，printf 不能输出case 的值 14）表达式：(int)((double)9/2)-(9)%2的值是 A ）0 B ）3 C ）4 D ）5 15）若有定义语句：int x=10;，则表达式 x-=x+x 的值为 A ）-20 B ）-10 C ）0 D ）10 16）有以下程序 #include main() { int a=1,b=0; printf(“%d,”,b=a+b); printf(“%d \n”,a=2*b); } 程序运行后的输出结果是 A ）0,0 B ）1,0 C ）3,2 D ）1,2 17）设有定义：int a=1,b=2,c=3;，以下语句中执行效果与其它三个不同的是 A ）if(a>b) c=a,a=b,b=c; B ）if(a>b) {c=a,a=b,b=c;} C ） if(a>b) c=a;a=b;b=c; D ） if(a>b) {c=a;a=b;b =c;} 18）有以下程序 #include main() { int c=0,k; for (k=1;k<3;k++) switch (k) {default: c+=k case 2: c++;break; case 4: c+=2;break; } printf(“%d \n”,c); } 程序运行后的输出结果是 A ）3 B ）5 C ）7 D ）9 19）以下程序段中，与语句：k=a>b?(b>c?1:0):0；功能相同的是 A ）if((a>b)&&(b>c)) k=1;else k=0; B ）if((a>b)||(b>c) k=1;else k=0; C ）if(a<=b) k=0;else if(b<=c) k=1; D ）if(a>b) k=1;else if(b>c) k=1; else k=0; 20）有以下程序 #include main() { char s[]={“012xy”};int i,n=0; for(i=0;s[i]!=0;i++) if(s[i]>=?a?&&s[i]<=?z?) n++; printf(“%d \n”,n); } 程序运行后的输出结果是 A ）0 B ）2 C ）3 D ）5 21）有以下程序 #include main() { int n=2,k=0; while(k++&&n++>2); printf(“%d %d \n”,k,n); } 程序运行后的输出结果是 A ）0 2 B ）1 3 C ）5 7 D ）1 2 22）有以下定义语句，编译时会出现编译错误的是 A ）char a=?a? B ）char a=?\n?; C ）char a=?aa?; D ）char a=?\x2d?; 23）有以下程序 #include main() { char c1,c2; c1=?A?+?8?-…4?; c2=?A?+?8?-…5?; printf(“%c,%d \n”,c1,c2); } 已知字母A 的ASCII 码为65，程序运行后的输出结果是

嵌入式C语言经典笔试题目

嵌入式c语言经典笔试题目 1 .用预处理指令#define声明一个常数，用以表明1年中有多少秒（忽略闰年问题） #define SECONDS_PER_YEAR (60 * 60 * 24 * 365)UL 我在这想看到几件事情： 1) #define语法的基本知识（例如：不能以分号结束，括号的使用，等等） 2)懂得预处理器将为你计算常数表达式的值，因此，直接写出你是如何计算一年中有多少秒而不是计算出实际的值，是更清晰而没有代价的。 3)意识到这个表达式将使一个16位机的整型数溢出-因此要用到长整型符号L,告诉编译器这个常数是的长整型数。 4)如果你在你的表达式中用到UL（表示无符号长整型），那么你有了一个好的起点。记住，第一印象很重要。 2 .写一个"标准"宏MIN，这个宏输入两个参数并返回较小的一个。 #define MIN(A,B)（（A）<= (B) ? (A) : (B)) 这个测试是为下面的目的而设的： 1)标识#define在宏中应用的基本知识。这是很重要的。因为在嵌入(inline)操作符变为标准C的一部分之前，宏是方便产生嵌入代码的唯一方法，对于嵌入式系统来说，为了能达到要求的性能，嵌入代码经常是必须的方法。 2)三重条件操作符的知识。这个操作符存在C语言中的原因是它使得编译器能产生比if-then-else更优化的代码，了解这个用法是很重要的。 3)懂得在宏中小心地把参数用括号括起来 4)我也用这个问题开始讨论宏的副作用，例如：当你写下面的代码时会发生什么事？ least = MIN(*p++, b); 3.预处理器标识#error的目的是什么？如果你不知道答案，请看参考文献1。这问题对区分一个正常的伙计和一个书呆子是很有用的。只有书呆子才会读C语言课本的附录去找出象这种问题的答案。当然如果你不是在找一个书呆子，那么应试者最好希望自己不要知道答案。死循环（Infinite loops） 4.嵌入式系统中经常要用到无限循环，你怎么样用C编写死循环呢？这个问题用几个解决方案。我首选的方案是： while(1) { } 一些程序员更喜欢如下方案： for(;;) { } 这个实现方式让我为难，因为这个语法没有确切表达到底怎么回事。如果一个应试者给出这个作为方案，

C经典习题答案

1．在类作用域中能够通过直接使用该类的（）成员名进行访问。 A. 私有 B. 公用 C. 保护 D. 任何答案：D 2.小数类型和浮点类型都可以表示小数，正确说法：( ) A. 两者没有任何区别 B. 小数类型比浮点类型取值范围大 C.小数类型比浮点类型精度高 D. 小数类型比浮点类型精度低答案：C 3．能作为C#程序的基本单位是( )。 A. 字符 B. 语句 C. 函数 D. 源程序文件答案：B 4. 可用作C#程序用户标识符的一组标识符是( )。 A. void define +WORD B. a3_b3 _123 YN C. for -abc Case D. 2a DO sizeof 答案：B 5.引用类型主要有4种：类类型、数组类型、接口类型和（）。 A.对象类型 B.字符串类型 C.委托类型 D.整数类型答案：C 6.使用Dirctory类的下列方法，可以获取指定文件夹中的文件的是（）. A.Exists() B.GetFiles() C.GetDirectories() D.CreateDirectory() 答案：B 7.加载窗体时触发的事件是( )。 A. Click B.Load C.GotFoucs D.DoubleClick

答案：B 8.改变窗体的标题，需修改的窗体属性是( )。 A. Text B. Name C.Title D. Index 答案：A 9.在接口的成员中，不能包含( ). A.属性 B.方法 C.事件 D.常量答案：D 10.在C#中定义接口时，使用的关键字是( )。 A.interface B.: C.class D.overrides 答案：A 1．当在程序中执行到语句时，将结束所在循环语句中循环体的一次执行。答案：continue 2．元素类型为double的2行5列的二维数组共占用字节的存储空间。答案：80 3．C#数组类型是一种引用类型，所有的数组都是从System命名空间的类继承而来的引用对象。答案：object 4．枚举是从System. 类继承而来的类型。答案：Enum 5．一般将类的构造方法声明为访问权限。如果声明为private，就不能创建该类的对象。答案：public或公有 6.类中声明的属性往往具有get()和两个函数。答案：set() 7.对于方法，参数传递分为值传递和两种。

C语言考试题库及答案复习整理

C 语言理论上机考试选择题部分（共200题） 1、下面程序的输出是___D______ #include void main() { int k=11; printf("k=%d,k=%o,k=%x\n",k,k,k); } A) k=11,k=12,k=11 B) k=11,k=13,k=13 C) k=11,k=013,k=0xb D) k=11,k=13,k=b 2、在下列选项中,不正确的赋值语句是__D______. A) ++t; B) n1=(n2=(n3=0)); C) k=i=j; D) a=b+c=1; 3、下面合法的C 语言字符常量是______A____. A) '\t' B) "A" C) 65 D) A 4、表达式: 10!=9的值是 ________D____. A) true B) 非零值 C) 0 D) 1 5、C 语言提供的合法的数据类型关键字是_____B____. A) Double B) short C) integer D) Char 6、字符(char)型数据在微机内存中的存储形式是__D__. A) 反码 B) 补码 C) EBCDIC 码 D) ASCII 码 7、C 语言程序的基本单位是_____C______. A) 程序行 B) 语句 C) 函数 D) 字符 8、设 int a=12,则执行完语句

a+=a-=a*a 后,a 的值是____D____ A) 552 B) 264 C) 144 D) -264 9、执行下面程序中的输出语句后,输出结果是____B__. #include void main() {int a; printf("%d\n",(a=3*5,a*4,a+5)); } A) 65 B) 20 C) 15 D) 10 10、下面程序的输出是____B______. #include void main() {int x=023; printf("%d\n",--x); } A) 17 B) 18 C) 23 D) 24 11、下面程序的输出的是_____C____. #include void main() {int x=10,y=3; printf("%d\n",y=x/y); } A) 0 B) 1 C) 3 D) 不确定的值 12、已知字母A 的ASCII 码为十进制的65,下面程序的输出是______A_____. #include void main() {char ch1,ch2; ch1='A'+'5'-'3'; ch2='A'+'6'-'3'; printf("%d,%c\n",ch1,ch2); } A) 67,D B) B,C C) C,D D) 不确定的值 13、若要求在if 后一对圆括号中表示a 不等于0的关系,则能正确表示这一关系的表达式为____D__. A) a<>0 B) !a C) a=0 D) a

C语言经典例题和答案

一、求一个任意边长的矩形面积。 #include void main() {int w,h,sum; scanf("%d%d",&w,&h); sum=w*h; printf("area=%d\n",sum); } 二、求一个任意半径的圆的面积及周长。 #define PI 3.14159 #include void main() {float r,area,c; scanf("%f",&r); area=PI*r*r; c=2*PI*r; printf("area=%f\ncircle=%f\n",area,c); } 三、已知：w=5, y=4, z=2, 求表达式：w*y/z的值，并输出。 ##include void main() { int w,y,z,r; w=5; y=4; z=2; r=w*y/z; printf("%5d",r); } 一、从键盘上输入三个数，求出其中的最大值，并输出。 #include void main() {int a,b,c,max; scanf("%d%d%d",&a,&b,&c); max=a; if(max

#include #define PI 3.14159 #include void main() {float a,b,sum; a=30*PI/180; b=60*PI/180; sum=sin(a)+sin(b)+cos(a)+cos(60); printf("total=%f\n",sum); } 三、比较两个数的大小。如果x大于y，则输出：x>y，否则输出：x void main() {int x,y; scanf("%d,%d",&x,&y); if(x>y) printf("x>y\n"); else printf("x void main() {int a,b,c,t; scanf("%d%d%d",&a,&b,&c); if(a>b) { t=b; b=a; a=t; } if(a>c) {t=a; a=c; c=t; } if(b>c) {t=b;b=c;c=t;} printf("%3d%3d%3d\n",a,b,c); }. 二、求自然数1～10之和。。 #include void main()

C语言期末考试题(含答案)

《C 语言程序设计》期末试卷一、单项选择题(10x2’=20’) 1、以下叙述正确的是（） A ）C 语言的源程序不必通过编译就可以直接运行。 B ） C 语言中的每条可执行语句最终都将被转换成二进制的机器指令。 C ）C 语言源程序经编译形成的二进制代码可以直接运行。 D ）C 语言中的函数不可以单独进行编译。 2、一个C 语言的源程序中（） A ）必须有一个主函数 B ）可能有多个主函数 C ）必须有除主函数外其它函数 D ）可以没有主函数 3、以下不能定义为用户标识符的是（） A ）scanf B ）Void C ）_3com D ）int 4、若以下选项中的变量已正确定义，则正确的赋值语句是（） A ）x1=26.8%3; B ）1+2=x2; C ）x3=0x12; D ）x4=1+2=3; 5、设有定义：floata=2,b=4,h=3;以下C 语言表达式中与代数式h b a *)(2 1 的计算结果不．相符的是（） A ）(a+b)*h/2 B ）(1/2)*(a+b)*h C ）(a+b)*h*1/2 D ）h/2*(a+b) 6、C 语言中用于结构化程序设计的3种基本结构是（） A ）顺序结构、选择结构、循环结构 B ）if 、switch 、break C ）for 、while 、do-while D ）if 、for 、continue 7．在while （!x ）语句中的!x 与下面条件表达式等价的是（） A)x!=0B)x==1C)x!=1D)x==0

8、有以下程序： #include voidmain(){ inti=1,j=1,k=2; if((j++||k++)&&i++) printf(“%d,%d,%d\n”,i,j,k);} 执行后的输出结果是（） A）1,1,2 B）2,2,1 C）2,2,2 D）2,2,3 9、有以下程序： #include voidmain(){ inti,s=0; for(i=1;i<10;i+=2) s+=i+1; printf(“%d\n”,s);} 程序执行后的输出结果是（） A）自然数1～9的累加和B）自然数1～10的累加和 C）自然数1～9中奇数之和D）自然数1～10中偶数之和 10、有以下函数定义： voidfun(intn,doublex){……} 若以下选项中的变量都已经正确定义并赋值，则对函数fun的正确调用语句是（）A）fun(inty,doublem); B）k=fun(10,12.5); C）fun(x,n);D）voidfun(n,x); 二、填空题(10x2’=20’) 11、C语言描述“x和y都大于或等于z”的表达式是：。 12、函数定义时涉及的基本要素是：、、。

嵌入式C语言面试题汇总(超经典)

第一部分：基本概念及其它问答题 1、关键字static的作用是什么？这个简单的问题很少有人能回答完全。在C语言中，关键字static有三个明显的作用： 1). 在函数体，一个被声明为静态的变量在这一函数被调用过程中维持其值不变。 2). 在模块内（但在函数体外），一个被声明为静态的变量可以被模块内所用函数访问，但不能被模块外其它函数访问。它是一个本地的全局变量。 3). 在模块内，一个被声明为静态的函数只可被这一模块内的其它函数调用。那就是，这个函数被限制在声明它的模块的本地范围内使用。大多数应试者能正确回答第一部分，一部分能正确回答第二部分，同是很少的人能懂得第三部分。这是一个应试者的严重的缺点，因为他显然不懂得本地化数据和代码范围的好处和重要性。 2、“引用”与指针的区别是什么？答、1) 引用必须被初始化，指针不必。 2) 引用初始化以后不能被改变，指针可以改变所指的对象。 3) 不存在指向空值的引用，但是存在指向空值的指针。指针通过某个指针变量指向一个对象后，对它所指向的变量间接操作。程序中使用指针，程序的可读性差；而引用本身就是目标变量的别名，对引用的操作就是对目标变量的操作。流操作符<<和>>、赋值操作符=的返回值、拷贝构造函数的参数、赋值操作符=的参数、其它情况都推荐使用引用。 3、.h头文件中的ifndef/define/endif 的作用？答：防止该头文件被重复引用。 4、#include 与#include “file.h”的区别？答：前者是从Standard Library的路径寻找和引用file.h，而后者是从当前工作路径搜寻并引用file.h。 5、描述实时系统的基本特性答：在特定时间内完成特定的任务，实时性与可靠性。 6、全局变量和局部变量在内存中是否有区别？如果有，是什么区别？答：全局变量储存在静态数据区，局部变量在堆栈中。 7、什么是平衡二叉树？答：左右子树都是平衡二叉树且左右子树的深度差值的绝对值不大于1。 8、堆栈溢出一般是由什么原因导致的？答：1.没有回收垃圾资源 2.层次太深的递归调用

c和c++经典笔试题及答案

C++/C经典笔试题及答案 C++/C试题本试题仅用于考查C++/C程序员的基本编程技能。内容限于C++/C常用语法，不涉及数据结构、算法以及深奥的语法。考试成绩能反映出考生的编程质量以及对C++/C的理解程度，但不能反映考生的智力和软件开发能力。笔试时间90分钟。请考生认真答题，切勿轻视。一、请填写BOOL , float, 指针变量与“零值”比较的 if 语句。（10分）提示：这里“零值”可以是0, 0.0 , FALSE或者“空指针”。例如 int 变量 n 与“零值”比较的 if 语句为： if ( n == 0 ) if ( n != 0 ) 请写出BOOL flag 与“零值”比较的if 语句：请写出float x 与“零值”比较的if 语句：请写出char *p 与“零值”比较的if 语句： char str[] = “Hello” ; char *p = str ; int n = 10; 请计算 sizeof (str ) = sizeof ( p ) = sizeof ( n ) =void Func ( char str[100]) { 请计算 sizeof( str ) = } void *p = malloc( 100 );请计算 sizeof ( p ) = 1、头文件中的 ifndef/define/endif 干什么用？ 2、#include 和#include “filename.h” 有什么区别？ 3、const 有什么用途？（请至少说明两种） 4、在C++ 程序中调用被 C编译器编译后的函数，为什么要加extern “C”声明？ 5 // 第一个 for (i=0; i

大学C语言考试题库(含标准答案)

单项选择 ================================================== 题号：1482 执行以下程序段后，输出结果和a的值是（）。int a=10 。printf("%d",a++) 。 A、11 和10 B、11 和11 C、10 和11 D、10 和10 答案： C 题号：2100 已知字符'A' 的ASCⅡ代码值是65, 字符变量c1的值是'A',c2 的值是'D'. 执行语句printf("%d,%d",c1,c2-2) 。后, 输出结果是 A、65,66 B、A,B C、 65,68 D、A,68 答案： A 题号：5055 相同结构体类型的变量之间，可以（）。 A、比较大小 B、地址相同 C、赋值 D、相加答案： C 题号：3217 int a[10] 。合法的数组元素的最小下标值为（）。 A、1 B、0 C、10 D、9 答案： B 题号：45 能正确表示逻辑关系:" a ≥10或a≤0 " 的C语言表达式是 A、a>=0 | a<=10 B、a>=10 or a<=0 C、a>=10 && a<=0 D、a>=10 || a<=0

D 题号：157 main() {int x=1,a=0,b=0 。 switch (x) { case 0: b++ 。 case 1: a++ 。 case 2: a++ 。b++。} printf("a=%d,b=%d",a,b) 。} 该程序的输出结果是( ) A、2,2 B、2,1 C、1,1 D、1,0 答案： B 题号：4784 设变量a是整型，f 是实型，i 是双精度型，则表达式10+'a'+i*f 值的数据类型为（）。 A、不确定 B、double C、int D、 float 答案： B 题号：1647 以下程序中，while 循环的循环次数是______ main() { int i=0 。 while(i<10) { if(i<1) continue 。 if(i==5) break 。 i++ 。 } } A、死循环，不能确定次数 B、6 C、4 D、1

C语言练习题(带答案)-绝对经典题目不看后悔

1单选题 1．（A）是构成C语言程序的基本单位。 A、函数 B、过程 C、子程序 D、子例程 2．C语言程序从C开始执行。 A) 程序中第一条可执行语句B) 程序中第一个函数 C) 程序中的main函数D) 包含文件中的第一个函数 3、以下说法中正确的是（C）。 A、C语言程序总是从第一个定义的函数开始执行 B、在C语言程序中，要调用的函数必须在main( )函数中定义 C、C语言程序总是从main( )函数开始执行 D、C语言程序中的main( )函数必须放在程序的开始部分 4.下列关于C语言的说法错误的是（B）。 A) C程序的工作过程是编辑、编译、连接、运行 B) C语言不区分大小写。 C) C程序的三种基本结构是顺序、选择、循环 D) C程序从main函数开始执行 5.下列正确的标识符是（C）。 A.-a1 B.a[i] C.a2_i D.int t 5~8题为相同类型题考点：标识符的命名规则（1）只能由字母、数字、下划线构成（2）数字不能作为标识符的开头（3）关键字不能作为标识符选项A中的“-” ，选项B中“[”与“]”不满足（1）；选项D中的int为关键字，不满足（3） 6．下列C语言用户标识符中合法的是（B）。 A)3ax B)x C)case D)-e2 E)union 选项A中的标识符以数字开头不满足（2）；选项C，E均为为关键字，不满足（3）；选项D中的“-”不满足（1）； 7．下列四组选项中，正确的C语言标识符是（C）。 A）%x B）a+b C）a123 D）123 选项A中的“%” ，选项B中“+”不满足（1）；选项D中的标识符以数字开头不满足（2） 8、下列四组字符串中都可以用作C语言程序中的标识符的是（A）。 A、print _3d db8 aBc B、I\am one_half start$it 3pai C、str_1 Cpp pow while D、Pxq My->book line# His.age 选项B中的“\”，”$” ，选项D中“>”，”#”，”.”，”-”不满足（1）；选项C中的while为关键

C语言试题及答案

第1章 C语言概述习题 1. 单项选择题 (1) C 语言是在 B 语言的基础上产生的。 A. A B. B C. D D. E (2) 在 C 语言中，每个语句必须以 D 结束。 A. 回车符 B. 冒号 C. 逗号 D. 分号 (3) 标识符和关键字间，要用 C 隔开。 A. 回车符 B. 冒号 C. 空格 D. 分号 (4) 用 C 语言编写的源文件经过编译，若没有产生编译错误，则系统将( B )。 A. 生成可执行目标文件 B. 生成目标文件 C. 输出运行结果 D.自动保存源文件 (5) 下列说法中正确的是( B )。 A. 由于 C 源程序是高级语言程序，因此一定要在 TC 软件中输入 B. 由 C 源程序是字符流组成，因此可以作为文本文件在任何文本编辑的软件中输入 C. 由于C 程序是高级语言程序，因此输入后即可执行 D. 由于 C 程序是高级语言程序，因此它由命令组成 (6) 下列说法中正确的是( A )。 A. C 语言程序由主函数和 0 个或多个函数组成 B. C 语言程序由主程序和子程序组成 C. C 语言程序由子程序组成 D. C 语言程序由过程组成 (7) 下列说法中错误的是( D )。 A. 主函数可以分为两个部分：主函数说明部分和主函数体 B. 主函数可以调用任何非主函数的其他函数 C. 任何非主函数可以调用其他任何非主函数 D. 程序可以从任何非主函数开始执行 2. 填空题 (1) C 语言只有 32 个关键字和 9 种控制语句。 (2) C 语言是一种“中级语言”，既具有高级语言的特点又具有低级语言的特点；既适合于开发系统软件又适合于编写应用程序。 (3) 每个源程序有且只有一个主函数，系统总是从该函数开始执行C语言程序。 (4) 在 C 语言程序中允许出现的字符集是 ASCII码字符集。 (5) C 语言的程序中有特殊含义的英语单词称为保留字。 (6) C 语言标识符的长度是前 8 位有效。 (7) C 语言中，标识符的定义规则是以字母或下划线为开头。 (8) C 语言程序的注释可以出现在程序中的任何地方，它总是以 /* 符号作为开始标记，以 */ 符号作为结束标记。第2章数据类型运算符和表达式习题 1. 单项选择题 (1) 以下选项中，正确的 C 语言整型常量是 D 。 A. 32L B. 510000 C. -1.00 D. 567 (2) 以下选项中， D 是不正确的 C 语言字符型常量。

c语言经典面试题

C语言面试题大汇总之华为面试题 1、局部变量能否和全局变量重名？答：能，局部会屏蔽全局。要用全局变量，需要使用"::" ;局部变量可以与全局变量同名，在函数内引用这个变量时，会用到同名的局部变量，而不会用到全局变量。对于有些编译器而言，在同一个函数内可以定义多个同名的局部变量，比如在两个循环体内都定义一个同名的局部变量，而那个局部变量的作用域就在那个循环体内。 2、如何引用一个已经定义过的全局变量？答：extern 可以用引用头文件的方式，也可以用extern关键字，如果用引用头文件方式来引用某个在头文件中声明的全局变理，假定你将那个编写错了，那么在编译期间会报错，如果你用extern方式引用时，假定你犯了同样的错误，那么在编译期间不会报错，而在连接期间报错。 3、全局变量可不可以定义在可被多个.C文件包含的头文件中？为什么？答：可以，在不同的C文件中以static形式来声明同名全局变量。可以在不同的C文件中声明同名的全局变量，前提是其中只能有一个C文件中对此变量赋初值，此时连接不会出错. 4、请写出下列代码的输出内容 #include int main(void) { int a,b,c,d; a=10;

c=++a; d=10*a++; printf("b，c，d：%d，%d，%d"，b，c，d）; return 0; } 答：10，12，120 5、static全局变量与普通的全局变量有什么区别？static局部变量和普通局部变量有什么区别？static函数与普通函数有什么区别？答: 1) 全局变量(外部变量)的说明之前再冠以static 就构成了静态的全局变量。全局变量本身就是静态存储方式，静态全局变量当然也是静态存储方式。这两者在存储方式上并无不同。这两者的区别在于非静态全局变量的作用域是整个源程序，当一个源程序由多个源文件组成时，非静态的全局变量在各个源文件中都是有效的。而静态全局变量则限制了其作用域，即只在定义该变量的源文件内有效，在同一源程序的其它源文件中不能使用它。由于静态全局变量的作用域局限于一个源文件内，只能为该源文件内的函数公用，因此可以避免在其它源文件中引起错误。 2) 从以上分析可以看出，把局部变量改变为静态变量后是改变了它的存储方式即改变了它的生存期。把全局变量改变为静态变量后是改变了它的作用域，限制了它的使用范围。3) static函数与普通函数作用域不同,仅在本文件。只在当前源文件中使用的函数应该说明为内部函数(static)，内部函数应该在当前源文件中说明和定义。对

C语言上机作业试题5套含答案

第一次上机作业（2014）：要求： ?独立完成，上机调试通过后上交 ?作业提交邮箱： ?邮件主题命名：班级学号姓名（第1次作业），例如：电1301班2王鹏（第1次作业） ?以附件形式将每次作业的所有程序源程序压缩打包后提交，压缩文件命名格式同上。 ?程序必须采用缩进格式 1．大写字母转换成小写字母从键盘输入一个大写英文字母，输出相应的小写字母。例：输入G 输出g 2．求平方根输入一个实数x，计算并输出其平方根（保留1 位小数）。例：输入17 输出The square root of 17.0 is 4.1 3．温度转换设计一个程序将华氏温度转换成摄氏温度c = 5/9(f-32) a)输入华氏温度（实型） b)输出的摄氏温度结果保留两位小数例：Please input Fahrenheit temperature: 76.8 The corresponding Celsius temperature is 24.89 4. 计算旅途时间输入二个整数time1 和time2，表示火车的出发时间和到达时间，计算并输出旅途时间。 (输入的有效的时间范围是0000 到2359，不需要考虑出发时间晚于到达时间的情况。) 例：输入712 1411 （出发时间是7：12，到达时间是14：11）输出The train journey time is 6 hours 59 minutes. 5. 数字加密输入一个四位数，将其加密后输出。方法是将该数每一位上的数字加9，然后除以10 取余，做为该位上的新数字，最后将第1 位和第3 位上的数字互换，第2 位和第4 位上的数字互换，组成加密后的新数。例：输入1257 输出The encrypted number is 4601 思考题：你能否编程找出谁做的好事？有四位同学中的一位做了好事，不留名，表扬信来了之后，校长问这四位是谁做的好事。 ?A说：不是我。 ?B说：是C。 ?C说：是D。 ?D说：他胡说。已知三个人说的是真话，一个人说的是假话。现在要根据这些信息，找出做了好事的人。第二次上机作业（2014）：要求： ?独立完成，程序必须采用缩进格式，上机调试通过后上交

C语言面试题(经典全)

1.static有什么用途？（请至少说明两种） 1）限制变量的作用域 2）设置变量的存储域（堆，主动分配内存也是堆） 1)在函数体，一个被声明为静态的变量在这一函数被调用过程中维持其值不变。 2) 在模块内（但在函数体外），一个被声明为静态的变量可以被模块内所用函数访问，但不能被模块外其它函数访问。它是一个本地的全局变量。 3) 在模块内，一个被声明为静态的函数只可被这一模块内的其它函数调用。那就是，这个函数被限制在声明它的模块的本地范围内使用。 4.全局变量和局部变量在内存中是否有区别？如果有，是什么区别？全局变量储存在静态数据库，局部变量在栈 6.堆栈溢出一般是由什么原因导致的？堆栈溢出一般是循环的递归调用导致的，如果使用的大数据结构的局部变量，也可能导致堆栈溢出。没有回收垃圾资源导致的是内存泄露最后内存耗尽。 20.不能做switch()的参数类型是： switch的参数不能为实型。（只能是int char） 9.写出float x 与“零值”比较的if语句。 if(x<0.000001&&x>-0.000001)

3.在c语言库函数中将一个字符转换成整型的函数是atol()吗，这个函数的原型是什么？函数名: atol 功能: 把字符串转换成长整型数函数的原型: long atol(const char *nptr); 程序例: #include #include int main(void) { long l; char *str = "98765432"; l = atol(lstr); printf("string = %s integer = %ld\n", str, l); return(0); } 1.对于一个频繁使用的短小函数,在C语言中应用什么实现,在C++中应用什么实现? c用宏定义，c++用inline

数据结构(C语言)【经典题库】含参考答案

《数据结构与算法》复习题选择题 1．在数据结构中，从逻辑上可以把数据结构分为 C 。 A．动态结构和静态结构 B．紧凑结构和非紧凑结构 C．线性结构和非线性结构 D．内部结构和外部结构 2．数据结构在计算机内存中的表示是指 A 。 A．数据的存储结构 B．数据结构 C 3 A 。 7．算法分析的目的是 C ，算法分析的两个主要方面是 A 。（1）A．找出数据结构的合理性 B．研究算法中的输入和输出的关系 C．分析算法的效率以求改进 C．分析算法的易读性和文档性（2）A．空间复杂度和时间复杂度 B．正确性和简明性 C．可读性和文档性 D．数据复杂性和程序复杂性 8．下面程序段的时间复杂度是 O(n2) 。 s =0;

for( I =0; inext ==NULL C．head->next ==head D head!=NULL

15．带头结点的单链表head为空的判定条件是 B 。 A．head == NULL B head->next ==NULL C．head->next ==head D head!=NULL 16．若某表最常用的操作是在最后一个结点之后插入一个结点或删除最后一个结点，则采用 D 存储方式最节省运算时间。 A．单链表 B．给出表头指针的单循环链表 C．双链表 D．带头结点的双循环链表17．需要分配较大空间，插入和删除不需要移动元素的线性表，其存储结构是 B 。 20 21 B 。 22 A．删除单链表中的第一个元素 B．删除单链表中的最后一个元素 C．在单链表第一个元素前插入一个新元素 D．在单链表最后一个元素后插入一个新元素 23．与单链表相比，双链表的优点之一是 D 。 A．插入、删除操作更简单

c语言期中考试试题及答案

《C语言程序设计》期中考试试卷课程编号：03402513试卷类型：A卷考试形式：笔试考试日期：注意事项：1.请将试卷最后一页的答题纸撕下，将答案填写在其中；2.交卷时请确认答题纸是否按要求写好姓名等信息并与试题一起上交；3.不准携带任何书籍、资料、纸张等。4.草稿纸用试卷的背面。一、单项选择题（1空1分，共20分） 1、C语言程序的基本结构是(【1】) 。【1】A) 函数B) 语句C) 字符D) 程序行 2、一个C程序的执行是(【2】) 。【2】Ａ) 从本程序的主函数开始，到本程序的主函数结束 B）从本程序的第一个函数开始，到本程序的最后一个函数结束 C) 从本程序的主函数开始，到本程序的最后一个函数结束Ｄ）从本程序的第一个函数开始，到本程序的主函数结束 3、下列四个叙述中，错误的是(【3】) 。【3】A) 一个C源程序必须有且只能有一个主函数 B) 一个C源程序可以含一个或多个子函数 C) 在C源程序中注释说明必须位于语句之后 D) C源程序的基本结构是函数 4、下面不属于C语言保留字的是(【4】) 。【4】A) short B) ELSE C) extern D) for 5、下列四个叙述中，正确的是(【5】) 。【5】A) 库函数也是C语言本身的组成部分 B) C语言中的输入输出操作是由相应语句完成的 C) 库函数是C编译系统提供的功能函数 D) 标题文件(头文件)可以在程序的函数内部调用 6、下列四组数据类型中，C语言允许的一组是(【6】）。【6】A) 整型、实型、逻辑型B) 整型、实型、字符型 C) 整型、双精度型、布尔型D) 整型、实型、复型 7、在C语言中不同数据类型的的长度是(【7】）。【7】A) 固定的B) 由用户自己定义的 C) 任意的D) 与机器字长有关

c++补考题目(附答案)

历年二级C语言笔试真题及答案

嵌入式C语言经典笔试题目

C经典习题答案

C语言考试题库及答案复习整理

C语言经典例题和答案

C语言期末考试题(含答案)

嵌入式C语言面试题汇总(超经典)

c和c++经典笔试题及答案

大学C语言考试题库(含标准答案)

C语言练习题(带答案)-绝对经典题目不看后悔

C语言试题及答案

c语言经典面试题

最新版c语言经典习题100例(最全面)

C语言上机作业试题5套含答案

C语言面试题(经典全)

数据结构(C语言)【经典题库】含参考答案

c语言期中考试试题及答案