下面是小编为大家推荐的C和C++经典笔试题附答案解析，本文共10篇，欢迎阅读，希望大家能够喜欢。
篇1：C和C++经典笔试题附答案解析
C和C++经典笔试题附答案解析
1. 用预处理指令#define声明一个常数，用以表明1年中有多少秒(忽略闰年问题)，
答案：#define SECONDS_PER_YEAR(60*60*24*365)UL
应该意识到表达式将使一个16位机的整形数溢出，因此要用到长整型符号L，表达式中UL表示无符号长整型。
2. 写一个“标准”宏MIN，这个宏输入连个参数并返回较小的一个。
答案：#define MIN(A,B) ((A)<=(B)?(A):(B));懂得在宏中小心的吧参数用括号扩起来
3. sizeof 的一些考察
char* ss1=”0123456789”; char ss2[]=”0123456789”; char ss3[100]=”0123456789”;
int ss4[100]; char q1[]=”abc”; char q2[]=”a\n”; char* q3=”a\n”;
答案：ss1是一个字符指针，指针的大小是一个确定的值，就是4，sizeof(ss1)=4;
ss2是一个字符数组，这个数组最初的大小未定，填充值是“0123456789”，一个字符占一位，再加上隐含的“\0”一共是11位。
ss3是一个字符数组，这个数组开始预分配100，所以它的`大小是100位。
ss4是一个整型数组，但是每个整型变量所占空间是4，所以它的大小一共是400位。
q1与ss2类似，占4位。Q2里面有一个“\n”，“\n”算作一位，加上隐含的，大小一共是3位。Q3是一个字符指针，指针得大小是一个定值，就是4.
4. What is the output of the following code?
#include
using namespace std;
class A {};
class A2 {char d,e;};
struct B{};
struct C{ char x,y;};
struct D{int x,y;};
main
{
cout< cout< A *p1=new A();
A p2;
A*p3;
cout< cout< cout< cout< cout< cout< return 0;
}
答案：对于一个类而言，即便它是一个空的类，编译器仍然要要给它一个空间，所以类A即便什么也没有，它的空间大小依然为1，而类A2大小是类中连个字符 d，e之和，所以它的空间大小依然是2，至于p1，p2，p3，p1和p3是指针，大小是一致的，而且是定值，为4，p2是A的对象，所以它的大小和类A 相等，为1，B和C得解释同A和A2，至于D，它和C不同点在于，结构体有两个整型变量，每个整型变量所占空间为4，所以D所占空间大小为8。
最后结果是 1， 2，4， 1，4，1，2，8
5. what is the output the following code?
#include using namespace std;
class A1 { public: int a; static int b;A1(); ~A1();}; 4
class A2 { public: int a; char c; A2(); ~A2();}; 8
class A3 { public: float a; char c; A3(); ~A3();}; 8
class A4 { public: float a; int b; char c; A4(); ~A4();}; 12
class A5 { public: double d; float a; int b; char c; A5(); ~A5();} 24
int main() { cout< 答案：因为静态变量是存放在全局数据区的，sizeof计算栈中分配的大小，是不会计算在内的，所以sizeof(A1)是4;为了照顾数据对其，int 大小为4，char大小为1，所以sizeof(A2)是8;为了照顾数据对其，float大小为4，char大小为1，所以sizeof(A3)为8;为了照顾数据对其，float大小为4，int大小为4，char大小为1，所以sizeof(A4)为12;为了照顾数据对其，double大小为 8，float大小为4，int大小为4，char大小为1，所以sizeof(A5)为24，
6. 以下代码的输出结果是()
char var[]
Int test(char var[]){ retrun sizeof(var);}
答案：因为var[]等价于*var，已经退化成一个指针了，所以大小是4.
7. 以下代码的输出结果是()
Class B { float f; char p; int asf[3];}; cout< 答案：float f占了4个字节，char p占了一个字节，int adf[3]占了12个字节，总共是17个，根据内存的对齐原则，要选择4的倍数，是20个字节。
8. 以下代码的输出结果是()
Class B { double d; char p; int asf[4];}; cout< 答案：double d占了8个字节，char p占了一个字节，int adf[4]占了16个字节，总共是25个，根据内存的对齐原则，要选择8的倍数，是32个字节。
9. 一个空类所占空间为1，多重继承的空类所占的空间还是1，但是虚继承涉及到虚表(虚指针)，所以虚继承的空类占的空间为4
10. this指针是在实例化一个对象后产生的,并且指向对象本身.比如实例化一个对象pt,那么this=&pt;用”&”取地址符来取对象的地址.同样,如果定义对象pt这个类中,有一个public变量x,那么就可以用this->x=0来定义x的值,等同于pt.x=0.
11. #include using namespace std;
Void GetMemory(int *z) { *z=5; }
Int main() { int v; GetMemory(&v); cout< Getmory把v的地址传了过来,*z是地址里的值,是v的副本.通过直接修改地址里的值,不需要有返回值,也把v给修改了,因为v所指向地址的值发生了改变,最终程序会崩溃.
篇2：C笔试题及答案
(1)算法的时间复杂度是指_______。
A)执行算法程序所需要的时间
B)算法程序的长度
C)算法执行过程中所需要的基本运算次数
D)算法程序中的指令条数
答案：C
评析：所谓算法的时间复杂度，是指执行算法所需要的计算工作量。
(2)下列叙述中正确的是________。
A)线性表是线性结构 B)栈与队列是非线性结构
C)线性链表是非线性结构 D)二叉树是线性结构
答案：A
评析：一般将数据结构分为两大类型：线性结构与非线性结构。线性表、栈与队列、线性链表都是线性结构，而二叉树是非线性结构。
(3)下面关于完全二叉树的叙述中，错误的是_________。
A)除了最后一层外，每一层上的结点数均达到最大值
B)可能缺少若干个左右叶子结点
C)完全二叉树一般不是满二叉树
D)具有结点的完全二叉树的深度为[log2n]+1
答案：B
评析：满二叉树指除最后一层外每一层上所有结点都有两个子结点的二叉树。完全二叉树指除最后一层外，每一层上的结点数均达到最大值，在最后一层上只缺少右边的若干子结点(叶子结点)的二叉树。
(4)结构化程序设计主要强调的是_________。
A)程序的规模 B)程序的易读性
C)程序的执行效率 D)程序的可移植性
答案：B
评析：结构化程序设计主要强调的是结构化程序清晰易读，可理解性好，程序员能够进行逐步求精、程序证明和测试，以保证程序的正确性。
(5)在软件生命周期中，能准确地确定软件系统必须做什么和必须具备哪些功能的阶段是________。
A)概要设计 B)详细设计 C)可行性分析 D)需求分析
答案：D
评析：需求分析是对待开发软件提出的需求进行分析并给出详细定义，即准确地确定软件系统的功能。编写软件规格说明书及初步的用户手册，提交评审。
(6)数据流图用于抽象描述一个软件的逻辑模型，数据流图由一些特定的图符构成。下列 图符名标识的图符不属于数据流图合法图符的是_________。
A)控制流 B)加工 C)数据存储 D)源和潭
答案：A
评析：数据流图从数据传递和加工的角度，来刻画数据流从输入到输出的移动变换过程。数据流图中的主要图形元素有：加工(转换)、数据流、存储文件(数据源)、源和潭。
(7)软件需求分析一般应确定的是用户对软件的__________。
A)功能需求 B)非功能需求 C)性能需求 D)功能需求和非功能需求
答案：D
评析：软件需求分析中需要构造一个完全的系统逻辑模型，理解用户提出的每一功能与性能要求，是用户明确自己的任务。因此，需求分析应确定用户对软件的功能需求和非功能需求。
(8)下述关于数据库系统的叙述中正确的是________。
A)数据库系统减少了数据冗余
B)数据库系统避免了一切冗余
C)数据库系统中数据的一致性是指数据类型的一致
D)数据库系统比文件系统能管理更多的数据
答案：A
评析：由数据的共享自身又可极大地减少数据冗余性，不仅减少了不必要的存储空间，更为重要的是可以避免数据的不一致性。所谓数据的一致性是指在系统中同一数据的不同出现应保持相同的值。
(9)关系表中的每一横行称为一个________。
A)元组 B)字段 C)属性 D)码
答案：A
评析：在关系数据库中，关系模型采用二维表来表示，简称“表”。二维表是由表框架及表元组组成。在表框架中，按行可以存放数据，每行数据称为元组。
(10)数据库设计包括两个方面的设计内容，它们是________。
A)概念设计和逻辑设计 B)模式设计和内模式设计
C)内模式设计和物理设计 D)结构特性设计和行为特性设计
答案：A
评析：数据库设计可分为概念设计与逻辑设计。概念设计的目的是分析数据间内在语义关联，在此基础上建立一个数据的抽象模型。逻辑设计的主要工作是将ER图转换为指定的RDBMS中的关系模型。
篇3：C和C经典笔试题及答案
1.那一种成员变量可以在同一个类的实例之间共享?
答案:必须使用静态成员变量在一个类的所有实例间共享数据.如果想限制对静态成员变量的访问,则必须把他们声明成保护型或私有型.不允许使用静态成员变量去存放一个对象的数据。静态成员数据是在这个类的所有对象间共享的。
静态数据成员：静态成员可以实现多个对象之间的数据共享，并且使用静态数据成员还不会破坏隐藏的原则，即保证了安全性。节省内存;提高时间效率。使用静态数据成员可以因为它是所有对象所公有的，因此，对多个对象来说，静态数据成员只存储一处，供所有对象共用。静态数据成员的值对每个对象都是一样，但它的值是可以更新的。只要对静态数据成员的值更新一次，保证所有对象存取更新后的相同的值，
1、静态数据成员在定义或说明时前面加关键字static。
2、静态成员初始化与一般数据成员初始化不同。静态数据成员初始化的格式如下：
<数据类型><类名>::<静态数据成员名>=<值>
这表明：
(1) 初始化在类体外进行，而前面不加static，以免与一般静态变量或对象相混淆。
(2) 初始化时不加该成员的访问权限控制符private，public等。
(3) 初始化时使用作用域运算符来标明它所属类，静态数据成员是类的成员，而不是对象的成员。
3、静态数据成员是静态存储的，它是静态生存期，必须对它进行初始化。
4、引用静态数据成员时，采用如下格式：
<类名>::<静态成员名>
静态数据成员的访问权限允许的话(即public的成员)，可在程序中，按上述格式来引用静态数据成员。
下面举一例子，说明静态数据成员的应用：
#include
class Myclass
{
public:
Myclass(int a, int b, int c);
void GetNumber;
void GetSum;
private:
int A, B, C;
static int Sum;
};
int Myclass::Sum = 0;
Myclass::Myclass(int a, int b, int c)
{
A = a;
B = b;
C = c;
Sum += A+B+C;
}
void Myclass::GetNumber
{
cout<<”Number=”<
}
void Myclass::GetSum
{
cout<<”Sum=”<
}
void main
{
Myclass M(3, 7, 10),N(14, 9, 11);
M.GetNumber;
N.GetNumber;
M.GetSum;
N.GetSum;
}
从输出结果可以看到Sum的值对M对象和对N对象都是相等的。这是因为在初始化M对象时，将M对象的三个int型数据成员的值求和后赋给了Sum，于是Sum保存了该值。在初始化N对象时，对将N对象的三个int型数据成员的值求和后又加到Sum已有的值上，于是Sum将保存另后的值。所以，不论是通过对象M还是通过对象N来引用的值都是一样的，即为54。
静态成员函数
静态成员函数和静态数据成员一样，它们都属于类的静态成员，它们都不是对象成员。因此，对静态成员的引用不需要用对象名。
在静态成员函数的实现中不能直接引用类中说明的非静态成员，可以引用类中说明的静态成员。如果静态成员函数中要引用非静态成员时，可通过对象来引用。下面通过例子来说明这一点。
#include
class M
{
public:
M(int a) { A=a; B+=a;}
static void f1(M m);
private:
int A;
static int B;
};
void M::f1(M m)
{
cout<<”A=”<
cout<<”B=”<
}
int M::B=0;
void main
{
M P(5),Q(10);
M::f1(P); file://调用时不用对象名
M::f1(Q);
}
读者可以自行分析其结果。从中可看出，调用静态成员函数使用如下格式：
<类名>::<静态成员函数名>(<参数表>);
2.判断选择
1. C++语言没有可移植性。 B不正确
2. 定义数组时可以不确定元素个数。 B不正确
3. 指针是一种特殊的变量，只能用来保存地址。 A正确
4. 通过引用或者指针调用对象的成员函数时，如果引用或者指针的类型跟对象的类型不一致时，能自动正确调用对象所属的类中对这个函数的定义。 B不正确
5.类myclass，为myclass类对象以成员函数形式重载后++运算符的声明应该为 C myclass operator++( int );
A. myclass operator++;
B. myclass& operator++;
C. D. myclass& operator++( int );
5. 父类和子类各自定义一个成员函数，函数名相同，参数表不同，那么 C子类中的函数会覆盖父类中的函数。 函数同名,通通覆盖,不同层次的函数不能重载
6. 如果myclass类定义了拷贝构造函数和一个整型参数的构造函数，还重载了赋值运算符，那么语句
myclass obj = 100;会 B调用整型参数的构造函数。等价于 myclass obj = myclass(100)
7. 抽象类指的是 D有纯虚函数的类
8. 多重继承时，如果派生类的两个父类有一个共同的虚基类，那么虚基类的初始化参数由 C派生类
的构造函数来传递。
9. 多态性是通过 C虚函数 实现的。
10. 如果有如下语句
char str[20];
cin >>str;
cout << str;
执行时输入的是“this is a test line!”，则输出的内容是 D 。
A. this is a test line!
B. this is a test line
C. this is a test
D. this
11. 执行语句
char ch = “Hello”;
char * p = &ch[0];
cout << p;
结果是输出 C 。Hello
3.以下生面是否正确?
Class A{ const int size=0;};
答案：常量必须在构造函数的初始化列表里面初始化或者将其设置为static
正确的程序如下：
Class A
{ A{ const int size=0; }};
或者：
Class A
{ static const int size=0; };
篇4：C和C经典笔试题及答案
1. #include using namespace std;
Void GetMemory(int *z) { *z=5; }
Int main { int v; GetMemory(&v); cout<
Getmory把v的地址传了过来,*z是地址里的值,是v的副本.通过直接修改地址里的值,不需要有返回值,也把v给修改了,因为v所指向地址的值发生了改变,最终程序会崩溃.
2. 下面的数据声明都代表什么意思?
(1)float(**def)[10]
Def是一个二级指针，它指向的是一个一维数组的指针，数组的元素都是float。
(2)double*(*gh)[10]
Gh是一个指针，它指向一个一维数组，该数组元素都是double*
(3) double(*f[10])
F是一个数组，f有十个元素，元素都是函数的指针，指向的函数类型是没有参数且返回double的函数
(4)int*((*b)[10])
就跟“int*(b)[10]”是一样的，b是一维数组的指针
(5)long(*fun)(int)
函数指针
(6)int(*(*f)(int,int))(int)
F是一个函数的指针，指向的函数的类型是有两个int参数并且返回一个函数指针的函数，返回的函数指针指向一个int参数且返回int的函数。
3. 指针数组与数组指针
指针数组，是指一个数组里面装着指针，数组指针，代表它是指针，指向真个数组
一个指向整型数组的指针定义为
A. int(*ptr) B.int *ptr C.int*(ptr) D.int ptr
int(*ptr)是以一个指向整型数组的指针
int *ptr是指针数组，ptr里面存的的是地址。它指向位置的值就是*ptr[0],*ptr[1],*ptr[2]，不要存*ptr[0]=5,*ptr[1]=6,因为里面没有相应的地址
int*(ptr)与B相同
4. 用变量a给出下面的定义
(1)一个整型数
(2)一个指向整形数的指针
(3)一个指向指针的指针，它指向的指针是一个整型数
(4)一个有10个整型数的数组
(5)一个有10个指针的数组，该指针是指向一个整型数的
(6)一个指向有10个整型数组的指针
(7)一个指向函数的指针，该函数有一个整型参数并返回一个整型数
(8)一个有10个指针的数组，该指针指向一个函数，该函数有一个整型参数并返回一个整数
Itn a; int *a; int a; int a[10]; int *a[10]; int (*a)[10]; int (*a)(int); int (*a[10])(int)
5.C++中的空类默认产生那些类成员函数?
Class Empty
{ public:
};
答案:对于一个空类,编译器默认产生4个成员函数:默认构造函数,析构函数,拷贝构造函数和赋值函数
篇5：C笔试题及答案
(1)请读程序：
#include
main
{
int a;float b，c;
scanf(“%2d%3P%4f’,&a,&b,&C);
printf(”\na=%d，b=%ec。%f\n”，a，b，C);
}
若运行时从键盘上输入9876543210l，则上面程序的输出结果是________。
A)a=98,b=765,c=432 1
B)a=1 0,b=432,c=8765
C)a=98,b=765.000000,c=432 1.000000
D)a=98,b=765.0,c=432 1.0
答案：C
评析：scanf把用户从键盘录入的数字的第1、2位存入整型变量a;把第3、4、5位存入单精度实型变量b，把第6、7、8、9位存入单精度实型变量c，用户录入的第10位被scanf遗弃。这时变量a、b、c的值分别为：98、765.000000、4321.000000。
(2)一个良好的算法由下面的基本结构组成，但不包括__________。
A)顺序结构 B)选择结构 C)循环结构 D)跳转结构
答案：D
评析：1966年，Bohra和Jacopini提出了以下三种基本结构，用这三种基本结构作为表示一个良好算法的基本单元：1、顺序结构;2、选择结构;3、循环结构。
(3)请选出以下程序的输出结果________。
#include
sub(x,y,z)
int x,y,*z：
{*z=y-x;}
main{
int a,b,c;
sub(10，5，&a);sub(7，a，&b);sub(a，b，&C);
printf(”%d，%d，%d\n”，a，b，C);
}
A)5,2,3 B)-5，-12,-7 C)-5，-12,-17 D)5,-2,-7
答案：B
评析：sub函数的作用是将形参y和x的差赋给了z指向的那个内存地址，所以在sub(10,5,&a/I，10和5属于值传递，a是属于地址传递，也就是a与z指向了同一个存储单元，在执行函数后，a的值随*z变化，所以此次函数被调用后，a的值为y-x=-5，同理可知，在sub(7,a,&b)后，b的值发生变化，其值为-5-7=-12，在sub(a,b,&C)后，c的值发生变化，其值为-12-(-5)=-7。
(4)下面程序在屏幕上的输出是________。
main
{
printf(”ab\b\b c”);
}
A)ab\b\b c B)a c C)abc D)ab c
答案：B
评析：c语言中允许使用一种特殊形式的字符常量，、就是以一个“”开头的字符序列，这样的字符称为“转义字符”。常用的转义字符有：\n，换行;\t，水平制表;\b，退格;\r，回车。
(5)若x是整型变量，pb是基类型为整型的指针变量，则正确的赋值表达式是_______。
A)pb=&x; B)pb=x; C)*pb=&x; D)*pb=
答案：A
评析：选项A将变量x的地址赋给指针变量pb，使pb指向x‘选项B是将x的值当作地址赋给指针pb，Db指向一个地址等于x值的内存单元;选项c将x的地址赋给指针pb指向的地址等于x的内存单元。
(6)设整型数i=5，则printf(“%d”，i+++++i);的输出为________。
A)10 B)1l C)12 D)语法错误
答案：D
评析：c语言中有基本的算术运算符(+、-、*、/)还包括自增自减运算符(++、–)，在c语言解析表达式时，它总是进行贪婪咀嚼，这样，该表达式就被解析为i++ ++ +i，显然该表达式不合c语言语法。
(7)若要用下面的程序片段使指针变量p指向一个存储整型变量的动态存储单元
int *p;
p=___________malloc(sizeof(im));
则应填入__________。
A)int B)int C)(*int) D)(int*)
答案：D
评析：不论p是指向什么类型的指针变量，都可以通过强制类型转换的方法使之类型一致，强制类型转换的格式为(数据类型+)。
(8)下面程序输出的结果是__________。
main
{
int i=5,J=9，x;
x=(I==j?i：(j=7));
printf(”\n%d，%d”，I,J);
}
A)5,7 B)5,5 C)语法错误 D)7,5
答案：A
评析：条件表达式的一般形式为：表达式I?表达式2：表达式3;先求解表达式1，若为真则求解表达式2;若表达式l的值为假，则求解表达式3。本题中先判断i==j，不等，执行j=7;然后执行x=7。故本题为A。
(9)若执行下面程序时从键盘上输入5，
main
{
int x：
scanf(”%d”，&x);
if(x++>5)printf(”%d\n”，x);
else printf(”%d\n”,x–);
}
则输出是________。
A)7 B)6 C)5 D)4
答案：B
评析：根据c语言的语法，x++是在使用x之后，再将x的值加1，在if语句中，x的值为5，条件不成立，执行else后面的语句，因为x的值已经加1，为6，所以打印结果为6。
(10)若有以下定义和语句：
int a={l，2，3，4，5，6，7，8，9,10}，*p=a;
则值为3的表达式是_________。
A)p+=2，*(p++) B)p+=2，*++p
C)p+=3，*p++ D)p+=2，++*p
答案：A
评析：引用一个数组元素，可以用：(1)下标法，如a[i]形式;(2)指针法，如*(a+i)或*(p+i)。数组的下标从0开始，值为3的数组元素是a[2]。B、c的内容为a[3]，D将a[2]前自加，结果为4。
篇6：C笔试题及答案
(1)设a、b和c都是int型变量，且a=3、b=4、c=5，则下面的表达式中，值为0的表
达式是___________。
A)’a’&&’b’ B)a<=b C)a‖+c&&b-c D)!((a
答案：D
评析z选项A：‘a’&&‘b’是字符a与b的相与，不为0;选项B：a<=b，由题中变量赋值可知，结果为1。选项c：a‖+c&&b-c，结果为1;选项D：!((a
(2)以下程序运行后，输出结果是_________。
main
{
char*d。{“ab”，”cde”};
printf(”%x”，d[1]);
}
A)cde B)字符c的ASCII码值
C)字符c的地址 D)出错
答案：C
评析：指针数组中的每一个元素都相当于一个指针变量。一维指针数组的定义形式为：类型名+数组名[数组长度]，在本题main函数中定义指针数组d，它有两个元素，其初值分别是“ab”、“cde”的首地址。dB]的值为”cde”的首地址。%x是指以十六进制数形式输出整数。
(3)设有如下程序
#include
main
{
intk，*j，i=100;
j=&i; k=&j;
printf(”%d\n”，k);
}
上述程序的输出结果是________。
A)运行错误 B)100 C)i的地址 D)j的地址
答案：B
评析：j=&i，j的值就是i的地址，*j=100，将j的地址赋给k，这时*k=j，那么，k=*j，而1=100，所以k=100，最后的打印结果应当为100。
(4)设有以下语句，其中不是对a数组元素的正确引用的是：_______(其中O≤i<10)
int a=[10]={0，1，2，3，4，5，6，7，8，9，}，*p=a;
A)a[p-a] B)。(&a[i]) C)p[I] D)*(*(a+i))
答案：D
评析：观察程序可知，a实际上就是数组a的首地址，所以“+(a+i)”表示的就是数组a中的第i个元素的值，进而，我们可以知道+(t(a+i))必然不是对a数组元素的正确引用。
(5)以下程序运行后，输出结果为________。
main
{
int a[2][3]={1,3,5,7,9,1 1}，*s[2]，**pp，*p;
s[0]=a[0]，s[1]=a[1];
pp=s;
p=(int*)malloc(sizeof(int));
**pp=s[1][1];
p=*PP;
printf(”%d\n”，*p);
}
A)l B)7 C)9 D)1l
答案：C
评析：s是一个含有两个元素的指针数组，pp是一个指向指针变量的指针，s[O]是指向二维数组a行下标为0的元素的首地址，即a[0儿0]的地址，s[1]为a[1][0]的地址。pp的值为s[O]的地址。**pp=s[1][l]后，a[0][0]的值将被赋值为all][l]的值，执行p=*pp;后，p中将是s[0]的值，最后的输出语句将输出地址s[0]所指向的数据，即a[0][O]。
(6)有以下程序：
#include
main{
char c[6];
int I=0：
for(;i<6;c[-]=getchar，i++);
for(I=0;i<6;i++)putchar(c[i]);
primf(”\n”);
}
如果从键盘上输入：
ab
c
def
则输出结果为_________.
A)a B)a C)ab D)abcdef
b b c
c c d
d d
e
f
答案：C
评析：1.getchar：此函数的作用是从终端(或系统隐含指定的输入设备)输入一个字符。
2.putchar：此函数的作用是向终端输出一个字符，也可以输出控制字符。
本题在输入字符时，ab和c后面的回车符分别赋给了c[2]和e[4]，所以，正确答案为c。
(7)在调用函数时，如果实参是简单变量，它与对应形参之间的数据传递方式是_______。
A)地址传递 B)单向值传递
C)由实参传递给形参，再由形参传递给实参
D)传递方式由用户指定
答案：B
评析：c语言规定，实参变量对形参变量的数据传递是“单向值传递”，只由实参传给形参。在内存中，实参单元与形参单元是不同的单元。调用结束后，实参单元仍保留并维持原值。
(8)下面程序
#include
#include
main
{ char*p1=”abc”，*p2=”ABC”,str[50]=”xyz”;
strcpy(str+2,strcat(p1,p2));
printf(”%s\n”,str);
}
的输出是_________。
A)xyzabcABC B)zabcABC
C)yzabcABC D)xyabcABC
答案：D
评析：strcat(pl,p2)将字符串abcABC放到了*pl所指向的存储单元中;strcpy在本题将abcABC复制到str+2所指向的存储单元中，即覆盖原str数组中的字符z及其后的所有字符，故str的值为”xyabcABC”。
(9)下面程序
int aa[3][3]：{{2}，{4}，{6}};
main
{ int i，*p：&aa[0][0];
for(I=0;i<2;i++){
if(i==0)aa[I][i+l]=*p+1;
else++p;
printf(”%d’.，。p);
}
}
的输出是__________。
A)23 B)26 C)33 D)36
答案：A
评析：观察题目，可以发现，*p=&aa[01[o]语句实际是将数组aa的首地址赋给了指针变量p，将i的值带入for循环中，i=0时，aa[0][1]=3，+p=2;*p输出的是指针所指向的数组值，此时p所指向的是aa[O][O]，输出2，而i=l时执行了++p操作使指针向后移动指向了aa[O儿1]，所以在输出*p时应为3。
(10)以下程序的输出结果是_________。
#include
#include
fun(char*w,int n)
{
char t，*s1,*s2;
s1=w;s2=w+n-l：
while(s1
{
t=*s1++：
*sl=*s2–;
*s2=t;
}
}
main
{
char*p;
p=”1234567″;
fun(p，strlen(p));
puts(p);
}
A)1234567 B)7654321 C)1711717 D)717717l
答案：C
评析：在子函数fun中，sl为字符串w的起始地址，s2为字符串的结束地址(字符‘\O’除外)，当执行循环结束循环，w=“1711717”。
篇7：C笔试题
C笔试题
1) 读文件file1.txt的内容(例如)：
12
34
56
输出到file2.txt：
56
34
12
(逆序)
2)输出和为一个给定整数的所有组合
例如n=5
5=1+4;5=2+3(相加的数不能重复)
则输出
1，4;2，3，
第一题,注意可增长数组的应用.
#include
#include
int main(void)
{ int MAX = 10;
int *a = (int *)malloc(MAX * sizeof(int));
int *b;
FILE *fp1;
FILE *fp2;
fp1 = fopen(“a.txt”,”r”);
if(fp1 == NULL)
{printf(“error1″);
exit(-1);
}
fp2 = fopen(“b.txt”,”w”);
if(fp2 == NULL)
{printf(“error2″);
exit(-1);
}
int i = 0;
int j = 0;
while(fscanf(fp1,”%d”,&a[i]) != EOF)
{i++;
j++;
if(i >= MAX)
{
MAX = 2 * MAX;
b = (int*)realloc(a,MAX * sizeof(int));
if(b == NULL)
{printf(“error3″);
exit(-1);
}a = b;
}}
for(;–j >= 0;)
fprintf(fp2,”%d\n”,a[j]);
fclose(fp1);
fclose(fp2);
return 0;
}
第二题.
#include
int main(void)
{unsigned long int i,j,k;
printf(“please input the number\n”);
scanf(“%d”,&i);
if( i % 2 == 0)
j = i / 2;
else
j = i / 2 + 1;
printf(“The result is \n”);
for(k = 0; k < j; k++)
printf(“%d = %d + %d\n”,i,k,i – k);
return 0;
}
#include
void main
{unsigned long int a,i=1;
scanf(“%d”,&a);
if(a%2==0)
{ for(i=1;i printf(“%d”,a,a-i);
}
else
for(i=1;i<=a/2;i++)
printf(” %d, %d”,i,a-i);
}
兄弟,这样的.题目若是做不出来实在是有些不应该, 给你一个递规反向输出字符串的例子,可谓是反序的经典例程.
void inverse(char *p)
{ if( *p = = ‘\0′ )
return;
inverse( p+1 );
printf( “%c”, *p );
}
int main(int argc, char *argv[])
{
inverse(“abc\0″);
return 0;
}
借签了楼上的“递规反向输出”
#include
void test(FILE *fread, FILE *fwrite)
{ char buf[1024] = {0};
if (!fgets(buf, sizeof(buf), fread))
return;
test( fread, fwrite );
fputs(buf, fwrite);
}
int main(int argc, char *argv[])
{ FILE *fr = NULL;
FILE *fw = NULL;
fr = fopen(“data”, “rb”);
fw = fopen(“dataout”, “wb”);
test(fr, fw);
fclose(fr);
fclose(fw);
return 0;
}
在对齐为4的情况下
struct BBB
{ long num;
char *name;
short int data;
char ha;
short ba[5];
}*p;
p=0×1000000;
p+0×200=____;
(Ulong)p+0×200=____;
(char*)p+0×200=____;
解答：假设在32位CPU上，
sizeof(long) = 4 bytes
sizeof(char *) = 4 bytes
sizeof(short int) = sizeof(short) = 2 bytes
sizeof(char) = 1 bytes
由于是4字节对齐，
sizeof(struct BBB) = sizeof(*p)
= 4 + 4 + 2 + 1 + 1/*补齐*/ + 2*5 + 2/*补齐*/ = 24 bytes (经Dev-C++验证)
p=0×1000000;
p+0×200=____;
= 0×1000000 + 0×200*24
(Ulong)p+0×200=____;
= 0×1000000 + 0×200
(char*)p+0×200=____;
= 0×1000000 + 0×200*4
你可以参考一下指针运算的细节
篇8：c经典笔试题
有两个磁盘文件A和B,各存放一行字母，要求把这两个文件中的信息合并(按字母顺序排列)，输出到一个新文件C中.
#include
#include
int main(int argc,char* argv)
{
FILE* fp;
int i,j,k,num,NUM;
char c[50],t,ch;
if((fp=fopen(“A”,“r”))==NULL)
/*can be replaced by open
* int fd=open(“A”,O_RDONLY|O_CREAT);*/
{
printf(“fileA cannot be opened\n”);
exit(0);
}
printf(“\nA contents are:\n”);
for(i=0;(ch=fgetc(fp))!=EOF;i++)/*一个字符一个字符读*/
{
c[i]=ch;
putchar(c[i]);
}
num=i+1;
fclose(fp);
if((fp=fopen(“B”,“r”))==NULL)
{
printf(“fileB cannot be opened\n”);
exit(0);
}
printf(“\nB contents are :\n”);
for(i=0;(ch=fgetc(fp))!=EOF;i++)
{
c[num+i]=ch;
putchar(c[num+i]);
}
fclose(fp);
NUM=num+i+1;
for(k=0;k
{
for(j=0;j
{
if(c[j]>c[j+1])
{
t=c[j];
c[j]=c[j+1];
c[j+1]=t;
}
}
}
printf(“\nC fileis:\n”);
fp=fopen(“C”,“w”);
for(i=0;i
{
putc(c[i],fp);/*将字符一个个写入文件中*/
putchar(c[i]);/*一个个输出字符*/
}
fclose(fp);
return 1;
}
篇9：c经典笔试题
有一浮点型数组A,用C语言写一函数实现对浮点数组A进行降序排序,并输出结果,要求要以数组A作为函数的入口.(建议用冒泡排序法)
#include
#include
void BubbleSort(int arr, int n)
{
int i,j;
int exchange = 1;//交换标志,提高算法效率;
int temp;
for(i=0;i
{
exchange=0;//本趟排序开始前，交换标志应为假
for(j=0;j
{
if(arr[j+1] >arr[j])
{
temp=arr[j+1];
arr[j+1]=arr[j];
arr[j]=temp;
exchange=1; //发生了交换，故将交换标志置为真
}
}
if(!exchange) //本趟排序未发生交换，提前终止算法
return;
}
}
int main(int argc,char* argv)
{
int arr[5]={1,4,2,6,5};
int i;
BubbleSort(arr, 5);
printf(“after sort,arr is :\n”);
for(i=0;i<5;i++)
{
printf(“%3d”,arr[i]);
}
return 1;
}
篇10：c经典笔试题
写出二分查找的代码：
Int binary_search(int* arr,int key,int size)
{
Intmid;
Intlow=0;
Int high=size-1;
While(low<=high)
{
Mid=(low+high)/2;
If(arr[mid]>key)
High=mid-1;
ElseIf(arr[mid]
Low=mid+1;
Else
Return mid;
}
Return -1;
}
请编写一个C 函数，该函数在一个字符串中找到可能的最长的子字符串，该字符串是由同一字符组成的。
#include
#include
#include
int ChildString(char*p)
{
char* q=p;
int stringlen=0, i=0,j=1,len=0,maxlen=1;
//stringlen=strlen(p);
while(*q!='\0') //不能用strlen,求得长stringlen
{
stringlen++;
q++;
}
while( i< stringlen)
{
if(*(p+i)==*(p+j)&&j< stringlen)
{
len++; //统计子串长度
i++;
j++;
}
else
{
if(len>=maxlen) //统计最大子串长度
{
maxlen=len+1;
len=0;
}
else
len=0;
i++;
j++;
}
}
return maxlen;
}
int main(int argc,char* argv)
{
char arr[11];
int len;
printf(“please input chararr(10):\n”);
scanf(“%s”,arr);
len=ChildString(arr);
printf(“the len of childarr is:%d\n”,len);
return 1;
}
★笔试题
文档为doc格式
