一些c语言面试题

http://hi.baidu.com/gilbertjuly/blog/item/171e19654c246afcf6365408.html

 

1.strlen, sizeof, strcpy
strlen的结果未统计’/0’所占用的1个字节
strcpy(), 以源串中的'/0'为拷贝结束标志, 直到遇到该NULL为止, 然后将NULL拷贝上. 
strncpy()以第三个参数N为拷贝结束标志, 如果source的长度小于N, 则剩余的字符全部用NULL填充. 如果source的长度大于N, 则从source中截取前N个字符,拷贝过去.

2.野指针
在free(str)后未置str为空，导致可能变成一个“野”指针。 野指针，有可能指向系统区，操作不当会导致程序运行的崩溃。

3.浮点数
浮点型变量并不精确，所以不可将float变量用“==”或“！=”与数字比较，应该设法转化成“>=”或“<=”形式。

4.数组名
数组名指代一种数据结构，这种数据结构就是数组；
数组名可以转换为指向其指代实体的指针，而且是一个指针常量，不能作自增、自减等操作，不能被修改；
数组名作为函数形参时，沦为普通指针。在函数体内，数组名失去了本身的内涵，仅仅只是一个指针；在失去其内涵的同时，它还失去了其常量特性，可以作自增、自减等操作，可以被修改。

5.结构体/类
将属于一个整体的数据成员组织为一个结构体/类，利用指针类型转换，可以将memcpy、memset等函数直接用于结构体地址，进行结构体的整体操作。

6.形参
形参和实参的类型必须要一致, 或者要符合隐含转换规则, 当形参和实参不是指针类型时, 在该函数运行时, 形参和实参是不同的变量, 他们在内存中位于不同的位置, 形参将实参的内容复制一份, 在该函数运行结束的时候形参被释放,
而实参内容不会改变.
而如果函数的参数是指针类型变量, 在调用该函数的过程中, 传个函数的是实参的地址, 在函数体内部使用的也是实参的地址, 即使用的就是实参本身. 所以在函数体内部可以改变实参的值.

7.Little Endian/big Endian
首先记住存储单元的地址总是由低到高排列。对于多字节的数值，如果先见到的是低位的字节，则系统就是Little Endian的，Little 就是"小，少"的意思，也就对应"低"。相反就是Big Endian，这里 Big "大"对应"高"。

8.十进制转二进制
整数：除2取余
小数：乘2取整

9.32 位的 float型.
一个浮点数 X, 在计算机中表示为:
X = a  *  2^e  
这里 e 代表指数,  a 代表尾数,   在 计算机内部, 他们都是用二进制表示的. 其中 a 用二进制的科学表示法表示, 由于科学表示法第一位总是1 (0除外) , 所以第一位略去不计.  e 表示的时候, 因为要表示出负数, 所以 要加上127 ,  实际运算的时候要减去 127.

10.字节数

数据类型名称	字节数	别名	取值范围
int	*	signed,signed int	由操作系统决定，即与操作系统的＂字长＂有关
unsigned int	*	unsigned	由操作系统决定，即与操作系统的＂字长＂有关
__int8	1	char,signed char	–128 到 127
__int16	2	short,short int,signed short int	–32,768 到 32,767
__int32	4	signed,signed int	–2,147,483,648 到 2,147,483,647
__int64	8	无	–9,223,372,036,854,775,808 到 9,223,372,036,854,775,807
bool	1	无	false 或 true
char	1	signed char	–128 到 127
unsigned char	1	无	0 到 255
short	2	short int,signed short int	–32,768 到 32,767
unsigned short	2	unsigned short int	0 到 65,535
long	4	long int,signed long int	–2,147,483,648 到 2,147,483,647
long long	8	none (but equivalent to __int64)	–9,223,372,036,854,775,808 到 9,223,372,036,854,775,807
unsigned long	4	unsigned long int	0 到 4,294,967,295
enum	*	无	由操作系统决定，即与操作系统的＂字长＂有关
float	4	无	3.4E +/- 38 (7 digits)
double	8	无	1.7E +/- 308 (15 digits)
long double	8	无	1.7E +/- 308 (15 digits)
wchar_t	2	__wchar_t	0 到 65,535

