欢迎来到个人简历网!永久域名:gerenjianli.cn (个人简历全拼+cn)
当前位置:首页 > 面试问题>c语言面试题

c语言面试题

2022-05-28 08:56:13 收藏本文 下载本文

“摸凹猫摸头长不高”通过精心收集,向本站投稿了11篇c语言面试题,以下是小编收集整理后的c语言面试题,仅供参考,希望对大家有所帮助。

c语言面试题

篇1:c语言面试题及答案

11. 指向常量的指针和常指针的区别

答案:指向常量的指针所指向的内容不能被修改但能够指向其它的量,而常指针是指向的内容可以被修改但指针不能再指向其它地方。

12. if (a=b)

printf(“a==b”)

else

printf(“a!=b”);

输出结果为:

A.a==b B.a!=b C.不一定 D.不能运行

答案:不一定,这要根据b的内容来决定。通常再编程时不要使用此类的赋值语句。

13.在内联函数中使用static变量,比如

inline test

{ static couter = 0;

counter++;

}

会有什么问题?

答案:会造成多次定义该变量,因此再内联函数中禁止定义静态变量

14. F是一个结构类型,有如下定义:

F f1,f2;

问:f1=f2;语句是否成立?

答案:该语句成立,不过有的编译器不支持。实际上编译器也是用内存拷贝函数来实现的。

15.全局变量、局部变量、模块变量在内存空间中如何存放?(数据区or栈空间?)

答案:全局变量在全局空间分配,局部变量在栈空间分配,模块变量在全局空间分配。

16.struct A{

......

......

union {

int x;

.....

};

}

struct A a;

问:a.x这样的表示法是否成立?

答案:成立

如果结构定义改为如下定义

.struct A{

......

int x;

union {

int x;

.....

};

}

那a.x表示法是否成立?

答案:不成立,编译时会报x变量重定义

17. #define REDEF(name,arg1,arg...)

_##name (arg1,##arg)

问:以下两个语句宏展开的结果

REDEF(test_fn1,int a,int b);

REDEF(test_fn2,int a);

答案:

_test_fn1(int a ,int b)

_test_fn2(int a);

注意:在VC中不支持,gcc才支持该参数宏函数。

18. fnxxxx_max(char str[])

{

putchar str[0];

str++; //(1)

printf(“%s”,str);

}

main()

{

char str[20]={“ABCDEFG”};

fnxxxx_max(str);

str++; //(2)

printf(“%s”,str);

}

问:语句(1)和语句(2)是否成立?

答案:语句(1)成立,语句(2)不成立

19.#define SRR 0x001;

#define SRT 0x002;

#define SRI 0x0900;

EVENT = SRR|SRT|SRI

问:上面的语句有什么问题?EVENT的值会是多少?

答案:宏展开后变为:

EVENT = 0x001; 0x002;0x0900;

因此EVENT的值为0x001,所以在编程时一定要小心,一定不要在常量宏定义的后面加上分号。

篇2:C语言面试题大12

1、用指针的方法,将字符串“ABCD1234efgh”前后对调显示

#include

#include

#include

int main()

{

char str[] = “ABCD1234efgh”;

int length = strlen(str);

char * p1 = str;

char * p2 = str + length - 1;

while(p1 < p2)

{

char c = *p1;

*p1 = *p2;

*p2 = c;

++p1;

--p2;

}

printf(“str now is %s”,str);

system(“pause”);

return 0;

}

2、有一分数序列:1/2,1/4,1/6,1/8……,用函数调用的方法,求此数列前20项的和

#include

double getValue()

{

double result = 0;

int i = 2;

while(i < 42)

{

result += 1.0 / i;//一定要使用1.0做除数,不能用1,否则结果将自动转化成整数,即0.000000

i += 2;

}

return result;

}

int main()

{

printf(“result is %f”, getValue());

system(“pause”);

return 0;

}

Top

回复人:free131(白日?做梦!) ( ) 信誉:100 -4-17 10:18:33 得分:0

?

有一个数组a[1000]存放0--1000;要求每隔二个数删掉一个数,到末尾时循环至开头继续进行,求最后一个被删掉的数的原始下标位置,

以7个数为例:

{0,1,2,3,4,5,6,7} 0-->1-->2(删除)-->3-->4-->5(删除)-->6-->7-->0(删除),如此循环直到最后一个数被删除。

方法1:数组

#include

using namespace std;

#define null 1000

int main()

{

int arr[1000];

for (int i=0;i<1000;++i)

arr[i]=i;

int j=0;

int count=0;

while(count<999)

{

while(arr[j%1000]==null)

j=(++j)%1000;

j=(++j)%1000;

while(arr[j%1000]==null)

j=(++j)%1000;

j=(++j)%1000;

while(arr[j%1000]==null)

j=(++j)%1000;

arr[j]=null;

++count;

}

while(arr[j]==null)

j=(++j)%1000;

cout<<< p>

return 0;

}方法2:链表

#include

using namespace std;

#define null 0

struct node

{

int data;

node* next;

};

int main()

{

node* head=new node;

head->data=0;

head->next=null;

node* p=head;

for(int i=1;i<1000;i++)

{

node* tmp=new node;

tmp->data=i;

tmp->next=null;

head->next=tmp;

head=head->next;

}

head->next=p;

while(p!=p->next)

{

p->next->next=p->next->next->next;

p=p->next->next;

}

cout

return 0;

}

方法3:通用算法

#include

#define MAXLINE 1000 //元素个数

/*

MAXLINE 元素个数

a[] 元素数组

R[] 指针场

suffix 下标

index 返回最后的下标序号

values 返回最后的下标对应的值

start 从第几个开始

K 间隔

*/

int find_n(int a[],int R[],int K,int& index,int& values,int s=0) {

int suffix;

int front_node,current_node;

suffix=0;

if(s==0) {

current_node=0;

front_node=MAXLINE-1;

}

else {

current_node=s;

front_node=s-1;

}

while(R[front_node]!=front_node) {

printf(“%d”,a[current_node]);

R[front_node]=R[current_node];

if(K==1) {

current_node=R[front_node];

continue;

}

for(int i=0;i< p>

front_node=R[front_node];

}

current_node=R[front_node];

}

index=front_node;

values=a[front_node];

return 0;

}

int main(void) {

int a[MAXLINE],R[MAXLINE],suffix,index,values,start,i,K;

suffix=index=values=start=0;

K=2;

for(i=0;i

a[i]=i;

R[i]=i+1;

}

R[i-1]=0;

find_n(a,R,K,index,values,2);

printf(“the value is %d,%d”,index,values);

return 0;

}

试题:

void test2()

{

char string[10], str1[10];

int i;

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

{

str1[i] = “a”;

}

strcpy( string, str1 );

}

解答:对试题2,如果面试者指出字符数组str1不能在数组内结束可以给3分;如果面试者指出strcpy(string, str1)调用使得从str1内存起复制到string内存起所复制的字节数具有不确定性可以给7分,在此基础上指出库函数strcpy工作方式的给10 分;

str1不能在数组内结束:因为str1的存储为:{a,a,a,a,a,a,a,a,a,a},没有“”(字符串结束符),所以不能结束

strcpy( char *s1,char *s2)他的工作原理是,扫描s2指向的内存,逐个字符付到s1所指向的内存,直到碰到“”,因为str1结尾没有“”,所以具有不确定性,不知道他后面还会付什么东东,

正确应如下

void test2()

{

char string[10], str1[10];

int i;

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

{

str1[i] = “a”+i; //把abcdefghi赋值给字符数组

}

str[i]=“”;//加上结束符

strcpy( string, str1 );

}

第二个code题是实现strcmp

int StrCmp(const char *str1, const char *str2)

做是做对了,没有抄搞,比较乱

int StrCmp(const char *str1, const char *str2)

{

assert(str1 && srt2);

while (*str1 && *str2 && *str1 == *str2) {

str1++, str2++;

}

if (*str1 && *str2)

return (*str1-*str2);

elseif (*str1 && *str2==0)

return 1;

elseif (*str1 = = 0 && *str2)

return -1;

else

return 0;

}

int StrCmp(const char *str1, const char *str2)

{

//省略判断空指针(自己保证)

while(*str1 && *str1++ = = *str2++);

return *str1-*str2;

}

第三个code题是实现子串定位

int FindSubStr(const char *MainStr, const char *SubStr)

做是做对了,没有抄搞,比较乱

int MyStrstr(const char* MainStr, const char* SubStr)

{

const char *p;

const char *q;

const char * u = MainStr;

//assert((MainStr!=NULL)&&( SubStr!=NULL));//用断言对输入进行判断

while(*MainStr) //内部进行递增

{

p = MainStr;

q = SubStr;

while(*q && *p && *p++ == *q++);

if(!*q )

{

return MainStr - u +1 ;//MainStr指向当前起始位,u指向

}

MainStr ++;

}

return -1;

}

分析:

int arr[] = {6,7,8,9,10};

int *ptr = arr;

*(ptr++)+=123;

printf(“ %d %d ”, *ptr, *(++ptr));

输出:8 8

过程:对于*(ptr++)+=123;先做加法6+123,然后++,指针指向7;对于printf(“ %d %d ”, *ptr, *(++ptr));从后往前执行,指针先++,指向8,然后输出8,紧接着再输出8

篇3:C语言面试题大13

1. 有双向循环链表结点定义为:

struct node

{ int data;

struct node *front,*next;

};

有两个双向循环链表A,B,知道其头指针为:pHeadA,pHeadB,请写一函数将两链表中data值相同的结点删除

BOOL DeteleNode(Node *pHeader, DataType Value)

{

if (pHeader == NULL) return;

BOOL bRet = FALSE;

Node *pNode = pHead;

while (pNode != NULL)

{

if (pNode->data == Value)

{

if (pNode->front == NULL)

{

pHeader = pNode->next;

pHeader->front = NULL;

}

else

{

if (pNode->next != NULL)

{

pNode->next->front = pNode->front;

}

pNode->front->next = pNode->next;

}

Node *pNextNode = pNode->next;

delete pNode;

pNode = pNextNode;

bRet = TRUE;

//不要break或return, 删除所有

}

else

{

pNode = pNode->next;

}

}

return bRet;

}

