笔试题

在C语言中，要求运算数必须是整型的运算符是( D )
A:/
B:++
C:!=
D:%

若希望当A的值为奇数时，表达式的值为"真"，A的值为偶数时，表达式的值为"假"。则以下不能满足要求的表达式为( C )
A:A%2 == 1
B:! (A%2==0)
C:! (A%2)
D:A%2

 

以下程序的运行结果是( 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

若有说明：int a[3][4]；则对a数组元素的非法引用是( D )
A:a[0][2*1]
B:a[1][3]
C:a[4-2][0]
D:a[0][4]

以下程序的功能是将字符串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 ]

以下程序的正确运行结果是( 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

若有以下语句

1. typedef struct S {

2. int g;

3. char h;

4. } T;

以下叙述中正确的是（ ）。
A．可用T定义结构体变量
B．可用S定义结构体变量
C．S是struct类型的变量
D．T是struct S类型的变量

若执行以下程序时从键盘上输入3和4，则输出的结果是（ ）。

main()

{

int a,b,s;

scanf("%d %d",&a,&b);

s=a;

if(a<b)s=b;

s*=s;

printf("%d\n",s);

}

A．14 
B．16 
C．18 
D．20

执行以下语句：x+=y；y=x-y；x-=y；的功能是（D）。 
A:把x和y按从大到小排列 
B:把x和y按从小到大排列 
C:无确定结果 
D:交换x和y中的值

在“文件包含”预处理语句的使用形式中，当#include后面的文件用了“”（B） 
时，寻找被包含文件的方式是（）。 
A:直接按系统设定的标准方式搜索目录 
B:先在源程序所在目录搜索，再按系统设定的标准方式搜索 
C:仅仅搜索源程序所在目录 
D:仅仅搜索当前目录 

设有以下宏定义:

define N 3

define Y(n) ( (N+1)*n)

则执行语句:z=2 * (N+Y(5+1));后,z的值为（C）。 
A:出错 
B:42 
C:48 
D:54 

以下叙述正确的是（A）。 
A:C程序中各函数之间既允许直接递归调用，也允许间接递归调用 
B:C程序中各函数之间不允许直接递归调用，也不允许间接递归调用 
C:C程序中各函数允许直接递归调用,不允许间接递归调用 
D:C程序中各函数之间不允许直接递归调用，允许间接递归调用

.下面有关for循环的正确描述是 （D）。 
A:for循环只能用于循环次数已经确定的情况 
B:for循环是先执行循环体语句，后判断表达式 
C:在for循环中，不能用break语句跳出循环体 
D:for循环的循环体语句中，可以包含多条语句，但必须用花括号括起来 

字符数组的环形移动如何实现？

要求：函数原型如下：

char * RightLoopMove(char *pstr, unsigned short steps)

参数1：char *pstr 表示需要循环移动的字符串

参数2：unsigned short steps 表示向右移动几个字符

返回值类型：char *  移动后的字符串

示例代码如下：

#include <stdlib.h>
#include <string.h>
#include <stdio.h>

char * RightLoopMove(char *pstr, unsigned short steps)
{
     if (NULL == pstr)
         return NULL;
    char tmp;
    int i;
     int len = strlen(pstr);
     steps %= len;
     while (steps-- > 0)
     {
        tmp = *(pstr + len -1);
         for (i = len - 2;i >= 0;--i)
         {
             pstr[i + 1] = pstr[i];
        }
         pstr[0] = tmp;
     }
    return pstr;
}
int main(int argc,char *argv[])
{
    int num=atoi(argv[2]);
    char *ret = RightLoopMove(argv[1],num);
    printf("%s",ret);

}

请说出static和const关键字尽可能多的作用

static关键字至少有下列n个作用：
　　（1）函数体内static变量的作用范围为该函数体，不同于auto变量，该变量的内存只被分配一次，因此其值在下次调用时仍维持上次的值；
　　（2）在模块内的static全局变量可以被模块内所用函数访问，但不能被模块外其它函数访问；
　　（3）在模块内的static函数只可被这一模块内的其它函数调用，这个函数的使用范围被限制在声明它的模块内；
　　（4）在类中的static成员变量属于整个类所拥有，对类的所有对象只有一份拷贝；
　　（5）在类中的static成员函数属于整个类所拥有，这个函数不接收this指针，因而只能访问类的static成员变量。

　　const关键字至少有下列n个作用：
　　（1）欲阻止一个变量被改变，可以使用const关键字。在定义该const变量时，通常需要对它进行初始化，因为以后就没有机会再去改变它了；
　　（2）对指针来说，可以指定指针本身为const，也可以指定指针所指的数据为const，或二者同时指定为const；
　　（3）在一个函数声明中，const可以修饰形参，表明它是一个输入参数，在函数内部不能改变其值；
　　（4）对于类的成员函数，若指定其为const类型，则表明其是一个常函数，不能修改类的成员变量；
　　（5）对于类的成员函数，有时候必须指定其返回值为const类型，以使得其返回值不为“左值”。例如：

const classA operator*(const classA& a1,const classA& a2);

　　operator*的返回结果必须是一个const对象。如果不是，这样的变态代码也不会编译出错：

classA a, b, c; (a * b) = c; // 对a*b的结果赋值

整数反转

#include <stdlib.h>
long ReverIong(long num)
{
    long r_num;

while(num > 0)

{

r_num = r_num*10 + (num%10);

num = num/10;

}
}

int main(int argc,char *argv[])
{
    //long num=atoi(argv[1]);
    long num=123456;
    long r_num= ReverIong(num);
    printf("%l",r_num);

}