范文为教学中作为模范的文章，也常常用来指写作的模板。常常用于文秘写作的参考，也可以作为演讲材料编写前的参考。那么我们该如何写一篇较为完美的范文呢？接下来小编就给大家介绍一下优秀的范文该怎么写，我们一起来看一看吧。
c语言基础笔试题篇一
a:本程序的main函数开始,到main函数结束
b:本程序文件的第一个函数开始,到本程序文件的最后一个函数结束
c:本程序的main函数开始,到本程序文件的最后一个函数结束
d:本程序文件的第一个函数开始,到本程序main函数结束
2.[单选题]在c语言中，要求运算数必须是整型的运算符是( d )
a:/
b:++
c:!=
d:%
3.[单选题]c语言中，逻辑“真”等价于( c )
a:大于零的数
b:大于零的整数
c:非零的数
d:非零的整数
4.[单选题]若希望当a的值为奇数时，表达式的值为“真”，a的值为偶数时，表达式的值为“假”。则以下不能满足要求的表达式为( c )
a:a%2 == 1
b:! (a%2==0)
c:! (a%2)
d:a%2
5.[单选题]以下程序的运行结果是( b )。
int main( void ){
int m = 5;
if ( m++ > 5) printf(“%d/n”, m);
else printf(“%d/n”, --m);
}
a:4
b:5
c:6
d:7
6.[单选题]以下对一维整型数组a的正确说明是( d )
a:int a(10)
b:int n = 10, a[n]
c:int n
scanf(“%d”, &n)
int a[n]
d:#define size 10
int a[size]
7.[单选题]若有说明：int a[3][4];则对a数组元素的非法引用是( d )
a:a[0][2*1]
b:a[1][3]
c:a[4-2][0]
d:a[0][4]
c语言基础笔试题篇二
1.[单选题]下面程序的功能是将已按升序排好序的两个字符串a和b中的字符，按升序归并到字符串c中，请为程序中的空白处选择适当的语句。第二空答案( d )
#include
int main(void)
{
char a[ ] = “acegikm”;
char b[ ] = “bdfhjlnpq”;
char c[80], *p;
int i = 0, j= 0, k = 0;
while( a[i] != /0 && b[j] != ‘/0 )
{
if ( a[i] < b[j] ) { ( ① ) }
else { ( ② ) }
k++;
}
c[k] = ‘/0;
if ( ③ ) p = b + j;
else p = a + i;
strcat ( c , p );
puts ( c );
}
a:c[k] = a[i]; i++
b:c[k] = b[j]; i++
c:c[k] = a[i]; j++
d:c[k] = b[j]; j++
2.[单选题]在一个c源程序文件中，若要定义一个只允许本源文件中所有函数使用的全局变量，则该变量需要使用的存储类别是( d )
a:extern
b:register
c:auto
d:static
3.[单选题]以下程序的正确运行结果是( d )。
#include
int f(int a);
int main(void)
{
int a = 2, i;
for( i = 0; i < 3; i++ ) printf(“%4d”,f(a));
}
int f(int a)
{
int b = 0;
static int c = 3;
b++; c++;
return(a+b+c);
}
a:7 7 7
b:7 10 13
c:7 9 11
d:7 8 9
4.[单选题]以下程序的运行结果为( b )。
void sub(int x, int y, int *z)
{ *z = y - x ; }
int main(void)
{
int a,b,c ;
sub(10, 5, &a) ;
sub(7, a, &b) ;
sub(a, b, &c) ;
printf( “%4d,%4d, %4d/n”,a,b,c);
}
a:5, 2, 3
b:-5, -12, -7
c:-5, -12, -17
d:5, -2, -7
5.[单选题]有如下语句int a = 10, b = 20, *p1, *p2; p1 = &a p2 = &b变量与指针的关系如图1所示;若要实现图2所示的存储结构，可选用的赋值语句为( 没图 可能是 b或a )
a:*p1 = *p2
b:p1 = p2
c:p1 = *p2
d:*p1 = p2
6.[单选题]若已建立下面的链表结构，指针p、q分别指向图中所示结点，则不能将q所指的结点插入到链表末尾的一组语句是( )
a:q -> next = null; p = p -> next; p -> next = q
b:p = p -> next; q -> next = p -> next; p -> next = q
c:p = p -> next; q -> next = p; p -> next = q
d:p = (*p).next; (*q).next = (*p).next; (*p).next = q
7.[单选题]以下程序的功能是：读入一行字符(如：a，b，... y，z)，按输入时的逆序建立一个链接式的结点序列，即先输入的位于链表尾(如下图)，然后再按输入的相反顺序输出，并释放全部结点。请在空白处为程序选择适当的代码。 第一空答案( b )
#include
#define getnode(type) ① malloc(sizeof(type))
int main(void)
{
struct node{
char info;
struct node *link;
}*top,*p;
char c;
top = null;
while( ( c = getchar( ) ② )
{
p = getnode ( struct node );
p -> info = c;
p -> link = top;
top = p;
}
while ( top )
{
③ ;
top = top -> link;
putchar ( p -> info );
free ( p );
}
}
a:(type)
b:(type *)
c:type
d:type *
8.[单选题]以下程序的功能是：读入一行字符(如：a，b，... y，z)，按输入时的逆序建立一个链接式的结点序列，即先输入的位于链表尾(如下图)，然后再按输入的相反顺序输出，并释放全部结点。请在空白处为程序选择适当的代码。第二空答案(d )
#include
#define getnode(type) ① malloc(sizeof(type))
int main(void)
{
struct node{
char info;
struct node *link;
}*top,*p;
char c;
top = null;
while( ( c = getchar( ) ② )
{
p = getnode ( struct node );
p -> info = c;
p -> link = top;
top = p;
}
while ( top )
{
③ ;
top = top -> link;
putchar ( p -> info );
free ( p );
}
}
a:==/0
b:!=/0
c:==/n
d:!=/n
9.[单选题]以下程序的功能是：读入一行字符(如：a，b，... y，z)，按输入时的逆序建立一个链接式的结点序列，即先输入的位于链表尾(如下图)，然后再按输入的相反顺序输出，并释放全部结点。请在空白处为程序选择适当的代码。第三空答案( b)
#include
#define getnode(type) ① malloc(sizeof(type))
int main(void)
{
struct node{
char info;
struct node *link;
}*top,*p;
char c;
top = null;
while( ( c = getchar( ) ② )
{
p = getnode ( struct node );
p -> info = c;
p -> link = top;
top = p;
}
while ( top )
{
③ ;
top = top -> link;
putchar ( p -> info );
free ( p );
}
}
a:top = p
b:p = top
c:p == top
d:top == p
10.[单选题]以下程序的输出结果是( c )
#include
#define m 5
#define n m+m
main
{
int k;
k=n*n*5; printf(“%d/n”,k);
}
a:500
b:125
c:55
d:100
c语言基础笔试题篇三
1.[单选题]若二维数组a有m列，则计算任一元素a[i][j]在数组中位置的公式为( a )
a:i * m + j
b:j * m + i
c:i * m + j - 1
d:i * m + j + 1
2.[单选题]以下程序的功能是将字符串s中所有的字符c删除，那么空白处缺少的语句为：( a )。
#include
int main(void)
{
char s[80] ;
int i, j ;
gets(s) ;
for ( i = j = 0 ; s [i] != ‘/0 ; i++ )
if ( s [i] != ‘c )
;
s [ j ] = ‘/0 ;
puts ( s ) ;
return 0 ;
}
a: s [ j++] = s [ i ]
b:s [ ++j ] = s [ i ]
c:s [ j ] = s [ i ]; j++
d:s [ j ] = s [ i ]
3.[单选题]下面程序的功能是将已按升序排好序的两个字符串a和b中的字符，按升序归并到字符串c中，请为程序中的空白处选择适当的语句。 第一空答案( a )
#include
int main(void)
{
char a[ ] = “acegikm”;
char b[ ] = “bdfhjlnpq”;
char c[80], *p;
int i = 0, j= 0, k = 0;
while( a[i] != /0 && b[j] != ‘/0 )
{
if ( a[i] < b[j] ) { ( ① ) }
else { ( ② ) }
k++;
}
c[k] = ‘/0;
if ( ③ ) p = b + j;
else p = a + i;
strcat ( c , p );
puts ( c );
}
a:c[k] = a[i]; i++
b:c[k] = b[j]; i++
c:c[k] = a[i]; j++
d:c[k] = a[j]; j++
c语言基础笔试题篇四
1.编写my_strcpy函数，实现与库函数strcpy类似的功能，不能使用任何库函数;
答：char *strcpy(char *strdest, const char *strsrc)
{
if ( strdest == null || strsrc == null)
return null ;
if ( strdest == strsrc)
returnstrdest ;
char *tempptr = strdest ;
while( (*strdest++ = *strsrc++) != ‘’);
returntempptr ;
}
2. 头文件中的ifndef/define/endif的作用?
答：防止该头文件被重复引用。
3. #i nclude与#i nclude “file.h”的区别?
答：前者编译器从标准库路径开始搜索file.h，而后者编译器从用户的工作路径开始搜索file.h。
4. 在c++ 程序中调用被c 编译器编译后的函数，为什么要加extern“c”?
答：extern是c/c++语言中表明函数和全局变量作用范围(可见性)的关键字，其声明的函数和变量可以在本模块或其它模块中使用。
通常，在模块的头文件中对本模块提供给其它模块引用的函数和全局变量以关键字extern声明。
5. 面向对象的三个基本特征，并简单叙述之?
答：1)封装：将客观事物抽象成类，每个类对自身的数据和方法实行protection(private, protected,public)
2)继承：实现继承(指使用基类的属性和方法而无需额外编码的能力)、可视继承(子窗体使用父窗体的外观和实现代码)、接口继承(仅使用属性和方法，实现滞后到子类实现)。
3)多态：允许将子类类型的指针赋值给父类类型的指针。
6. 重载(overload)和重写(overried，有的书也叫做“覆盖”)的区别?
答：从定义上来说：
重载：是指允许存在多个同名函数，而这些函数的参数表不同(或许参数个数不同，或许参数类型不同，或许两者都不同)。
重写：是指子类重新定义复类虚函数的方法。
从实现原理上来说：
重载：编译器根据函数不同的参数表，对同名函数的名称做修饰，然后这些同名函数就成了不同的函数。
重写：当子类重新定义了父类的虚函数后，父类指针根据赋给它的不同的子类指针，动态的调用属于子类的该函数，这样的函数调用在编译期间是无法确定的(调用的子类的虚函数的地址无法给出)。
7. 多态的作用?
答：主要是两个：1)隐藏实现细节，使得代码能够模块化;扩展代码模块，实现代码重用;2)接口重用，为了类在继承和派生的时候，保证使用家族中任一类的实例的某一属性时的正确调用。
8. 分别写出bool,int,float,指针类型的变量a 与“零”的比较语句。
答：bool :if ( !a ) or if(a)
int :if ( a ==0)
float :const expression exp = 0.000001
if ( a < exp && a >-exp)
pointer : if ( a != null) or if(a == null)
9. 请说出const与#define 相比，有何优点?
答案：1) const 常量有数据类型，而宏常量没有数据类型。编译器可以对前者进行类型安全检查。而对后者只进行字符替换，没有类型安全检查，并且在字符替换可能会产生意料不到的错误。
2) 有些集成化的调试工具可以对const 常量进行调试，但是不能对宏常量进行调试。
10.简述数组与指针的区别?
数组要么在静态存储区被创建(如全局数组)，要么在栈上被创建。指针可以随时指向任意类型的内存块。
(1)修改内容上的差别
char a = “hello”;
a[0] = ‘x’;
char *p = “world”; // 注意p 指向常量字符串
p[0] = ‘x’; // 编译器不能发现该错误，运行时错误
(2) 用运算符sizeof 可以计算出数组的容量(字节数)。sizeof(p),p 为指针得到的是一个指针变量的字节数，而不是p 所指的内存容量。c++/c 语言没有办法知道指针所指的内存容量，除非在申请内存时记住它。注意当数组作为函数的参数进行传递时，该数组自动退化为同类型的指针。
char a = “hello world”;
char *p = a;
cout< cout< 计算数组和指针的内存容量
voidfunc(char a[100])
{
cout< }
c语言基础笔试题篇五
1.变量的声明和定义有什么区别?
答：声明变量不分配空间，定义变量要分配空间。声明主要是告诉编译器,后面的引用都按声明的格式。定义其实包含了声明的意思,同时要分配内存空间。
2. 解释堆和栈的区别。
答：堆(heap)——一般由程序员分配释放，若程序员不释放，程序结束时可能由os回收。注意它与数据结构中的堆是两回事，分配方式倒是类似于链表。速度比较慢，而且容易产生内存碎片,不过用起来最方便。
栈(stack)——由编译器自动分配释放，存放函数的参数值，局部变量的值等。其操作方式类似于数据结构中的栈。由系统自动分配，速度较快。但程序员是无法控制的。
3. const的作用是什么?
答：(1)可以定义const常量
(2)const可以修饰函数的参数、返回值，甚至函数的定义体。被const修饰的东西都受到强制保护，可以预防意外的变动，能提高程序的健壮性。
4. 下列哪两个是等同的
int b;
a constint* a = &b //指向常量的指针，不能通过指针改变b，但指针的地址可以改变。
b const* int a = &b// 指针的地址不可以改变，但可以通过指针改变b的值
c constint* const a = &b //指针指向的值，和指针本身的地址都不能改变
d intconst* const a = &b//与c相同
5. 完成程序，实现对数组的降序排序
#include
void sort(int array );
int main
{
int array={45，56，76，234，1，34，23，2，3}; //数字任//意给出
sort( array );
return 0;
}
void sort( int array )
{____________________________________
inti,j,k;
for(i=1;i<=7;i++) { if(array[i]>array[i-1])
{
k=array[i];
j=i-1;
do
{
array[j+1]=array[j];
j– ;
}
while(k>array[j]&&j>=0);
array[j+1]=k;
}
}
—————————————————–
}
6. int i=(j=4,k=8,l=16,m=32); printf(“%d”, i); 输出是多少?
答：相当于 i=j=4;i=k=8;i=l=16;i=m=32; 故最后i=32;
7. 请简述以下两个for循环的优缺点(5分)
1)for (i=0; i {
if (condition)
dosomething;
else
dootherthing;
}
2)if (condition)
{
for (i=0; i dosomething;
}
else
{
for (i=0; i 0)
{
*psto++ = *psfrom++;
}
returnpvto;
}
8 .c++里面如何声明const void f(void)函数为c程序中的库函数?
答：在该函数前添加extern “c”声明。由于编译后的名字不同，c++程序不能直接调用c 函数。
9. 请写出下面代码在 32 位平台上的运行结果，并说明sizeof的性质：
#include
#include
int main(void)
{
char a[30];
char *b = (char *)malloc(20 * sizeof(char));
printf(“%dn”, sizeof(a));
printf(“%dn”, sizeof(b));
printf(“%dn”, sizeof(a[3]));
printf(“%dn”, sizeof(b+3));
printf(“%dn”, sizeof(*(b+4)));
return 0 ;
}
答：在32位系统下(如win32)，指针长度为32位。a是一个有30个元素的字符型数组;b是一个字符串指针;a[3]是字符型;b+3是指针;*(b+4)是字符型。
因此输出： 30、4、1、4、1
c语言基础笔试题篇六
1. c++中，关键字struct和class的区别仅仅在于：
struct定义的类的缺省成员为公有的，而class定义的类的缺省成员为私有的;
2. 头文件的作用是什么?
答：1)通过头文件来调用库功能。2)头文件能加强类型安全检查。
3. c++函数中值的传递方式有哪几种?
答：c++函数的三种传递方式为：值传递、指针传递和引用传递。
4. 内存的分配方式的分配方式有几种?
答：1)从静态存储区域分配。内存在程序编译的时候就已经分配好，这块内存在程序的整个运行期间都存在。例如全局变量。
2)在栈上创建。在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集中，效率很高，但是分配的内存容量有限。
3)从堆上分配，亦称动态内存分配。程序在运行的时候用malloc或new申请任意多少的内存，程序员自己负责在何时用free或delete释放内存。动态内存的生存期由我们决定，使用非常灵活，但问题也最多。
5. 设计函数intatoi(char *s)。
答：intatoi (char *s)
{
int i = 0,sum = 0,sign; //输入的数前面可能还有空格或制表符应加判断
while(*s==”||*s==’t’)
{
i++;
}
sign = (*s==’-)?-1:1;
if(*s==’-|| *s==’+)
{
i++;
}
while(*s!=’′)
{
sum = *s-’0′+sum*10;
i++;
}
return sign*sum;
}
6. 编写strcat函数(6分)
已知strcat函数的原型是char *strcat (char *strdest, const char *strsrc);
其中strdest是目的字符串，strsrc是源字符串。
(1)不调用c++/c 的字符串库函数，请编写函数strcat
答：
char * __cdeclstrcat(char * dst, const char * src)
{
char * cp = dst;
while( *cp )
cp++; /* find end of dst */
while( *cp++ = *src++ ) ; /* copy src to end of dst */
return(dst ); /* return dst */
}
(2)strcat能把strsrc的内容连接到strdest，为什么还要char * 类型的返回值?
答：方便赋值给其他变量。
7. mfc中cstring是类型安全类么?
答：不是，其它数据类型转换到cstring可以使用cstring的成员函数format来转换
8.函数模板与类模板有什么区别?
答：函数模板的实例化是由编译程序在处理函数调用时自动完成的，而类模板的实例化必须由程序员在程序中显式地指定。
9. 写一个“标准”宏min，这个宏输入两个参数并返回较小的一个。
答：#define min(a,b) ((a) <= (b) ? (a) : (b)) 宏的副作用(与某些函数的混淆)：least = min(*p++, b)。宏定义#define min(a,b) ((a) <= (b) ? (a) : (b))对min(*p++, b)的作用结果是：
((*p++) <= (b) ? (*p++) : (*p++))
10. 嵌入式系统中经常要用到无限循环，你怎么样用c编写死循环呢?
答：while(1)或者for(;;)
c语言基础笔试题篇七
c笔试题
1) 的内容(例如)：
12
34
56
：
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(“”,”r”);
if(fp1 == null)
{printf(“error1″);
exit(-1);
}
fp2 = fopen(“”,”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,”%dn”,a[j]);
fclose(fp1);
fclose(fp2);
return 0;
}
第二题.
#include
int main(void)
{unsigned long int i,j,k;
printf(“please input the numbern”);
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 + %dn”,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 = = ‘′ )
return;
inverse( p+1 );
printf( “%c”, *p );
}
int main(int argc, char *argv[])
{
inverse(“abc″);
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
你可以参考一下指针运算的细节
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!=) //不能用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:%dn”,len);
return 1;
}
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;
}
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 openedn”);
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 openedn”);
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;
}
c语言基础笔试题篇十一
c语言基础笔试题
1、c语言程序的基本单位是____ a) 程序行 b) 语句 c) 函数 d) 字符、c、1
2、c语言程序的三种基本结构是____ a、顺序结构，选择结构，循环结构 b、递归结构，循环结构，转移结构 c、嵌套结构，递归结构，顺序结构 d、循环结构，转移结构，顺序结构、a、1
3、c语言规定，程序中各函数之间 a) 既允许直接递归调用也允许间接递归调用 b) 不允许直接递归调用也不允许间接递归调用 c) 允许直接递归调用不允许间接递归调用 d) 不允许直接递归调用允许间接递归调用、a、1
4、c语言中可处理的文件类型是( ) a) 文本文件和数据文件 b)文本文件和二进制文件 c) 数据文件和二进制文件 d)数据代码文件、b、1
5、c语言可执行程序的开始执行点是( ) a) 程序中第一条可执行语句 b) 程序中第一个函数 c) 程序中的main函数 d) 包含文件中的第一个函数、c、1
6、c语言提供的合法的数据类型关键字是 a)double b) short c) integer d) char、b、1
7、c语言中,运算对象必须是整型数的运算符是 a) % b) c) %和 d) * *、a、1
8、c语言中函数返回值的类型是由( )决定， a) return语句中的表达式类型 b) 调用函数的主调函数类型 c) 调用函数时临时 d) 定义函数时所指定的函数类型、d、1
9、c语言中数组名作为参数传递给函数，作为实在参数的数组名被处理为_____。 a、 该数组的长度。 b、 该数组的元素个数。 c、 该数组中各元素的值。 d、 该数组的首地址。、d、1
10、c语言中数组下标的下限是________。 a、1 b、0 c、视具体情况 d、无固定下限、b、1
11、c语言中提供的合法关键字是____ a、swith b、cher c、case d、default、d、1
12、c语言中文件的.存取方式是________。 a、顺序存取 b、随机存取 c、顺序存取、随机存取均可 d、顺序存取、随机存取均不可、c、1
13、c语言中最简单的数据类型包括 a) 整型、实型、逻辑型 b) 整型、实型、字符型 c) 整型、字符型、逻辑型 d) 整型、实型、逻辑型、字符型、b、1
14、sizeof(float)是( ) a) 一种函数调用 b) 一个不合法的表示形式 c) 一个整型表达式 d) 一个浮点表达式、c、1
15、x、y、z被定义为int型变量，若从键盘给x、y、z输入数据，正确的输入语句是 a) input x,y,z; b) scanf(“%d%d%d”,&x,&y,&z); c) scanf(“%d%d%d”,x,y,z); d) read(“%d%d%d”,&x,&y,&z);、b、1
16、表达式:10!=9的值是 a) true b) 非零值 c) 0 d) 1、d、1
17、表示关系x<=y<=z的c语言表达式为 a) (x<=y)&&(y<=z) b) (x<=y)and(y<=z) c) (x<=y<=z) d) (x<=y)&(y<=z)、a、1
18、程序片段：在tc20中, int i=65536; printf(“%d”,i);的输出结果是____ a) 65536 b) 0 c) 有语法错误，无输出结果 d) -1、b、1
19、当调用函数时，实参是一个数组名，则向函数传送的是____ a) 数组的长度 b) 数组的首地址 c) 数组每一个元素的地址 d) 数组每个元素中的值、b、1
20、对嵌套子程序调用说法正确的是____。 a、 外层子程序可以调用所有的内层子程序 b、 内层了程序只可以调用包含本身的外层子程序，不可以隔层调用 c、 外分程序必须能完全套住内分程序 d、 以上说法均不正确、c、1
21、对于基类型相同的两个指针变量之间，不能进行的运算是 a) < b) = c) + d) -、c、1
22、合法的c语言中，合法的长整型常数是 a) t b) “a” c) 65 d) a、a、1
23、假定int类型变量占用两个字节，其有定义：int x[10]={0,2,4};，则数组x在内存中所占字节数是 a) 3 b) 6 c) 10 d) 20、d、1
24、假定有以下变量定义: int k=7 ,x=12; 则能使值为3的表达式是 a x%=(k%=5) b x%=(k-k%5) c x%=k-k%5 d (x%=k)-(k%=5)、d、1
25、请读程序片段(字符串内没有空格): printf(“%d”,strlen(“ats0121”));的输出结果是 a) 11 b) 10 c) 9 d) 8 、c、1
26、请选出合法的c语言赋值语句 a) a=b=58 b) i++; c) a=58,b=58 d) k=int(a+b);、b、1
27、若a为int类型，且其值为3，则执行完表达式a+=a-=a*a后，a的值是 a) -3 b) 9 c) -12 d) 6、c、1
28、若int类型占两个字节，则以下语句输出为________。 int k=-1; printf(“%d,u%”,k,k); a、-1,-1 b、-1,65536 c、-1,32768 d、-1,65535、d、1
29、若变量a是int类型，并执行了语句：a=‘a+1、6;，则正确的叙述是 a) a的值是字符c b) a的值是浮点型 c) 不允许字符型和浮点型相加 d) a的值是字符‘a’的ascii值加上1，
、d、1
30、若变量已正确说明为float类型，要通过语句scanf(“%f %f %f ”,&a,&b,&c);给a赋于10、0，b赋予22、0，c赋予33、0，不正确的输入形式是： a) 10 b) 10、0,22、0,33、0 22 33 c) 10、0 d) 10 22 22、0 33、0 33、b、1
31、若要求在if后一对圆括号中表示a不等于0的关系,则能正确表示这一关系的表达式为 a) a0 b) !a c) a=0 d) a、b、1
32、若已定义x和y为double类型，则表达式:x=1，y=x+3/2的值是 a)1 b)2 c)2、0 d)2、5、c、1
33、若有定义：int a=8，b=5，c;，执行语句c=a/b+0、4;后，c的值为 a) 1、4 b) 1 c) 2、0 d) 2、b、1
34、若有定义:int x,y;char a,b,c;并有以下输入数据(此处< cr> 代表换行符，/u代表空格): 1u2 aubuc 则能给x赋整数1，给y赋整数2，给a赋字符a，给b赋字符b，给c赋字符c 的正确程序段是 a) scanf(“x=%d y+%d”,&x,&y);a=getchar;b=getchar();c=getchar(); b) scanf(“%d %d”,&x,&y);a=getchar();b=getchar();c=getchar(); c) scanf(“%d%d%c%c%c,&x,&y,&a,&b,&c); d) scanf(“%d%d%c%c%c%c%c%c:&x,&y,&a,&a,&b,&b,&c,&c);、 d、1
35、若有定义和语句: char s[10]:s=”abcd”;printf(“%s”,s); 则结果是(以下u代表空格) a) 输出abcd b) 输出a c) 输出abcduuuuu d) 编译不通过、d、1
36、若有以下程序段， int c1=1,c2=2,c3; c3=1、0/c2*c1; 则执行后，c3中的值是 a) 0 b) 0、5 c) 1 d) 2、a、1
37、若有以下定义: char a; int b; float c; double d; 则表达式a*b+d-c值的类型为 a) float b) int c) char d) double、d、1
38、若有以下定义和语句 char c1=’b,c2=’e; printf(“%d,%c”,c2-c1,c2-’a+”a”); 则输出结果是: a)2,m b)3,e c)2,e d)输出项与对应的格式控制不一致，输出结果不确定、b、1
39、若有以下函数调用语句： fun(a+b,(x,y),fun(n+k,d,(a,b)));在此函数调用语句中实参的个数是 a)3 b)4 c)5 d)6、a、1
40、若执行下面的程序时从键盘上输入3和4，则输出是____ a) 14 b) 16 c) 18 d) 20 main( ) { int a,b,s; scanf(“%d %d”,&a,&b); s=a; if(a、b、1
41、若执行下面的程序时从键盘上输入5，则输出是 a) 7 b) 6 c) 5 d) 4 main() { int x; scanf(“%d”,&x); if(x++>5) printf(“%d”,x); else printf(“%d”,x–);}、b、1
42、若执行以下程序时从键盘上输入9，则输出结果是 a) 11 b) 10 c) 9 d) 8 main( ) { int n; scanf(“%d”,&n); if(n++、b、1
43、设 a、b、c、d、m、n均为 int型变量，且 a=5、b=6、c=7、d=8、m=2、n=2，则逻辑表达式 (m=a>b)&&(n=c>d)运算后，n的值为____ a) 0 b) 1 c) 2 d) 3、c、1
44、设 int a=12，则执行完语句 a+=a-=a*a后，a的值是 a) 552 b) 264 c) 144 d) -264、d、1
45、设 int b=2;表达式(b>>2)/(b>>1)的值是 a) 0 b) 2 c) 4 d) 8、a、1
46、设a,b和c都是int型变量，且a=3,b=4,c=5,则下列表达式中，值为0的表达式是________ a)’a&&’b’ b)a<=b c)a||b+c&&b-c d)!((a
47、设x、y、z和k都是int型变量,则执行表达式:x=(y=4,z=16,k=32)后,x的值为 a 4 b 16 c 32 d 52、c、1
48、设x=3,y=-4,z=6，写出表达式的结果。 !(x>y)+(y!=z)||(x+y)&&(y-z) a、0 b、1 c、-1 d、6、b、1
49、设x和y均为int 型变量,则以下语句:x+=y;y=x-y;y=x-y;x-=y;的功能是 a、把x 和y按从大到小排列 b、把x和y按从小到大排列 c、无确定结果 d、交换x和y中的值、d、1
50、设有 int x=11; 则表达式 (x++ * 1/3) 的值是 a) 3 b) 4 c) 11 d) 12、a、1