void DE(Node *pHeadA, Node *pHeadB)

{

if (pHeadA == NULL || pHeadB == NULL)

{

return;

}

Node *pNode = pHeadA;

while (pNode != NULL)

{

if (DeteleNode(pHeadB, pNode->data))

{

if (pNode->front == NULL)

{

pHeadA = pNode->next;

pHeadA->front = NULL;

}

else

{

pNode->front->next = pNode->next;

if (pNode->next != NULL)

{

pNode->next->front = pNode->front;

}

}

Node *pNextNode = pNode->next;

delete pNode;

pNode = pNextNode;

}

else

{

pNode = pNode->next;

}

}

}

2. 编程实现:找出两个字符串中最大公共子字符串,如“abccade”,“dgcadde”的最大子串为“cad”

int GetCommon(char *s1, char *s2, char **r1, char **r2)

{

int len1 = strlen(s1);

int len2 = strlen(s2);

int maxlen = 0;

for(int i = 0; i < len1; i++)

{

for(int j = 0; j < len2; j++)

{

if(s1[i] == s2[j])

{

int as = i, bs = j, count = 1;

while(as + 1 < len1 && bs + 1 < len2 && s1[++as] == s2[++bs])

count++;

if(count > maxlen)

{

maxlen = count;

*r1 = s1 + i;

*r2 = s2 + j;

}

}

}

}

3. 编程实现:把十进制数(long型)分别以二进制和十六进制形式输出,不能使用printf系列库函数

char* test3(long num) {

char* buffer = (char*)malloc(11);

buffer[0] = “0”;

buffer[1] = “x”;

buffer[10] = “”;

char* temp = buffer + 2;

for (int i=0; i < 8; i++) {

temp[i] = (char)(num<<4*i>>28);

temp[i] = temp[i] >= 0 ? temp[i] : temp[i] + 16;

temp[i] = temp[i] < 10 ? temp[i] + 48 : temp[i] + 55;

}

return buffer;

}

输入N, 打印 N*N 矩阵

比如 N = 3,打印:

1 2 3

8 9 4

7 6 5

N = 4,打印:

1 2 3 4

12 13 14 5

11 16 15 6

10 9 8 7

解答:

1 #define N 15

int s[N][N];

void main

{

int k = 0, i = 0, j = 0;

int a = 1;

for( ; k < (N+1)/2; k++ )

{

while( j < N-k ) s[i][j++] = a++; i++; j--;

while( i < N-k ) s[i++][j] = a++; i--; j--;

while( j > k-1 ) s[i][j--] = a++; i--; j++;

while( i > k ) s[i--][j] = a++; i++; j++;

}

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

{

for( j = 0; j < N; j++ )

cout << s[i][j] << “ ”;

cout << endl;

}

}

2 define MAX_N 100

int matrix[MAX_N][MAX_N];

/*

*(x,y):第一个元素的坐标

* start:第一个元素的值

* n:矩阵的大小

*/

void SetMatrix(int x, int y, int start, int n) {

int i, j;

if (n <= 0) //递归结束条件

return;

if (n == 1) { //矩阵大小为1时

matrix[x][y] = start;

return;

}

for (i = x; i < x + n-1; i++) //矩阵上部

matrix[y][i] = start++;

for (j = y; j < y + n-1; j++) //右部

matrix[j][x+n-1] = start++;

for (i = x+n-1; i > x; i--) //底部

matrix[y+n-1][i] = start++;

for (j = y+n-1; j > y; j--) //左部

matrix[j][x] = start++;

SetMatrix(x+1, y+1, start, n-2); //递归

}

void main() {

int i, j;

int n;

scanf(“%d”, &n);

SetMatrix(0, 0, 1, n);

//打印螺旋矩阵

for(i = 0; i < n; i++) {

for (j = 0; j < n; j++)

printf(“%4d”, matrix[i][j]);

printf(“”);

}

}

斐波拉契数列递归实现的方法如下:

int Funct( int n )

{

if(n==0) return 1;

if(n==1) return 1;

retrurn Funct(n-1) + Funct(n-2);

}

请问,如何不使用递归,来实现上述函数?

请教各位高手!

解答:int Funct( int n ) // n 为非负整数

{

int a=0;

int b=1;

int c;

if(n==0) c=1;

else if(n==1) c=1;

else for(int i=2;i<=n;i++) //应该n从2开始算起

{

c=a+b;

a=b;

b=c;

}

return c;

}

解答:

现在大多数系统都是将低字位放在前面,而结构体中位域的申明一般是先声明高位,

C语言面试题大汇总13

100 的二进制是 001 100 100

低位在前 高位在后

001----s3

100----s2

100----s1

所以结果应该是 1

如果先申明的在低位则:

001----s1

100----s2

100----s3

结果是 4

1、原题跟little-endian,big-endian没有关系

2、原题跟位域的存储空间分配有关,到底是从低字节分配还是从高字节分配,从Dev C++和VC7.1上看,都是从低字节开始分配,并且连续分配,中间不空,不像谭的书那样会留空位

3、原题跟编译器有关,编译器在未用堆栈空间的默认值分配上有所不同,Dev C++未用空间分配为

01110111b,VC7.1下为11001100b,所以在Dev C++下的结果为5,在VC7.1下为1。

注:PC一般采用little-endian,即高高低低,但在网络传输上,一般采用big-endian,即高低低高,华为是做网络的,所以可能考虑big-endian模式,这样输出结果可能为4

判断一个字符串是不是回文

int IsReverseStr(char *aStr)

{

int i,j;

int found=1;

if(aStr==NULL)

return -1;

j=strlen(aStr);

for(i=0;i

if(*(aStr+i)!=*(aStr+j-i-1))

{

found=0;

break;

}

return found;

}

Josephu 问题为:设编号为1,2,… n的n个人围坐一圈,约定编号为k(1<=k<=n)的人从1开始报数,数到m 的那个人出列,它的下一位又从1开始报数,数到m的那个人又出列,依次类推,直到所有人出列为止,由此产生一个出队编号的序列。

数组实现:

#include

#include

int Josephu(int n, int m)

{

int flag, i, j = 0;

int *arr = (int *)malloc(n * sizeof(int));

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

arr[i] = 1;

for (i = 1; i < n; ++i)

{

flag = 0;

while (flag < m)

{

if (j == n)

j = 0;

if (arr[j])

++flag;

++j;

}

arr[j - 1] = 0;

printf(“第%4d个出局的人是:%4d号”, i, j);

}

free(arr);

return j;

}

int main()

{

int n, m;

scanf(“%d%d”, &n, &m);

printf(“最后胜利的是%d号!”, Josephu(n, m));

system(“pause”);

return 0;

}

链表实现:

#include

#include

typedef struct Node

{

int index;

struct Node *next;

}JosephuNode;

int Josephu(int n, int m)

{

int i, j;

JosephuNode *head, *tail;

head = tail = (JosephuNode *)malloc(sizeof(JosephuNode));

for (i = 1; i < n; ++i)

{

tail->index = i;

tail->next = (JosephuNode *)malloc(sizeof(JosephuNode));

tail = tail->next;

}

tail->index = i;

tail->next = head;

for (i = 1; tail != head; ++i)

{

for (j = 1; j < m; ++j)

{

tail = head;

head = head->next;

}

tail->next = head->next;

printf(“第%4d个出局的人是:%4d号”, i, head->index);

free(head);

head = tail->next;

}

i = head->index;

free(head);

return i;

}

int main()

{

int n, m;

scanf(“%d%d”, &n, &m);

printf(“最后胜利的是%d号!”, Josephu(n, m));

system(“pause”);

return 0;

}

已知strcpy函数的原型是:

char * strcpy(char * strDest,const char * strSrc);

1.不调用库函数,实现strcpy函数。

2.解释为什么要返回char *。

解说:

1.strcpy的实现代码

char * strcpy(char * strDest,const char * strSrc)

{

if ((strDest==NULL)||(strSrc==NULL)) file://[/1]

throw “Invalid argument(s)”; //[2]

char * strDestCopy=strDest; file://[/3]

while ((*strDest++=*strSrc++)!=“”); file://[/4]

return strDestCopy;

}

错误的做法:

[1]

(A)不检查指针的有效性,说明答题者不注重代码的健壮性。

(B) 检查指针的有效性时使用((!strDest)||(!strSrc))或(!(strDest&&strSrc)),说明答题者对C语言中类型的隐式转换没有深刻认识。在本例中char *转换为bool即是类型隐式转换,这种功能虽然灵活,但更多的是导致出错概率增大和维护成本升高。所以C++专门增加了bool、true、false 三个关键字以提供更安全的条件表达式。

(C)检查指针的有效性时使用((strDest==0)||(strSrc==0)),说明答题者不知道使用常量的好处。直接使用字面常量(如本例中的0)会减少程序的可维护性。0虽然简单,但程序中可能出现很多处对指针的检查,万一出现笔误,编译器不能发现,生成的程序内含逻辑错误,很难排除。而使用NULL代替0,如果出现拼写错误,编译器就会检查出来。

[2]

(A)return new string(“Invalid argument(s)”);,说明答题者根本不知道返回值的用途,并且他对内存泄漏也没有警惕心。从函数中返回函数体内分配的内存是十分危险的做法,他把释放内存的义务抛给不知情的调用者,绝大多数情况下,调用者不会释放内存,这导致内存泄漏。

(B)return 0;,说明答题者没有掌握异常机制。调用者有可能忘记检查返回值,调用者还可能无法检查返回值(见后面的链式表达式)。妄想让返回值肩负返回正确值和异常值的双重功能,其结果往往是两种功能都失效。应该以抛出异常来代替返回值,这样可以减轻调用者的负担、使错误不会被忽略、增强程序的可维护性。

[3]

(A)忘记保存原始的strDest值,说明答题者逻辑思维不严密。

[4]

(A)循环写成while (*strDest++=*strSrc++);,[1](B)。

(B)循环写成while (*strSrc!=“”) *strDest++=*strSrc++;,说明答题者对边界条件的检查不力。循环体结束后,strDest字符串的末尾没有正确地加上“”。

篇4:C语言面试题大11

1. 简述一个Linux驱动程序的主要流程与功能,

2. 请列举一个软件中时间换空间或者空间换时间的例子。

void swap(int a,int b)

{

int c; c=a;a=b;b=a;

}

--->空优

void swap(int a,int b)

{

a=a+b;b=a-b;a=a-b;

}

6. 请问一下程序将输出什么结果?

char *RetMenory(void)

{

char p[] = “hellow world”;

return p;

}

void Test(void)

{

char *str = NULL;

str = RetMemory();

printf(str);

}

RetMenory执行完毕,p资源被回收,指向未知地址。返回地址,str的内容应是不可预测的, 打印的应该是str的地址

写一个函数,它的原形是int continumax(char *outputstr,char *intputstr)

功能:

在字符串中找出连续最长的数字串,并把这个串的长度返回,并把这个最长数字串付给其中一个函数参数outputstr所指内存。例如:“abcd12345ed125ss123456789”的首地址传给intputstr后,函数将返回

9,outputstr所指的值为123456789

int continumax(char *outputstr, char *inputstr)

{

char *in = inputstr, *out = outputstr, *temp, *final;

int count = 0, maxlen = 0;

while( *in != “” )

{

if( *in > 47 && *in < 58 )

{

for(temp = in; *in > 47 && *in < 58 ; in++ )

count++;

}

else

in++;

if( maxlen < count )

{

maxlen = count;

count = 0;

final = temp;

}

}

for(int i = 0; i < maxlen; i++)

{

*out = *final;

out++;

final++;

}

*out = “”;

return maxlen;

}

不用库函数,用C语言实现将一整型数字转化为字符串

方法1:

int getlen(char *s){

int n;

for(n = 0; *s != “”; s++)

n++;

return n;

}

void reverse(char s[])

{

int c,i,j;

for(i = 0,j = getlen(s) - 1; i < j; i++,j--){

c = s[i];

s[i] = s[j];

s[j] = c;

}

}

void itoa(int n,char s[])

{

int i,sign;

if((sign = n) < 0)

n = -n;

i = 0;

do{/*以反序生成数字*/

s[i++] = n%10 + “0”;/*get next number*/

}while((n /= 10) > 0);/*delete the number*/

if(sign < 0)

s[i++] = “-”;

s[i] = “”;

reverse(s);

}

方法2:

#include

using namespace std;

void itochar(int num);

void itochar(int num)

{

int i = 0;

int j ;

char stra[10];

char strb[10];

while ( num )

{

stra[i++]=num%10+48;

num=num/10;

}

stra[i] = “”;

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

{

strb[j] = stra[i-j-1];

}

strb[j] = “”;

cout<<< p>

}

int main()

{

int num;

cin>>num;

itochar(num);

return 0;

}

前几天面试,有一题想不明白,请教大家!

typedef struct

{

int a:2;

int b:2;

int c:1;

}test;

test t;

t.a = 1;

t.b = 3;

t.c = 1;

printf(“%d”,t.a);

printf(“%d”,t.b);

printf(“%d”,t.c);

谢谢!

t.a为01,输出就是1

t.b为11,输出就是-1

t.c为1,输出也是-1

3个都是有符号数int嘛,

这是位扩展问题

01

11

1

编译器进行符号扩展

求组合数: 求n个数(1....n)中k个数的组合....

如:combination(5,3)

要求输出:543,542,541,532,531,521,432,431,421,321,

#include

int pop(int *);

int push(int );

void combination(int ,int );

int stack[3]={0};

top=-1;

int main()

{

int n,m;

printf(“Input two numbers:”);

while( (2!=scanf(“%d%*c%d”,&n,&m)) )

{

fflush(stdin);

printf(“Input error! Again:”);

}

combination(n,m);

printf(“”);

}

void combination(int m,int n)

{

int temp=m;

push(temp);

while(1)

{

if(1==temp)

{

if(pop(&temp)&&stack[0]==n) //当栈底元素弹出&&为可能取的最小值,循环退出

break;

}

else if( push(--temp))

{

printf(“%d%d%d ”,stack[0],stack[1],stack[2]);

pop(&temp);

}

}

}

int push(int i)

{

stack[++top]=i;

if(top<2)

return 0;

else

return 1;

}

int pop(int *i)

{

*i=stack[top--];

if(top>=0)

return 0;

else

return 1;

}

篇5:C语言面试题大10

同学的4道面试题,应聘的职位是搜索引擎工程师,后两道超级难,(希望大家多给一些算发)

1.给两个数组和他们的大小,还有一动态开辟的内存,求交集,把交集放到动态内存dongtai,并且返回交集个数

long jiaoji(long* a[],long b[],long* alength,long blength,long* dongtai[])

2.单连表的建立,把“a”--“z”26个字母插入到连表中,并且倒叙,还要打印!

方法1:

typedef struct val

{ int date_1;

struct val *next;

}*p;

void main(void)

{ char c;

for(c=122;c>=97;c--)

{ p.date=c;

p=p->next;

}

p.next=NULL;

}

}

方法2:

node *p = NULL;

node *q = NULL;

node *head = (node*)malloc(sizeof(node));

head->data = “ ”;head->next=NULL;

node *first = (node*)malloc(sizeof(node));

first->data = “a”;first->next=NULL;head->next = first;

p = first;

int longth = “z” - “b”;

int i=0;

while ( i<=longth )

{

node *temp = (node*)malloc(sizeof(node));

temp->data = “b”+i;temp->next=NULL;q=temp;

head->next = temp; temp->next=p;p=q;

i++;

}

print(head);

3.可怕的题目终于来了

象搜索的输入信息是一个字符串,统计300万输入信息中的最热门的前十条,我们每次输入的一个字符串为不超过255byte,内存使用只有1G,

请描述思想,写出算发(c语言),空间和时间复杂度,

4.国内的一些帖吧,如baidu,有几十万个主题,假设每一个主题都有上亿的跟帖子,怎么样设计这个系统速度最好,请描述思想,写出算发(c语言),空间和时间复杂度,

#include string.h

main(void)

{ char *src=“hello,world”;

char *dest=NULL;

dest=(char *)malloc(strlen(src));

int len=strlen(str);

char *d=dest;

char *s=src[len];

while(len--!=0)

d++=s--;

printf(“%s”,dest);

}

找出错误!!

#include “string.h”

#include “stdio.h”

#include “malloc.h”

main(void)

{

char *src=“hello,world”;

char *dest=NULL;

dest=(char *)malloc(sizeof(char)*(strlen(src)+1));

int len=strlen(src);

char *d=dest;

char *s=src+len-1;

while(len--!=0)

*d++=*s--;

*d=“”;

printf(“%s”,dest);

}

篇6:C语言面试题大9

今天早上的面试题9道,比较难,向牛人请教,国内的一牛公司,坐落在北京北四环某大厦:

1、线形表a、b为两个有序升序的线形表,编写一程序,使两个有序线形表合并成一个有序升序线形表h;

答案在 请化大学 严锐敏《数据结构第二版》第二章例题,数据结构当中,这个叫做:两路归并排序

Linklist *unio(Linklist *p,Linklist *q){

linklist *R,*pa,*qa,*ra;

pa=p;

qa=q;

R=ra=p;

while(pa->next!=NULL&&qa->next!=NULL){

if(pa->data>qa->data){

ra->next=qa;

qa=qa->next;

}

else{

ra->next=pa;

pa=pa->next;

}

}

if(pa->next!=NULL)

ra->next=pa;

if(qa->next!=NULL)

ra->next==qa;

return R;

}

2、运用四色定理,为N个局域举行配色,颜色为1、2、3、4四种,另有数组adj[][N],如adj[i][j]=1则表示i区域与j区域相邻,数组color[N],如color[i]=1,表示i区域的颜色为1号颜色,

C语言面试题大汇总9

四色填充

3、用递归算法判断数组a[N]是否为一个递增数组。

递归的方法,记录当前最大的,并且判断当前的是否比这个还大,大则继续,否则返回false结束:

bool fun( int a[], int n )

{

if( n= =1 )

return true;

if( n= =2 )

return a[n-1] >= a[n-2];

return fun( a,n-1) && ( a[n-1] >= a[n-2] );

}

4、编写算法,从10亿个浮点数当中,选出其中最大的10000个。

用外部排序,在《数据结构》书上有

《计算方法导论》在找到第n大的数的算法上加工

5、编写一unix程序,防止僵尸进程的出现。

篇7:C语言面试题大8

写一段程序,找出数组中第k大小的数,输出数所在的位置,例如{2,4,3,4,7}中,第一大的数是7,位置在4。第二大、第三大的数都是4,位置在1、3随便输出哪一个均可。函数接口为:int find_orderk(const int* narry,const int n,const int k)

要求算法复杂度不能是O(n^2)

谢谢!

可以先用快速排序进行排序,其中用另外一个进行地址查找

代码如下,在VC++6.0运行通过。给分吧^-^

//快速排序

#include

usingnamespacestd;

intPartition (int*L,intlow,int high)

{

inttemp = L[low];

intpt = L[low];

while (low < high)

{

while (low < high && L[high] >= pt)

--high;

L[low] = L[high];

while (low < high && L[low] <= pt)

++low;

L[low] = temp;

}

L[low] = temp;

returnlow;

}

voidQSort (int*L,intlow,int high)

{

if (low < high)

{

intpl = Partition (L,low,high);

QSort (L,low,pl - 1);

QSort (L,pl + 1,high);

}

}

intmain

{

intnarry[100],addr[100];

intsum = 1,t;

cout << “Input number:” << endl;

cin >> t;

while (t != -1)

{

narry[sum] = t;

addr[sum - 1] = t;

sum++;

cin >> t;

}

sum -= 1;

QSort (narry,1,sum);

for (int i = 1; i <= sum;i++)

cout << narry[i] << “ ”;

cout << endl;

intk;

cout << “Please input place you want:” << endl;

cin >> k;

intaa = 1;

intkk = 0;

for (;;)

{

if (aa == k)

break;

if (narry[kk] != narry[kk + 1])

{

aa += 1;

kk++;

}

}

cout << “The NO.” << k << “number is:” << narry[sum - kk] << endl;

cout << “And it”s place is:“ ;

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

{

if (addr[i] == narry[sum - kk])

cout << i << ” “;

}

return0;

}

1、找错

Void test1()

{

char string[10];

char* str1=”0123456789“;

strcpy(string, str1);// 溢出,应该包括一个存放”“的字符string[11]

}

Void test2()

{

char string[10], str1[10];

for(I=0; I<10;I++)

{

str1[i] =”a“;

}

strcpy(string, str1);// I,i没有声明,

}

Void test3(char* str1)

{

char string[10];

if(strlen(str1)<=10)// 改成<10,字符溢出,将strlen改为sizeof也可以

{

strcpy(string, str1);

}

}

2.

void g(int**);

int main()

{

int line[10],i;

int *p=line; //p是地址的地址

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

{

*p=i;

g(&p);//数组对应的值加1

}

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

printf(”%d“,line[i]);

return 0;

}

void g(int**p)

{

(**p)++;

(*p)++;// 无效

}

输出:

1

2

3

4

5

6

7

8

9

10

3. 写出程序运行结果

int sum(int a)

{

auto int c=0;

static int b=3;

c+=1;

b+=2;

return(a+b+c);

}

void main()

{

int I;

int a=2;

for(I=0;I<5;I++)

{

printf(”%d,“, sum(a));

}

}

// static会保存上次结果,记住这一点,剩下的自己写

输出:8,10,12,14,16,

4.

int func(int a)

{

int b;

switch(a)

{

case 1: 30;

case 2: 20;

case 3: 16;

default: 0

}

return b;

}

则func(1)=?

// b定义后就没有赋值。

5:

int a[3];

a[0]=0; a[1]=1; a[2]=2;

int *p, *q;

p=a;

q=&a[2];

则a[q-p]=a[2]

解释:指针一次移动一个int但计数为1

篇8:C语言面试题大3

1、static全局变量与普通的全局变量有什么区别 static局部变量和普通局部变量有什么区别 static函数与普通函数有什么区别

全局变量(外部变量)的说明之前再冠以static 就构成了静态的全局变量,全局变量本身就是静态存储方式, 静态全局变量当然也是静态存储方式。这两者在存储方式上并无不同。这两者的区别虽在于非静态全局变量的作用域是整个源程序,当一个源程序由多个源文件组成时,非静态的全局变量在各个源文件中都是有效的。 而静态全局变量则限制了其作用域, 即只在定义该变量的源文件内有效,在同一源程序的其它源文件中不能使用它。由于静态全局变量的作用域局限于一个源文件内,只能为该源文件内的函数公用,因此可以避免在其它源文件中引起错误。

从以上分析可以看出, 把局部变量改变为静态变量后是改变了它的存储方式即改变了它的生存期。把全局变量改变为静态变量后是改变了它的作用域, 限制了它的使用范围。

static函数与普通函数作用域不同。仅在本文件。只在当前源文件中使用的函数应该说明为内部函数(static),内部函数应该在当前源文件中说明和定义。对于可在当前源文件以外使用的函数,应该在一个头文件中说明,要使用这些函数的源文件要包含这个头文件

static全局变量与普通的全局变量有什么区别:static全局变量只初使化一次,防止在其他文件单元中被引用;

static局部变量和普通局部变量有什么区别:static局部变量只被初始化一次,下一次依据上一次结果值;

static函数与普通函数有什么区别:static函数在内存中只有一份,普通函数在每个被调用中维持一份拷贝

程序的局部变量存在于(堆栈)中,全局变量存在于(静态区 )中,动态申请数据存在于( 堆)中。

2、设有以下说明和定义:

typedef union {long i; int k[5]; char c;} DATE;

struct data { int cat; DATE cow; double dog;} too;

DATE max;

则语句 printf(”%d“,sizeof(struct date)+sizeof(max));的执行结果是:___52____

答:DATE是一个union, 变量公用空间. 里面最大的变量类型是int[5], 占用20个字节. 所以它的大小是20

data是一个struct, 每个变量分开占用空间. 依次为int4 + DATE20 + double8 = 32.

所以结果是 20 + 32 = 52.

当然...在某些16位编辑器下, int可能是2字节,那么结果是 int2 + DATE10 + double8 = 20

3、队列和栈有什么区别

队列先进先出,栈后进先出

4、写出下列代码的输出内容

以下是引用片段:

#include

int inc(int a)

{

return(++a);

}

int multi(int*a,int*b,int*c)

{

return(*c=*a**b);

}

typedef int(FUNC1)(int in);

typedef int(FUNC2) (int*,int*,int*);

void show(FUNC2 fun,int arg1, int*arg2)

{

INCp=&inc;

int temp =p(arg1);

fun(&temp,&arg1, arg2);

printf(”%d“,*arg2);

}

main()

{

int a;

show(multi,10,&a);

return 0;

}

答:110

5、请找出下面代码中的所以错误

说明:以下代码是把一个字符串倒序,如“abcd”倒序后变为“dcba”

以下是引用片段:

1、#include”string.h“

2、main()

3、{

4、 char*src=”hello,world“;

5、 char* dest=NULL;

6、 int len=strlen(src);

7、 dest=(char*)malloc(len);

8、 char* d=dest;

9、 char* s=src[len];

10、 while(len--!=0)

11、 d++=s--;

12、 printf(”%s“,dest);

13、 return 0;

14、}

答:

方法1:

以下是引用片段:

int main(){

char* src = ”hello,world“;

int len = strlen(src);

char* dest = (char*)malloc(len+1);//要为分配一个空间

char* d = dest;

char* s = &src[len-1];//指向最后一个字符

while( len-- != 0 )

*d++=*s--;

*d = 0;//尾部要加

printf(”%s“,dest);

free(dest);// 使用完,应当释放空间,以免造成内存汇泄露

return 0;

}

方法2:

以下是引用片段:

#include

#include

main()

{

char str[]=”hello,world“;

int len=strlen(str);

char t;

for(int i=0; i

{

t=str[i];

str[i]=str[len-i-1]; str[len-i-1]=t;

}

printf(”%s“,str);

return 0;

}

篇9:C语言面试题大7

说明data为bs变量,共占两个字节,其中位域a占8位,位域b占2位,位域c占6位。对于位域的定义尚有以下几点说明:

1. 一个位域必须存储在同一个字节中,不能跨两个字节。如一个字节所剩空间不够存放另一位域时,应从下一单元起存放该位域。也可以有意使某位域从下一单元开始。例如:

struct bs

{

unsigned a:4

unsigned :0 /*空域*/

unsigned b:4 /*从下一单元开始存放*/

unsigned c:4

}

在这个位域定义中,a占第一字节的4位,后4位填0表示不使用,b从第二字节开始,占用4位,c占用4位。

2. 由于位域不允许跨两个字节,因此位域的长度不能大于一个字节的长度,也就是说不能超过8位二进位。

3. 位域可以无位域名,这时它只用来作填充或调整位置。无名的位域是不能使用的。例如:

struct k

{

int a:1

int :2 /*该2位不能使用*/

int b:3

int c:2

};

从以上分析可以看出,位域在本质上就是一种结构类型, 不过其成员是按二进位分配的。

二、位域的使用位域的使用和结构成员的使用相同,其一般形式为: 位域变量名?位域名 位域允许用各种格式输出。

main{

struct bs

{

unsigned a:1;

unsigned b:3;

unsigned c:4;

} bit,*pbit;

bit.a=1;

bit.b=7;

bit.c=15;

pri

改错:

#include

int main(void) {

int **p;

int arr[100];

p = &arr;

return 0;

}

解答:

搞错了,是指针类型不同,

int **p; //二级指针

&arr; //得到的是指向第一维为100的数组的指针

#include

int main(void) {

int **p, *q;

int arr[100];

q = arr;

p = &q;

return 0;

}

下面这个程序执行后会有什么错误或者效果:

#define MAX 255

int main()

{

unsigned char A[MAX],i;//i被定义为unsigned char

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

A[i]=i;

}

解答:死循环加数组越界访问(C/C++不进行数组越界检查)

MAX=255

数组A的下标范围为:0..MAX-1,这是其一..

其二.当i循环到255时,循环内执行:

A[255]=255;

这句本身没有问题..但是返回for (i=0;i<=MAX;i++)语句时,

由于unsigned char的取值范围在(0..255),i++以后i又为0了..无限循环下去.

struct name1{

char str;

short x;

int num;

}

struct name2{

char str;

int num;

short x;

}

sizeof(struct name1)=8,sizeof(struct name2)=12

在第二个结构中,为保证num按四个字节对齐,char后必须留出3字节的空间;同时为保证整个结构的自然对齐(这里是4字节对齐),在x后还要补齐2个字节,这样就是12字节。

intel:

A.c 和B.c两个c文件中使用了两个相同名字的static变量,编译的时候会不会有问题?这两个static变量会保存到哪里(栈还是堆或者其他的)?

static的全局变量,表明这个变量仅在本模块中有意义,不会影响其他模块。

他们都放在数据区,但是编译器对他们的命名是不同的。

如果要使变量在其他模块也有意义的话,需要使用extern关键字。

struct s1

{

int i: 8;

int j: 4;

int a: 3;

double b;

};

struct s2

{

int i: 8;

int j: 4;

double b;

int a:3;

};

printf(”sizeof(s1)= %d“, sizeof(s1));

printf(”sizeof(s2)= %d“, sizeof(s2));

result: 16, 24

第一个struct s1

{

int i: 8;

int j: 4;

int a: 3;

double b;

};

理论上是这样的,首先是i在相对0的位置,占8位一个字节,然后,j就在相对一个字节的位置,由于一个位置的字节数是4位的倍数,因此不用对齐,就放在那里了,然后是a,要在3位的倍数关系的位置上,因此要移一位,在15位的位置上放下,目前总共是18位,折算过来是2字节2位的样子,由于double是8 字节的,因此要在相对0要是8个字节的位置上放下,因此从18位开始到8个字节之间的位置被忽略,直接放在8字节的位置了,因此,总共是16字节。

第二个最后会对照是不是结构体内最大数据的倍数,不是的话,会补成是最大数据的倍数

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“,a[j]);

fclose(fp1);

fclose(fp2);

return 0;

}

第二题.

#include

int main(void)

{

unsigned long int i,j,k;

printf(”please input the number“);

scanf(”%d“,&i);

if( i % 2 == 0)

j = i / 2;

else

j = i / 2 + 1;

printf(”The result is “);

for(k = 0; k < j; k++)

printf(”%d = %d + %d“,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=0x1000000;

p+0x200=____;

(Ulong)p+0x200=____;

(char*)p+0x200=____;

希望各位达人给出答案和原因,谢谢拉

解答:假设在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=0x1000000;

p+0x200=____;

= 0x1000000 + 0x200*24

(Ulong)p+0x200=____;

= 0x1000000 + 0x200

(char*)p+0x200=____;

= 0x1000000 + 0x200*4

你可以参考一下指针运算的细节

篇10:c语言基础面试题

c语言基础面试题

1、statac 全局变量、局部变量、函数与普通全局变量、局部变量、函数static 全局变量与普通的全局变量有什么区别?static 局部变量和普通局部变量有什么区别?static 函数与普通函数有什么区别?

答 、全局变量(外部变量)的说明之前再冠以 static 就构成了静态的全局变量,全局变量本身就是静态存储方式, 静态全局变量当然也是静态存储方式。 这两者在存储方式上并无不同。

这两者的区别虽在于非静态全局变量的作用域是整个源程序, 当一个源程序由多个源文件组成时,非静态的全局变量在各个源文件中都是有效的。 而静态全局变量则限制了其作用域, 即只在定义该变量的源文件内有效, 在同一源程序的其它源文件中不能使用它。由于静态全局变量的作用域局限于一个源文件内,只能为该源文件内的函数公用, 因此可以避免在其它源文件中引起错误。

从以上分析可以看出, 把局部变量改变为静态变量后是改变了它的存储方式即改变了它的生存期。把全局变量改变为静态变量后是改变了它的作用域, 限制了它的使用范围。

static 函数与普通函数作用域不同。仅在本文件。只在当前源文件中使用的函数应该说明为内部函数(static),内部函数应该在当前源文件中说明和定义。对于可在当前源文件以外使用的函数,应该在一个头文件中说明,要使用这些函数的源文件要包含这个头文件static 全局变量与普通的全局变量有什么区别:static 全局变量只初使化一次,防止在其他文件单元中被引用;

static 局部变量和普通局部变量有什么区别:static 局部变量只被初始化一次,下一次依据上一次结果值;

static 函数与普通函数有什么区别:static 函数在内存中只有一份,普通函数在每个被调用中维持一份拷贝

2、程序的内存分配

答:一个由 c/C++编译的程序占用的内存分为以下几个部分

1、栈区(stack)—由编译器自动分配释放,存放函数的参数值,局部变量的值等。其操作方式类似于数据结构中的栈。

2、堆区(heap)—一般由程序员分配释放,若程序员不释放,程序结束时可能由 OS 回收。注意它与数据结构中的堆是两回事,分配方式倒是类似于链表,呵呵。

3、全局区(静态区)(static)—全局变量和静态变量的存储是放在一块的,初始化的全局变量和静态变量在一块区域,未初始化的全局变量和未初始化的静态变量在相邻的另一块区域。程序结束后由系统释放。

4、文字常量区—常量字符串就是放在这里的。程序结束后由系统释放。

5、程序代码区—存放函数体的二进制代码

3、解释堆和栈的区别

答:堆(heap)和栈(stack)的区别

(1)申请方式

stack:由系统自动分配。例如,声明在函数中一个局部变量 int b;系统自动在栈中为 b 开辟空间

heap:需要程序员自己申请,并指明大小,在 c 中 malloc 函数

如 p1=(char*)malloc(10);

在 C++中用 new 运算符

如 p2=(char*)malloc(10);

但是注意 p1、p2 本身是在栈中的。

(2)申请后系统的响应

栈:只要栈的剩余空间大于所申请空间,系统将为程序提供内存,否则将报异常提示栈溢出。

堆:首先应该知道操作系统有一个记录空闲内存地址的链表,当系统收到程序的申请时,会遍历该链表,寻找第一个空间大于所申请空间的堆结点,然后将该结点从空闲结点链表中删除,并将该结点的空间分配给程序,另外,对于大多数系统,会在这块内存空间中的首地址处记录本次分配的大小,这样,代码中的 delete 语句才能正确的释放本内存空间,

另外,由于找到的堆结点的大小不一定正好等于申请的大小,系统会自动的将多余的那部分重新放入空闲链表中。

(3)申请大小的限制

栈:在 Windows 下,栈是向低地址扩展的数据结构,是一块连续的内存的区域。这句话的意思是栈顶的地址和栈的最大容量是系统预先规定好的,在 WINDOWS 下,栈的大小是 2M(也有的说是 1M,总之是一个编译时就确定的常数),如果申请的空间超过栈的.剩余空间时,将提示 overflow。因此,能从栈获得的空间较小。

堆:堆是向高地址扩展的数据结构,是不连续的内存区域。这是由于系统是用链表来存储的空闲内存地址的,自然是不连续的,而链表的遍历方向是由低地址向高地址。堆的大小受限于计算机系统中有效的虚拟内存。由此可见,堆获得的空间比较灵活,也比较大。

(4)申请效率的比较:

栈:由系统自动分配,速度较快。但程序员是无法控制的。

堆:是由 new 分配的内存,一般速度比较慢,而且容易产生内存碎片,不过用起来最方便.另外,在 WINDOWS 下,最好的方式是用 Virtual Alloc 分配内存,他不是在堆,也不是在栈,而是直接在进程的地址空间中保留一块内存,虽然用起来最不方便。但是速度快,也最灵活。

(5)堆和栈中的存储内容

栈:在函数调用时,第一个进栈的是主函数中后的下一条指令(函数调用语句的下一条可执行语句)的地址,然后是函数的各个参数,在大多数的 C 编译器中,参数是由右往左入栈的,然后是函数中的局部变量。注意静态变量是不入栈的。

当本次函数调用结束后,局部变量先出栈,然后是参数,最后栈顶指针指向最开始存的地址,也就是主函数中的下一条指令,程序由该点继续运行。

堆:一般是在堆的头部用一个字节存放堆的大小。堆中的具体内容由程序员安排。

(6)存取效率的比较

char s1[]=”aaaaaaaaaaaaaaa“;

char *s2=”bbbbbbbbbbbbbbbbb“;

aaaaaaaaaaa 是在运行时刻赋值的;

而 bbbbbbbbbbb 是在编译时就确定的;

但是,在以后的存取中,在栈上的数组比指针所指向的字符串(例如堆)快。

比如:

#include

voidmain()

{

char a=1;

char c[]=”1234567890“;

char *p=”1234567890";

a = c[1];

a = p[1];

return;

}

对应的汇编代码

10:a=c[1];

004010678A4DF1movcl,byteptr[ebp-0Fh]

0040106A884DFCmovbyteptr[ebp-4],cl

11:a=p[1];

0040106D8B55ECmovedx,dwordptr[ebp-14h]

004010708A4201moval,byteptr[edx+1]

004010738845FCmovbyteptr[ebp-4],al

第一种在读取时直接就把字符串中的元素读到寄存器 cl 中,而第二种则要先把指针值读到 edx 中,在根据 edx 读取字符,显然慢了。

篇11:c语言面试题及答案

c语言面试题及答案

一、选择题(1)~(10)每小题2分,(11)~(50)每小题1分,共60分)

在下列各题A)、B)、C)、D)四个选项中,只有一个选项是正确的,请将正确的选项涂写在答题卡相应的位置上,答在试卷上不得分。

