华为面试题C语言软件工程师

华为面试题C语言软件工程师（精选5篇）

篇1：华为面试题C语言软件工程师

那就是变量i没有定义，这在代码编译阶段编译器可以帮你发现，很容易搞定。然而很多问题是自己造成的漏洞，编译器是帮不上什么忙的。这里最大的问题还是str1没有结束符，因为strcpy的第二个参数应该是一个字符串常量。该函数就是利用判断第二个参数的结束符来得到是否拷贝完毕。所以在for循环后面应加上str1p[9] = ‘’;

PS：字符数组和字符串的最明显的区别就是字符串会被默认的加上结束符’’。void test3(char* str1){

char string[10];

if(strlen(str1)<=10)

{

strcpy(string, str1);

} }

这里的问题仍是越界问题。strlen函数得到字符串除结束符外的长度。如果这里是<=10话，就很明显越界了。

小结：上面的三个找错的函数，主要是考查对字符串和字符数组的概念的掌握以及对strcpy函数和strlen函数的理解。

2、找错

DSN get_SRM_no(){

static int SRM_no;

int I;“>

for(I=0;I

{

SRM_no %= MAX_SRM;

if(MY_SRM.state==IDLE)

{

break;

}

}

if(I>=MAX_SRM)

return(NULL_SRM);

else

return SRM_no;} 这里for循环的判断语句是后来我加上的，估计在网上流传的时候被人给弄丢了，根据对程序的分析，给补上了。估计错误应该不是这儿。

简单的阅读一下这个函数，可以大概的可以猜测出这个函数的功能是分配一个空闲的SRAM块。方法：从上次分配的RAM块后的RAM块开始检测SRAM每个RAM块，看是否是IDLE状态，如果是IDLE则返回当前的RAM块的号SRM_no。如果所有的RAM块都不是IDLE状态，则意味着无法分配一个RAM给函数调用者，返回一个表示没有RAM可分配的标志（NULL_SRM）。

经过上面的分析，则这里可以知道，这个函数的错误是for循环里面没有给SRM_no这个变量累加1。

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));

} } 运行结果是：8,10,12,14,16, 在求和函数sum里面c是auto变量，根据auto变量特性知每次调用sum函数时变量c都会自动赋值为0。b是static变量，根据static变量特性知每次调用sum函数时变量b都会使用上次调用sum函数时b保存的值。

简单的分析一下函数，可以知道，若传入的参数不变，则每次调用sum函数返回的结果，都比上次多2。所以答案是：8,10,12,14,16，4、func(1)＝ ？ int func(int a){

int b;

switch(a)

{

case 1: 30;

case 2: 20;

case 3: 16;

default: 0;

}

return b;} 在 case 语句中可能忘记了对变量b赋值。如果改为下面的代码： int func(int a){

int b;

switch(a)

{

case 1: b = 30;

case 2: b = 20;

case 3: b = 16;

default: b = 0;

}

return b;} 因为case语句中漏掉了break语句，所以无论传给函数的参数是多少，运行结果均为0。

5、a[qp] = a[2] = 2;

6、内存空间占用问题

定义 int **a[3][4], 则变量占有的内存空间为：16位系统24，32位编译系统中是48。PS：公式：3 * 4 * sizeof(int **)。

7、程序编写

编写一个函数，要求输入年月日时分秒，输出该年月日时分秒的下一秒。如输入2004年12月31日23时59分59秒，则输出2005年1月1日0时0分0秒。

void ResetTheTime(int *year,int *month,int *date,int *hour,int *minute,int*second){

int dayOfMonth[12]={31,28,31,30,31,30,31,31,30,31,30,31};

if(*year < 0 || *month < 1 || *month > 12 ||

*date < 1 || *date > 31 || *hour < 0 || *hour > 23 ||

*minute < 0 ||*minute > 59|| *second <0 || *second >60)

return;if(*year%400 == 0 || *year%100!= 0 && *year%4 == 0)

dayOfMonth[1] = 29;

if(*second >= 60)

{

*second = 0;

*minute += 1;

if(*minute >= 60)

{

*minute = 0;

*hour += 1;

if(*hour >= 24)

{

*hour = 0;

*date += 1;

if(*date > dayOfMonth[*month-1])

{

*date = 1;

*month += 1;

if(*month > 12)

{

*month=1;

*year += 1;

}

}

} } return }

篇2：华为面试题C语言软件工程师

#include

#include

typedef struct array1{

int ID;

struct array1* next;

}A;

typedef struct array2{

int ID;

int a;

int b;

int c;

}* B;

int main

{

A s1[15];

A* s2;

B s3;

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

{

s1[i].ID=i+64;

}

s2=s1+3;

s3=(B)s2;

printf(”%d/n“,s3->b);

return 0;

篇3：C语言面试题大13

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)。

篇4：C语言面试题大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：C语言面试题大7

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