类型标识符	类型说明	长度 （字节）	范围	备注
char	字符型	1	-128 ~ 127	-27 ~ (27 -1)
unsigned char	无符字符型	1	0 ~ 255	0 ~ (28 -1)
short int	短整型	2	-32768 ~ 32767	2-15 ~ (215 - 1)
unsigned short int	无符短整型	2	0 ~ 65535	0 ~ (216 - 1)
int	整型	4	-2147483648 ~ 2147483647	-231 ~ (231 - 1)
unsigned int	无符整型	4	0 ~ 4294967295	0 ~ (232-1)
float	实型（单精度）	4	1.18*10-38 ~ 3.40*1038	7位有效位
double	实型（双精度）	8	2.23*10-308 ~ 1.79*10308	15位有效位
long double	实型（长双精度）	10	3.37*10-4932 ~ 1.18*104932	19位有效位

11.printf格式

格式字符	说    明
d,i	以带符号的十进制形式输出整数（正数不输出符号）
o	以八进制无符号形式输出整数（不输出前导符0）
x,X	以十六进制无符号形式输出整数（不输出前导符0x）,用x则输出十六进制数的a～f时以小写形式输出，用X时，则以大写字母输出
u	以无符号十进制形式输出整数
c	以字符形式输出，只输出一个字符
s	输出字符串
f	以小数形式输出单、双精度数，隐含输出6位小数
e,E	以指数形式输出实数
g,G	选用%f或%e格式中输出宽度较短的一种格式，不输出无意义的0

字符串strlen、sizeof，堆栈，字节长度，宏定义等：

编写strcpy函数：

#include <stdio.h> #include <stdlib.h> #include <string.h> //#include <iostream> char *mystrcpy(char *mDst, const char *mSrc)//2.注意形参和返回值 { char *p; if((mSrc==NULL)&&(mDst==NULL))//3.指针判断 return NULL; //printf("sizeof(mSrc):%d/n",strlen(mSrc)); //不用strlen，不高效 p=mDst; while(*mSrc!='/0') { *mDst++=*mSrc++; } *mDst='/0'; return p; } int main() { char *mSrc="hello world!"; char mDst[100];//1.开辟空间 mystrcpy(mDst,mSrc); printf("Src:%s/n",mSrc); printf("Dst:%s/n",mDst); printf("sizeof(mSrc):%d/n",sizeof(mSrc)); printf("sizeof(mSrc):%d/n",strlen(mSrc)); printf("sizeof(mDst):%d/n",sizeof(mDst)); printf("sizeof(mDst):%d/n",strlen(mDst)); return (0); }

 

 

字符串倒序：

C语言:

#include <stdio.h> char *mystrsort(char *dst, const char *src) { int strlength; char *p; if((src==NULL)&&(dst==NULL)) return NULL; strlength=strlen(src); p=dst+strlength; *p='/0'; p=p-1; while(*src!='/0') { *p--=*src++; } return dst; } int main() { char *src="abcdefg"; char dst[100]; mystrsort(dst,src); printf("Src:%s/n",src); printf("Dst:%s/n",dst); return (0); }

进制转换，置位清零，32位倒序：

C语言:

#include <stdio.h> #include <stdlib.h> #include <string.h> #define BIT (0x80000000) //用宏定义表示相应的位 #define BIT3 (0x01<<3) //用宏定义表示相应的位 #define BASE 2 void dectobase(unsigned int src,int *x); int mybitset(int src) { int dst=0; dst=src|BIT3; return dst; } int mybitclr(int src) { int dst=0; dst=src&(~BIT3); return dst; } void dectobin(unsigned int src,int *x)//方法是相除取余 { //int x[100]; int i=0; unsigned int temp; temp=src; //printf("temp: %d /n",temp ); while(1) { x[i]=temp%2; temp=temp/2; if(temp==0) break; i++; //printf("temp: %u x[i]: %d i: %d/n",temp,x[i],i); } printf("Dec: %u 's bin transfrom:/n",src); printf("Bin: "); for(;i>=0;i--) { printf("%u",x[i]); if(i%4==0) printf(" "); } printf("/n---------------/n"); } void dectohex(unsigned int src,int *x)//方法是相除取余 { //int x[100]; int i=0; unsigned int temp; temp=src; //printf("temp: %d /n",temp ); while(1) { x[i]=temp%16; temp=temp/16; if(temp==0) break; i++; //printf("temp: %u x[i]: %d i: %d/n",temp,x[i],i); } printf("Dec: %u 's hex transfrom:/n",src); printf("Hex: "); for(;i>=0;i--) { printf("%x",x[i]); if(i%4==0) printf(" "); } printf("/n---------------/n"); } void bintodec(char *s)//次方累加, '1'加, '0'不加 { int dst=0; int mlen; int temp=1; mlen=strlen(s); //printf("---------------/n"); printf("%d/n",mlen); mlen--; for(;mlen>=0;mlen--) { if(s[mlen]=='1') dst=dst+temp; else dst=dst+0; temp=temp*2; } printf("%s/n",s); printf("%u/n",dst); } int mybitsw(unsigned int src)//取位, 移位(移位的多少是i的线性代数) { unsigned int dst=0; unsigned int temp; // bool testbool; unsigned int bit=0x80000000; int i=0; for(i=0;i<32;i++) { temp=src&bit; if(i<=15) dst=dst+(temp>>(31-2*i)); else dst=dst+(temp<<(2*i-31)); printf("temp: %x; bit: %x; dst: %x; /n",temp,bit,dst); bit=bit>>1; } printf("%u/n",src); printf("%u/n",dst); return dst; } int main() { int src=0xabcd; unsigned int srcc=2147483646; int dst; int x[100]; int x1=0x0f;//十六进制表示，前加0x int x2=15; //十进制表示 int x3=017; //八进制表示，前加0 //c语言中没有二进制表示 char *binstr="01111111111111111111111111111111"; printf("---------------/n"); printf("%d/n",x1); printf("%d/n",x2); printf("%d/n",x3); printf("---------------/n"); printf("%u/n",BIT3); printf("%u/n",~BIT3);//%u是无符号十进制输出, (FFF7)H=(4294967287)D printf("%x/n",BIT3); printf("%x/n",~BIT3);//%x是十六进制输出 printf("---------------/n"); dectobin(~BIT3,x); dectohex(~BIT3,x); dectohex(src,x); dst=mybitset (src); dectobin(dst,x); dst=mybitclr (src); dectobin(dst,x); bintodec(binstr); //dst=mybitsw(src); printf("---------------/n"); mybitsw(srcc); return (0); } void dectobase(unsigned int src,int *x)//十进制转换为BASE进制, BASE为宏定义, 可更改 { //方法是相除取余 //int x[100]; int i=0; unsigned int temp; temp=src; //printf("temp: %d /n",temp ); while(1) { x[i]=temp%BASE; temp=temp/BASE; if(temp==0) break; i++; //printf("temp: %u x[i]: %d i: %d/n",temp,x[i],i); } printf("Dec: %u 's base transfrom:/n",src); for(;i>=0;i--) { if(BASE<=10) printf("%u",x[i]); else if(BASE==16) printf("%x",x[i]); else { printf("进制出错/n"); break; } if(i%4==0) printf(" "); } printf("/n---------------/n"); }

冒泡法排序：

C语言:

#include <stdio.h> void mybubblesort(int *data, int number) { //冒泡法是一种比较慢的算法 //它每次可以排序一个数，第一次最大（最小），第二次次大（次小）。。。 //所以一共要n-1轮排序，第i轮要进行n-1-i次比较 //复杂度属于O(n*n)。 int i,j,temp; for(i=0;i<number-1;i++) for(j=0;j<number-1-i;j++)//注意这个j的范围 { if(data[j]>data[j+1]) { temp=data[j+1]; data[j+1]=data[j]; data[j]=temp; } } } int main() { int data[]={10,9,8,7,6,5,4}; int i; for (i=0;i<7;i++) printf("%4d",data[i]); printf("/n"); mybubblesort(data,7); for (i=0;i<7;i++) printf("%4d",data[i]); printf("/n"); return (0); }