(1)在数据结构中,从逻辑上可以把数据结构分为_______。

A)动态结构和静态结构      B)紧凑结构和非紧凑结构

C)线性结构和非线性结构    D)内部结构和外部结构

答案:C

评析:逻辑结构反映数据元素之间的逻辑关系,线性结构表示数据元素之间一对一的关系,非线性结构表示数据元素之间一对多或多对一的关系。

(2)若进栈序列为l,2,3,4,进栈过程中可以出栈,则下列选项中不可能的一个出栈序列是_______。

A)1,4,3,2    B)2,3,4,l

C)3,1,4,2    D)3,4, 2,1

答案:C

评析:栈是一种后进先出表,在选项c中,先出栈的是3,说明此时栈内必然有1,2,由于l先于2进栈,所以l不可能在2之前出栈,故选项C这种出栈序列是不可能的。

(3)排序方法中,将整个无序序列分割成若干小的子序列并分别进行插入排序的方法,称为_______。

A)希尔排序    B)冒泡排序    C)插入排序    D)选择排序

答案:A

评析:希尔排序法的基本思想是:将整个无序序列分割成若干小的子序列分别进行插入排序。

(4)在顺序表(3,6,8,10,12,15,16,18,21,25,30)中,用二分法查找关键码值11,所需的关键码比较次数为_______。

