C语言使用注意事项(二)

原创作品，转载请标明http://blog.csdn.net/yming0221/article/details/7235085

更多查看

C语言使用注意事项(一)

C语言使用注意事项(三)

1、如何使用指针调用函数

如下例

[cpp] view plain copy print ?

1. #include <stdio.h>  
2. void func()  
3. {  
4.         printf("asdfg\n");  
5. }  
6.   
7. void (*fp)();  
8.   
9. int main(int argc,char **argv)  
10. {  
11.         fp=func;  
12.         (*fp)();  
13.         return 0;  
14. }  

我们认为一个函数指针必须前面加上*后面加一个额外的括号从而转换成一个真正的函数，就如上例。

但是下面的方法也可以正确执行

[cpp] view plain copy print ?

1. #include <stdio.h>  
2. void func()  
3. {  
4.         printf("asdfg\n");  
5. }  
6.   
7. void (*fp)();  
8.   
9. int main(int argc,char **argv)  
10. {  
11.         fp=func;  
12.         fp();  
13.         return 0;  
14. }  

由于函数的调用其实就是通过指针实现，而真正的函数总是饮食的退化为指针。ANSI C解释*符号不再需要，但依然兼容。

2、strcpy,strncpy,strdup的用法和实现

char * strcpy ( char * destination, const char * source );

功能：复制字符串，复制source至destination，返回目的串的地址。

源长>目标长，将源中长度等于目标长的部分复制到目的串
源长<目标长，将源中全部字符复制到目的串，不包括最后的'\0'

[cpp] view plain copy print ?

1. /*********************************************** 
2.  * 字符串复制函数 
3.  * 源长>目标长，将源中长度等于目标长的部分复制到目的串 
4.  * 源长<目标长，将源中全部字符复制到目的串，不包括最后的'\0' 
5.  * ************************************/  
6. char * strcpy(char * destination,const char * source)  
7. {  
8.         if(destination == NULL || source == NULL) return NULL;  
9.         char * tmp=destination;  
10.         for(;*source != '\0';destination++,source++)  
11.         {  
12.                 *destination = *source;  
13.         }  
14.         return tmp;  
15. }  

例如

char* src="how are you ?";
char des[20]="ABCDEFGHIJKLMNOPQRS;

strcpy(des,src); 

结果des为

char * strncpy ( char * destination, const char * source, size_t num );

功能：复制字符串，复制源中定长的字符串到目标字符串

目标长>指定长>源长，则将源长全部拷贝到目标长，自动加上'\0'
指定长<源长，则将源长中按指定长度拷贝到目标字符串，不包括'\0'
指定长>目标长，出错ERROR

[cpp] view plain copy print ?

1. /** 
2.  * strncpy - Copy a length-limited, %NUL-terminated string 
3.  * @dest: Where to copy the string to 
4.  * @src: Where to copy the string from 
5.  * @count: The maximum number of bytes to copy 
6.  * 
7.  * The result is not %NUL-terminated if the source exceeds 
8.  * @count bytes. 
9.  * 
10.  * In the case where the length of @src is less than  that  of 
11.  * count, the remainder of @dest will be padded with %NUL. 
12.  * 
13.  */  
14. char *strncpy(char *dest, const char *src, size_t count)  
15. {  
16.         char *tmp = dest;  
17.   
18.         while (count) {  
19.                 if ((*tmp = *src) != 0)  
20.                         src++;  
21.                 tmp++;  
22.                 count--;  
23.         }  
24.         return dest;  
25. }  

char *strdup(char *src)
功能：将src字符串复制到新的位置，返回值即为目的串地址，其目的串地址是由malloc()分配，使用完毕须用free()释放。

[cpp] view plain copy print ?

1. char *strdup(char *src)  
2.  {  
3.         char *tmp = NULL;  
4.         if(src!=NULL && (tmp=malloc(strlen(src)+1)) !=NULL )  
5.                 strcpy(tmp,src);  
6.         return tmp;  
7.  }  

3、NULL（空指针）到底是什么？

每个指针都有一个特殊的值，空NULL，这与其他对象或函数的地址都不相同，也就是说在程序中通过&（取地址运算符）永远无法得到NULL地址。

当一个指针类型的变量被赋予0值，那么编译器在编译的时候会将其作为NULL指针，即在指针初始化、比较、赋值的时候NULL可用0代替。即自己定义

#define NULL 0

如果NULL要以函数参数传递的时候，编译器可能不知道这是指针类型的变量而把其当作是常数0看待，这是可以进行强制类型转换(char *)0来使编译器将其作为NULL来使用。即

#define NULL ((void *)0)

所以空指针的使用注意

*在源码中使用空指针常数时，则使用0或NULL

*在函数的参数传递时如果使用空指针，则使用NULL或相应的类型指针0（(type *)0）

4、if(p)这样判断是否是空指针正确吗？

if(p)相当于if(p != 0)

完全合法，但是一些人认为这样的风格不好。

在指针上下文中NULL和0是完全等价的。

5、char a[n]和char *a的区别

例如：

char a[6]="world";

表示定义一个有6个存储空间的连续地址空间，首地址是a，故a[i]可以修改。

char *p="world";

表示定义一个指针，该指针指向一个有6个连续地址空间的首地址。

如下图示意：

6、和5不同，为什么在函数参数中指针和数组可以等价

[cpp] view plain copy print ?

1. void func(char a[])  
2. {  
3. ........  
4. }  

和

[cpp] view plain copy print ?

1. void func(char *a)  
2. {  
3. ........  
4. }  

相同，这种等价只局限于形参的传递，别的地方并不适用。

7、和5不同的是，C语言中“指针与数组等价”该如何理解？

数组的定义中，如果一个数组变量出现在=的左边，即作为左值出现，那么它立刻蜕化为一个相应类型的指针。

8、如何给二位数组动态分配内存？

[cpp] view plain copy print ?

1. int dmalloc(int **arg)  
2. {  
3.         int cols=6;  
4.         int rows=6;  
5.         arg=malloc( rows*sizeof(int *) );  
6.         int i,j;  
7.         for(i=0;i<cols;i++)  
8.         {  
9.                 arg[i]=malloc( cols*sizeof(int) );  
10.         }  
11.         for(i=0;i<rows;i++)  
12.         {  
13.                 for(j=0;j<cols;j++) arg[i][j]=i*j,printf("%d ",arg[i][j]);  
14.                 printf("\n");  
15.         }  
16.         for(i=0;i<cols;i++) free(arg[i]);  
17.         free(arg);  
18. }  

9、二维数组参数的传递的方法

int arr[rows][cols];

[cpp] view plain copy print ?

1. void func(int arr[][cols])  
2. {  
3. .............  
4. }  

或者

[cpp] view plain copy print ?

1. typedef ap *arr  
2. void func(int ap[cols])  
3. {  
4. .............  
5. }  

10、当数组以参数的方式传递后，参数内sizeof()无法获得数组的大小

由于数组以形参传递后，实质是传递的一个指针，首地址，所以在函数内通过sizeof获得的不是数组的大小，而是指针的大小。