A)2      B)3       C)4        D)5

答案:C

评析:二分法查找是用关键码与线性表的中间元素比较,然后根据比较结果来判断是结束查找,还是在左边或者右边子表按相同的方法继续查找。本题中,与ll比较的关键码分别为15,8,10,12四个。

(5)对于n个结点的单向链表(无表头结点),需要指针单元的个数至少为_______。

A)n-1    B)n    C)n+l      D)2n

答案:C

评析:在n个结点的单向链表(无表头结点)中,每个结点都有一个指针单元(即指针域),加上头指针,至少需要n+1个指针单元。

(6)在软件开发过程中,软件结构设计是描述_______。

A)数据存储结构     B)软件体系结构    C)软件结构测试    D)软件控制过程

答案:B

评析:从工程管理的角度来看,软件设计分为两步完成:概要设计和详细设计。概要设计(又称结构设计)将软件需求转化为软件体系结构、确定系统级接口、全局数据结构或数据库模式。

(7)模块本身的内聚是模块独立性的重要性度量因素之一。在7类内聚中,具有最强内聚    的一类是_______。

A)顺序性内聚     B)过程性内聚      C)逻辑性内聚    D)功能性内聚

答案:D

评析:内聚性是一个模块内部各元素间彼此结合的紧密程度的度量。内聚共有7类,它们之间的内聚性由弱到强排列顺序为:偶然内聚、逻辑内聚、时间内聚、过程内聚、通信内聚、顺序内聚和功能内聚。

(8)数据存储和数据流都是_______,仅仅是所处的状态不同。

A)分析结果    B)事件    C)动作    D)数据

答案:D

评析:数据流图有4种成分:源点或终点、处理、数据存储和数据流。数据存储是处于静止状态的数据,数据流是处于运动中的数据。

(9)数据的完整性是指数据的正确性、有效性和_______。

A)可维护性    B)独立性    C)安全性    D)相容性

答案:D

评析:数据模型的完整性规则是给定的数据模型中数据及其联系所具有的制约和依存规则,用以限定符合数据模型的数据库状态及其状态的变化,以保证数据的正确性、有效性和相容性。

(10)关系代数运算是以_______为基础的运算。

A)关系运算    B)谓词运算    C)集合运算     D)代数运算

答案:C

评析:关系代数运算是以关系代数作为运算对象的一组高级运算的集合。它的基本操作是并、交、差、笛卡尔积,另外还包垂直分割(投影)、水平分割(选择)、关系的结合(连接)等。

(11)能将高级语言程序转换成目标语言程序的是_______。

A)调试程序    B)解释程序    C)编译程序      D)编辑程序

答案:C

评析:用高级语言编写的程序称为“源程序”,而计算机只能识别和执行由0和l组成的二进制指令,所以高级语言必须先用一种称为“编译程序”的软件,把源程序翻译成二进制形式的“目标程序”。

(12) _______是构成c语言程序的基本单位。

A)函数    B)过程    C)子程序       D)子例程

答案:A

评析:c程序是由函数构成的。一个c源程序至少包含一个main函数,也可以包含一个main函数和若干个其他函数,因此,函数是c程序的基本单位。

(13)可以在C语言中用做用户标识符的是_______。

A)void    B)as_b3    C)for        D)2c

define    _123       -abc        Do

WORD       If        cas         SIG

答案:B

评析:在c语言中规定,标识符只能由字母、数字和下划线三种符号所组成,而且第一个字符必须是字母或下划线。另外还需要注意的是关键字不能作标识符。选项A中void,C中for都为关键字,D中2c以字母开头。

(14)若有以下类型说明语句:

char w;int x;float y,z;

则表达式w*x+z-y的结果为________类型。

A)float    B)char     C)int   D)double

答案:A

评析:在进行运算时,不同类型的数据参加运算,需要先将其转换成同一类型的数据,然后再进行运算。转换的顺序由低到高为:char,short→int→unsigned→long→double→float,故结果为float型。

(15)main(()

{  float x=123A56;

printf(“%-5.2f”,x);

}

以上程序输出的结果是________。

A)123.4    B)123.5      C)123.45    D)123.46

答案:D

评析:f格式符,用来输出实数,以小数的形式输出。“%-m.nf”的含义是:输出数据共占m列,其中n位小数,如果输出位数小于m。则右端补空格。如果总长度大于列数,则按实际情况四舍五入输出。

(16)下面语句的输出结果是________。

Printf(“%d\n”,strlen(“\t\”\065\xff\n”));

A)14          B)8

C)5           D)输出项不合法,无正常输出

答案:C

评析:在c语言中,以“\”开头的字符均为转义字符,其中“\”后可跟l~3位八进制数或在“\”后跟字母x及l~2位十六进制数,以此来代表一个特定的字符。

(17)下列程序的输出结果是________。

main()

{  int a=0,b=0,c=0;

if(++a>0lI++b>0)++c;

printf(“\na=%d,b=%d,c=%d”,a,b,C);

}

A)a=0,b=0,c=0       B)a=l,b=l,c=1

C)a=l,b=O, c=I       D)a=0, b=1.c=1

答案:C

评析:

“︱︱”是或运算,它有个“短路”的特点需要特别注意,当“︱︱”运算符左边的表达式的值为真时,则程序就不再对“︱︱”右边的表达式的值去进行运算,而是使得整个表达式的值直接为真。

(18)下列程序的输出结果是_________。

Main()

{  int i;

for(i=1;i+l;i++)

{  if(i>4){printlf(”%d”,i++);break;}

}

printf(“%d”,i++);

}

A)55                    B)56

C)程序错误,没有输出    D)循环条件永远为真,死循环

答案:B

评析:本程序中有个for循环,但注意到for循环的条件是“i+l”,也就是只要i+l的值为真(非零值均为真),就执行循环。当i=l的时,i+l的值为真,判断if条件不成立,执行i++,输出i的值为5。

(19)下列程序的输出结果是_________。

#define A 100

main()

{  int i=O,sum=O;

do{  if(I==(i/2)*2)continue;

sum+=i;

}while(++i

printf(“%d\n”,sum);

}

A)2500    B)2050    C)4    D)O

答案:A

评析:本题程序的功能是求1到_99之问(包括1和99)所有奇数之和。程序中的while循环的终止条件为++i=100,在while循环体内,如果i是偶数,则执行continue,跳过这一次循环,去执行下一次循环,否则求和。最后输出的值是1到99之间(包括l和99)所有奇数之和(1+99)*50/2=2500。

(20)下列程序的输出结果是_________。

main()

{  int I=3;

switch(i)

{ case 1:

case 2:printf(”%d”,i);

case 3:

case 4:break;

default:printf(”OK”);

}

}

A)0    B)3    C)OK    D)没有任何输出

答案:D

评析:在本题中,i的值为3,由于“case 3:”后面没有break语句,所以继续向下执行“case 4:”后面的语句,由于“case 4:”后面的语句为break强行退出switch语句,所以,本题没有任何输出。

(21)下列程序执行后的输出结果是________。

main()

{  int m[][3]={1,4,7,2,5,8,3,6,9};

int i,k=2:

for(I=0;i<3;i++)

{printf(”%d”,m[k][i]);}

}

A)456    B)258    C)369    D)789

答案:C

评析:根据二维数组的定义得出:m[O][O]=1,m[O][1]=4,m[O][2]=7,m[1][0]=2,rail][1]=5,m[1][2]=8,m[2][0]=3,m[2][l]=6,m[2][2]=9,所以本题的输出是第3行的值m[2][0],m[2][1],m[2][2],即369。

(22)设已定义洱口k为int类型变量,则以下for循环语句_________。

for(i=0;k=-1,k=1;i++,k++)

printf(”****\n”);

A)判断循环结束的条件不合法    B)是无限循环

C)循环一次也不执行            D)循环只执行一次

答案:B

评析:本题定义了一个for循环,它的循环变量是i,但由于本题并没有去设置循环条件,所以循环的条件永远默认为真,即无限次执行循环。

(23)下面程序的输出结果是___________。

unsigned fun(unsigned num)

{   unsigned k=1;

do{

k*=num%lO;

num/=lO;

}while(num);

return(k);

}

main()

{  unsigned n。26;

printf(”%d\n”,fun(n));

}

A)0    B)4    C)12    D)无限次循环

答案:C

评析:本题定义了一个fun函数,用于num求和,具体执行过程如下:

num=26:k=k*(num%10)=1*(26%10),所以k=6,num=num/10=2;

num=2:k=k*(num%10)=6*(2%10),所以k=12,num=num/lO=O;

num=O:while条件不成立,所以返回k的值12.

(24)已知字母A的ASCII码值是65,字母a的ASCII码值是97,以下程序_______。

main()

{  char a=‘A’;

int b=20;

printf(“%d,%o”,(a=a+a,a+b,b),a+‘a’-‘A’,b);

}

A)表达式非法,输出零或不确定值

B)因输出项过多,无输出或输出不确定值

C)输出结果为20,141

D)输出结果为20,141,20

答案:C

评析:本题中首先输出逗号表达式“a=a+a,a+b,b”的值,即是20。然后以八进制的形式输出a+‘a’-‘A’的值为97对应的八进制数141,由于最后一个表达式b没有对应输出格式的输出项表列就不会输出。

(25)C语言函数返回值的类型是由__________决定的。

A)return语句中的表达式类型    B)调用函数的主调函数类型

C)调用函数时临时               D)定义函数时所指定的函数类型

答案:D

评析:函数值的类型应当是在定义函数时指定的。在定义函数时对函数值说明的类型一般应该和return语句中的表达式类型一致,如果不_致,则以函数类型为准,即函数类型决定返回值的类型。

(26)下列程序执行后输出的结果是___________。

int d=l:

fun(int p)

{  int d。5;

d+=p++;

printf(”%d,”,d);

}

main()

{  int a=3;

fun(a);

d+=a++:

printf(”%d\n”,d);

}

A)8,12    B)9,13    C)8,4    D)9,5

答案:C

评析:本题执行过程如下:首先调用fun函数,使得实参a的值3传递给形参p,得到局部变量d=8,打印出局部变量d的值8;返回主函数执行“d+=a++”,此处的d为全局变量,所以d=1+3=4(由于本题是值传递,所以在函数fun中对p值的改变并不能引起a的改变),故本题的输出是8,4。

(27)已知下面的程序段,正确的判断是_________。

#define A 3

#define B(A)((_A+1)‘a)

int a=3:

……

X=3*(A+B(7));

A)程序错误,不允许嵌套定义    B)X=93

C)X=8l                        D)程序错误,宏定义不允许有参数

答案:C

评析:本题的宏定义是合法的,宏定义展开为3*(3+((A+1)*a))=3*(3+((7+1)*3))=81。

(28)定义int*swap()指的是_______。

A)一个返回整型值的函数swap()

B)一个返回指向整型值指针的函数swap()

C)一个指向函数swap()的指针,函数返回一个整型值

D)以上说法均错

答案:B

评析:一个函数可以带回一个整型值、字符值、实型值等,但是也可以带回指针型数据,即地址。本题的定义中,包括括号和·号,由于f)优先级高于t。故它是一个返回整型指针的函数。

(29)以下程序段的输出结果是__________。

main()

{   char s1[10],s2[10],s3[10];

scanf(”%s”,s1);gets(s2);gets(s3);

puts(s 1);puts(s2);puts(s3);

}

输入数据如下:  (此处代表回车符)

aaa

bbb

A)aaa    B)aaa    C)aaa\0bbb\0    D)aaabbb

bbb

bbb

答案:B

评析:scanf是标准的输入函数,在输入字符串aaa时,实际的内容为“aaa”,“\0”是由系统自动加入的;gets的功能是从终端读入一行字符,即一直读到换行符为止,并由系统自动以“\0”代替换行符。

(30)下述函数功能是________。

Int fun(char*x)

{  char*y=x;

while(*y++);

return y-x-l;

}

A)求字符串的长度          B)求字符串存放的位置

C)比较两个字符串的大小    D)将字符串x连接到字符串y后面

答案:A

评析:在函数体内定义一字符型指针并指向形参,然后遍历其中各字符直到碰到NULL,最后返回字符串首尾地址的差值,即字符串的长度。

(31)以下程序的输出结果是_________。

main()

{ char str[12]={‘s’,‘t’,‘r’,‘i’,‘n’,‘ g’};

printf(”%d\n”,strlen(str));

}

A)6    B)7    C)ll    D)12

答案:A

评析:在c语言中,字符串的长度是其首字符到NULL(不含)字符的总字符个数。本题定义字符数组str的同时,对第7个元素,由系统自动添加上“\0”,故字符串的长度为6。

(32)请读程序段:

char str[]=”ABCD”,*p=str;

printf(”%d\n”,*(p+4));

程序段的输出结果是_________。

A)68                 B)0

C)字符‘D’的地址    D)不确定的值

答案:B

评析:在对字符数组赋字符串值时,系统会自动在字符串的末尾加上一个字符串结束标志“\0”,故指向字符数组的指针p的+(p+4)的值为“\0”。由于“\0”的编码值就是0,所以本题输出为0。

(33)若有定义:int a[4][10];,则以下选项中对数组元素a[i][j]引用错误的是________。

(0<=i<4,0<=j<10)

A)*(&a[O][O]+10*i+j)     B)*(a+i)+j

C)*(*(a+i)+j)             D)*(a[i]+j)

答案:B

评析:本题中选项B是错误的引用,*(a+i)+j只代表了a[i][i]的地址。

(34)设有以下语句:

char strl[]=”string”,str2[8],。str3,。str4=”strin∥;

则__________不是对库函数的正确调用。

A)strcpy(strl,”HELLOl”);    B)strcpy(str2,”HELL02”);

C)strcpy(str3,”HELL03”);    D)strcpy(str4,”HELL04”);

答案:C

评析:c语言中:sgcpy(stl,st2);,其两个参数均为字符指针或字符数组,选项c中的目的`串指针str3没有指向具体有效的存储单元,故是错误的调用。

(35)请读程序:

#include

#include

main()

{  char*sl=”AbCdEf”,*s2=”aB”;

s1++;s2++;

printf(”%d\n”,strcmp(s 1,s2));

}

上面程序的输出结果是___________。

A)正数    B)负数    C)零    D)不确定的值

答案:A

评析:函数strcmp的功能是比较字符串s1和s2,如果sl>s2,则返回个正数;如果sls2,所以函数的值为正数。

(36)下面程序的输出是_________。

char s[]=”ABcD”;

main()

{  char*p;

for(p=s;p

printf(”%s\n”,p);

}

A)ABCD    B)A        C)D    D)ABCD

BCD       B          C      ABC

CD        C          B      AB

D         D          A      A

答案:A

评析:在第一次执行for循环的时候,字符数组的首地址赋给了指针变量p,使得指针变量p指向了s的首地址,输出p所指向的字符串;第二次执行for循环时,p值增加1,p指向了s的第二个元素输出BCD;第三次输出CD;第四次输出D;直到p指向字符串的结束字符“\0”,for循环终止执行。

(37)以下程序输出的结果为__________。

main()

{  char* alpha[6]={“ABCD”,EFGH”,”IJKL”,”MNOP”,”QRST”,”UVwX”};

char**p;

int i:

p=alpha;

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

printf(”%s”,p[I]);

}

A)ABCDEFGHIJKL            B)ABCD

C)ABCDEFGHIJKLMNOP        D)AEIM

答案:C

评析:alpha[O]指向“ABCD”的首地址;alpha[1]指向“EFGH”的首地址;alpha[2]指向“IJKL”的首地址,依此类推。当执行到p=alpha后,p指向指针数组alpha的首地址。for循环中输出了4个字符串。

(38)下面程序的输出结果是_________。

#include

main()

{  char*p[]={”B00L”,”0PK”,”H”,”SP”};

int i:

for(i=3;i>=0;i–,i–)

printf(“%c”,*p[i]);

printf(”\n”);

}

A)SO    B)SP    C)SPOPK    D)SHOB

答案:A

评析:p[0]存放的是“BOOL\0”的首地址;p[1]存放的是“OPK\0”的首址等。

在printf语句中输出的+p[I]表示p[i]字符串的第一个字符。在for循环中,i的初值为3,那么输出的第一个字符为“s”,接着两次i–,则输出的值为+p[1],即字符“0”,所以本题的输出为SO。

(39)以下程序的输出结果是_________。

#include

void prt(int*x,int*y,int*z)

{   printf(”%d,%d,%d\n”,++*x,++*y*(z++));}

int a=10,b=40,c=20;

main()

{  prt(&a,&b&C);

prt(&a,&b,&C);

}

A)ll,42,3l    B)ll,41,20    C)1l,21,40    D)11,41,2l

12,22,41      12,42,20      11,2l,41      12,42,22

答案:B

评析:由于实参传送的是变量的地址,所以对形参指针所指向的单元内容的改变,即对实参内容的改变。

(40)若一个外部变量的定义形式为static int x;,那么,其中static的作用应该是_______。

A)将变量存储在静态存储区

B)使变量x可以由系统自动初始化

C)使x只能在本文件内引用

D)使x的值可以永久保留

答案:C

评析:事实上,无论有无static修饰,外部变量都具有A、B和c三种特性。作为一种修饰,static仅是限制此类型外部变量的引用范围:只能在定义它的文件范围内使用。

(41)以下程序的输出结果是________。

#include

#define SQR(x)x*x

main()

{  int a,k=3;

a=++SQR(k+1);

printf(”%d\n”,a);

}

A)8    B)9    C)17    D)20

答案:B

评析:本题宏替换中遇到形参x以实参k+l代替,其它字符不变。sQR(k+1)展开后应为字符串k+l*k+l。

(42)下面是对宏定义的描述,不正确的是_______。

A)宏不存在类型问题,宏名无类型,它的参数也无类型

B)宏替换不占用运行时间

C)宏替换时先求出实参表达式的值,然后代入形参运算求值

D)宏替换只不过是字符替代而已

答案:C

评析:宏替换实质上就是字符替代,它不可能去进行计算,故c是错误的。带参数的宏与函数相比,宏在程序编译之前已经将代码替换到程序内,执行时不会产生类似于函数调用的问题,可以说不占用运行时间。

(43)以下程序(程序左边的数字为附加的行号)________。

1#include

2#include

3main()

4{char s[]=”string”;

5  puts(s);

6  strcpy(s,”hello”);

7  printf(”%3s\n”,s);}

A)没有错      B)第l行有错      C)第6行有错    D)第7行有错

答案:B

评析:字符串复制函数strcpy包含在头文件string.h中,因此,程序中的第l行文件包含命令是错误的。

(44)若有如下说明,则__________的叙述是正确的。

struct st

{  int a;

int b[2l;

}a;

A)结构体变量a与结构体成员a同名,定义是非法的

B)程序只在执行到该定义时才为结构体st分配存储单元

C)程序运行时为结构体st分配6个字节存储单元

D)类型名struct st可以通过extern关键字提前引用(即引用在前,说明在后)

答案:D

评析:结构体变量a与结构体成员a同名是合法的定义,引用成员a的方法是a.a,变量a处于不同的“层次”上,系统完全能够分清。st是一个结构体名,不会为结构体名分配存储空间,应该是在运行时为结构体变量a分配6个字节的存储单元,故选项B和选项C错误。

(45)若有以下结构体定义,则________是正确的引用或定义。

struct example

{  int x;

int y;

}v1;

A)example.x=10          B)example v2.x=10

C)struct v2;v2.x=lO    D)struct example v2={10};

答案:D

评析:在定义结构体变量时,不能只用结构体名example或关键字strum进行定义,必需要用结构体类型名struct example定义,在引用结构体成员变量时,需要用结构体变量名进行引用,所以选D。

(46)下列程序的执行结果是_________。

#include

union un

{  int i;

char c[21;

};

void main()

{ union un x;

x.c[0]=10:

x.c[1]=1:

printf(“\n%d”,x.i);

}

A)266    B)ll    C)265    D)138

答案:A

评析:由于本题定义的是共用体,所以成员表列中的整型变量x和字符数组c共占用同一个存储单元,且此存储单元为2个字节,通常c[O]位于低字节,c[1]位于高字节,所以x.i的值为266。

(47)已知形成链表的存储结构如下图所示,则下述类型描述中的空白处应填_______。

struct link

Datanext{   char data;

___________

}node;

A)struct link next    B)link*next

C)struct next link    D)struct link*next

答案:D

评析:在单向链表中,由于每个结点需要存储下一个结点的地址,且下一个结点的数据类型与前一个结点的数据类型完全相同,故应为struct link*next。

(48)已知小写字母a的ASCII码为97,大写字母A的ASCII.码为65,以下程序的结果是__________。

main()

{  unsigned int a=32,b=66;

printf(“%c\n”,atb);

}

A)66    B)98    C)b    D)B

答案:C

评析:位运算符“l”的作用是按位或,即两个二进制数的相应位中只要有一个为1,该位的结果值为l。最后以字符型输出,  98对应的字符“b”。

(49)C语言库函数龟ets(str,n,fp)的功能是_________。

A)从fp指向的文件中读取长度n的字符串存入str指向的内存

B)从fp指向的文件中读取长度不超过n-l的字符串存入str指向的内存

C)从fp指向的文件中读取n个字符串存/Xstr指向的内存

D)从str读取至多n个字符到文件fp

答案:B

评析:fgets函数的作用是从指定的文件读入一个字符串。fgets(str,n,fp);中的n为要求得到的字符的个数,但只从fb指向的文件输入n-1个字符,然后在最后加一个‘\O’字符,因此得到的字符串共有n个字符。

(50)下述的程序向文件输出的结果是__________。

#include

void main()

{  FILE*fp=fopen(“TEST”,”wb”);

fprintf(fp,”%d%5.0f%c%d”,58,76273.0,’-',2278);

fclose(fp);

}

A)58 76273-2278      B)5876273。.000000-2278

C)5876273-2278       D)因文件为二进制文件而不可读

答案:C

评析:fprintf函数工作时,多个数据间不会自动加分隔符,选项A错误;浮点数的输出格式是“%5.0f”表明其小数部分输出O位,即没有输出,所以选项B也是错误的。

二、填空题(每空2分,共40分)

请将每个空的正确答案写在【l】至【20】序号的横线上,答在试卷上不得分。

(1)对于长度为n的顺序存储的线性表,当随机插入和删除一个元素时,需平均移动元素的个数为  【l】  。

答案:【1】n/2

评析:删除一个元素,平均移动的元素个数为(n-l+n-2+……+0)n=(n-1)/2;插入一个元素,平均移动元素个数为(n+n-l+n-2+……+1)n=(n+1)/2;所以总体平均移动元素个数为n/2。

(2)注释说明了程序的功能,它分为  【2】  注释和功能性注释。

答案:【2】序言性

评析:注释一般分为序言性注释和功能性注释。

(3)软件测试中路径覆盖测试是整个测试的基础,它是对软件  【3】  进行测试。

答案:【3】结构

评析:路径测试是白盒测试方法中的一种,它要求对程序中的每条路径最少检查一次,目的是对软件的结构进行测试。

(4)数据库技术的主要特点为数据的集成性、数据的高  【4】  和低冗余性、数据独立性和数据统一管理与控制。

答案:【4】共享性

评析:数据库技术的主要特点有以下几个方面:数据的集成性,数据的高共享性与低冗余性,数据韵独立性,数据统一管理与控制。

(5)数据元素之间  【5】  的整体称为逻辑结构。

答案:【5】逻辑关系

评析:数据元素之间逻辑关系的整体称为逻辑结构。数据的逻辑结构就是数据的组织形式。

(6)若有定义int m=5,y=2,则执行表达式y+=y-=m*=y后,y的值为  【6】  。

答案:【6】.16

评析:将赋值运算符右侧的“表达式”的值赋给左侧的变量,并且赋值运算符按照“白右而左”的结合顺序,本题表达式应先算m的值为10,再运算y的值为8,最后计算y=y+(-8)=-8+(-8)=-16。

(7)若x和y都是double型变量,]ix的初值为3.0,y的初值为2.0,则表达式pow(y,fabs(x))的值为  【7】  。

答案:【7】8.000000

评析: fabs函数功能是求x的绝对值,计算结果为double型。pow功能是计算x的y次方的值,计算结果同样为double型。所以本题表达式相当于2.0的3.0次方,结果为8.000000。

(8)设有char a,b;,若要通过a&b运算屏蔽掉a中的其它位,只保留第2位和第8位(右起为第1位),则b的二进制是  【8】  。

答案:【8】10000010

评析:运算“&”的规则是只有当两个相应的二进制位都为1时,该位的结果才为1。要保留第2、8位,只要将其与二进制数10000010相与。

(9)下列程序执行后输出的结果是  【9】  。

f(int a)

{  static c=0;

C=a+C++:

return(C);

}

main()

{  int a=2,i,k;

for(i=O;i<2;i++)

k=f(a++);

printf(”%d\n”,k);

}

答案:【9】7

评析:在程序执行时,static变量仅初始化一次,下次使用时将使用上次保存的值。

(10)下面程序执行后输出的结果是  【10】  。

int m=13:

int fun(int x,int y)

{  int m=3;

return(x*y-m);

}

main()

{  int a=7,b=5;

printf(”%d\n”,fun(a,b)/m);

}

答案:【10】2

评析:本题变量m既是外部变量(值是13),又是fun函数的局部变量(值为3)。函数fun(x*y-m)的值为7*5-3=32,在main函数中,ftm(a,b)/m中的m应取外部变量的值13,因此输出2。

(11)下列程序执行后输出的结果是  【11】  。

main()

{  nt arr[10],i,k=0;

for(I=0;i

for(I=1;i<4;i++)k+=arr[i]+i;

printf(”%d\n”,k);

}

答案:【11】12

评析:本题的第一个for循环是用于给数组arr赋初值,第二个for循环用于求和运算。由于第二个for循环初始值为1,而循环条件为i<4,所以求的是art[1]到arr[3]及i的和,所以输出结果为12。

(12)下列程序执行后输出的结果是 【12】 。

struct s

{int x,y;}data[2]={10,100,20,200};

main()

{

struct s*p=data;

printf(”%d”,++(p->x));

}

答案:【12】11

评析:程序中结构体数组data首地址(即&data[0])赋值给结构体指针变量p,++(p->x)表示先将p所指向的结构体变量的成员x值加1,然后将此x(即data[01.x]输出。

(13)下面程序有两个printf语句,如果第一个printf语句输出的是194,则第二个print语句的输出结果是  【13】  。

main()

{ int a [10]={1,2,3,4,5,6,7,8,9,0},*p;

p=a;

printf(”%X\n”,p);

printf(”%x\n”,p+9);

}

答案:【13】la6

评析:对于指针变量的运算,就是对于地址的运算。本题中由于指针指向的是整型变量,所以,使指针变量移动9个位置也就是移动18个字节。注意,本题是以16进制输出的。

(14)以下函数的功能是计算s=l+l/2!+l/3!+…+l/n!,请填空.

double fun(int n)

{  double s=O.O,fac=1.O;

int i,k=1;

for(i=l;i<=n;i++)

{    【14】  ;

fat=fat/k;

s=s+fac;

}

}

答案:【14】k=k*i

评析:本题中通过for循环求s表达式中每一项的和,表达式“fac=fac/k;”求的是每一项的值,所以k的值应为n!,在求n!的时候,可以用上次循环阶乘的值乘i,就可以直接得此次n!,故本题填k=k*i。

(15)下面程序的运行结果是  【15】  。

main()

{  unsigned a=0112,x;

x=a>>3:

printf(”x=%o”,x);

}

答案:【15】x=11

评析:在对无符号数的右移是高位补0。

(16)函数(s,i,n)是作用是从字符串s中删除从第i个字符开始的n个字符,请填空。

void (char s[],int i,int n)

{  int j,k,length=O;

while(s[1ength])

【16】  ;

–i:

j=i;

}

if(  【17】  )

{  k=i+n;

if(i+n<=length)

while(k

s[j++]=s[k++];

s[j]=‘\0’;

}

答案:【16】length++

【17】i

评析:第一个循环极有可能是这个计算串的长度,在i<=length时字符才被删除,被删除的是从第i个到第i+n或最后一个间的所有字符。删除前,应判断i<=length。由于已经进行了一i运算,故实际应填入i

(17)下述函数统计一个字符串中的单词个数,单词是指处在空格之间的字符序列,请填空。

int word(char*s)

{ int num=O,flag=O;

while(*s)

{ if(  【18】  ==”)flag=O;

else if(  【19】  ){flag=1;num++}

}

return  【20】  ;

}

答案:【18】*s++

【19】flag==O或*(s-1)==”

【20】num

评析:在统计字符串单词个数的算法中,本题的flag是为了记录一个单词是否结束了。在第18空应填写*s++;如果某个字符不是空格,则必需判断它是否是单词,如果是,则使得flag的标志为1,num的值加1。本题判断方法是:先判断s所指向的字符是否为空格,如果是则使得flag=O,否则判断前一个字符是否是空格,如果是的话,则说明这个字符是一个单词的开始,将flag标志为1,num的值加1,如果不是,则不必记录。故第19空应flag==O或*(s-1)==”;最后一个空格需填写的是返回的单词的个数,即num。

【c语言面试题】相关文章:

1.c语言实验报告范文

2.C语言实验报告《指针》

3.c语言课程设计计划书

4.谭浩强c语言课件指针

5.c语言二级考试试题

6.产品的肢体语言?C交互动画

7.Yahoo-PHP面试题

8.php 面试题

9.计算机二级考试《C语言》上机答题技巧

10.面向智能科学与技术专业的C语言教学探讨

下载word文档
《c语言面试题.doc》
将本文的Word文档下载到电脑,方便收藏和打印
推荐度: 评级1星 评级2星 评级3星 评级4星 评级5星
点击下载文档

文档为doc格式

  • 返回顶部