@lishuhuakai
2015-05-18T00:23:26.000000Z
字数 4918
阅读 2569
c
一般来说有两种方法,第一种思路是将数据的首地址以返回值的方法返回,第一种方法如下:
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
char *newBuf(int num)
{
char *p;
p = (char *)malloc(num * sizeof(char));
return p;
}
void deleteBuf(char *p)
{
if (p != NULL)
{
free(p);
p = NULL; //垃圾代码,执行了也不会有任何用处
}
}
void main()
{
char *p = NULL;
p = newBuf(100);
printf("p :%x\n", p);
deleteBuf(p);
system("pause");
}
第一种方法虽然可用,但是实际上并不好,要是需要新建多个数据然后返回呢?显然返回值不能有多个。第二种方法是利用指针的间接赋值的性质,下面是第二种方法:
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
//间接赋值是指针存在的最大意义
void modifyP(int *p)
{//用一级指针去修改零级指针(通常是实参)的值
*p = 20;
}
void main_01()
{
int a = 0; //定义一个实参变量
int *p = NULL; //定义一个形参
p = &a;
*p = 10; //间接修改a的值*(a的地址)去间接修改a的值
modifyP(&a);
printf("%d\n", a);
system("pause");
}
void getNewBuf(char **p)
{//用二级指针(通常是形参)去修改一级指针(通常是实参)的值
//相当于在被调用函数里面分配内存,把结果给传出来了
//这就是指针做函数参数的精华
*p = 0x33;//间接修改p的值*(p的地址)去间接修改p的值
char *tmp = NULL;
tmp = (char *)malloc(100);
*p = tmp;//可以甩出被调用函数的结果
}
void deleteBuf(char **p)
{
if (p == NULL)
{
return;
}
if (*p != NULL)
{
free(*p);
}
*p = NULL; //这一句话就不是垃圾代码了
}
void main()
{
char *p = NULL;
char **p2 = NULL;
p = 0x11; //直接修改p的值
printf("p : %x \n", p);
p2 = &p;
//*p2 = 0x99;//间接修改p的值*(p的地址)去间接修改p的值
getNewBuf(&p);
printf("p : %x \n", p);
deleteBuf(&p);
system("pause");
}
从上面可以看到,第二种方法远远优于第一种,且第二种方法更加说明了使用者对于指针的理解。
指针指向的空间释放之后,指针的值并未有改变,这个指针就成为了野指针。
1. 指针定义时初始化NULL
;
char **myarray = NULL;
2. 释放的时候需要判断是否为NULL
;
if (myarray != NULL)
{
free(myarray);
}
3. 释放完毕之后置成NULL
。
if (myarray != NULL)
{
free(myarray);
myarray = NULL;
}
如何使用二级数组做函数参数?
在解决这个问题之前,我们必须先了解这么一些知识:
1. 数组做函数参数,会退化为指针。
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
void printfArray(int a[10])
{
printf("----------printfArray----------\n");
printf("a:数组的地址:%x\n", a);
for (int i = 0; i < 10; ++i)
{
printf("%d ", a[i]);
}
printf("\n");
}
void main()
{
int a[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
printf("----------main----------\n");
printf("a:数组的地址:%x\n", a);
for (int i = 0; i < 10; ++i)
{
printf("%d ", a[i]);
}
printf("\n");
printfArray(a);
system("pause");
}
运行上面的代码,我们会发现,在函数printfArray中a的地址和我们传递的a数组的地址是一致的,函数并没有一个一个地拷贝数组的值。因此, 数组做函数参数,会退化为指针。
既然这样,我们可以总结出,下面三种输出函数参数的写法几乎没有区别
第一种:
void printArray(int *a, int size)
{
for (int i = 0; i < size; ++i)
{
printf("%d ", a[i]);
}
printf("\n");
}
第二种:
void printArray(int a[], int size)
{
for (int i = 0; i < size; ++i)
{
printf("%d ", a[i]);
}
printf("\n");
}
第三种:
void printArray(int a[10])
{
for (int i = 0; i < 10; ++i)
{
printf("%d ", a[i]);
}
printf("\n");
}
2. 指针是一种数据类型,是指它指向的内存空间的数据类型
- 指针步长(p++),根据所致内存空间的数据类型来确定
- 指针的步长,根据所指内存空间类型来定。
3. 二维数组也是线性排列的。
看下面的代码:
void printArray(int *a, int size)
{
int i = 0;
printf("printArray: %d\n", sizeof(a));
for(i = 0; i < size; i++)
{
printf("%d\n", a[i]);
}
}
int main()
{
int a[2][3] = {{1, 2, 3}, {4, 5, 6}};
printArray(p, 6);
getchar();
return 0;
}
我们可以看到,函数轻易地输出了二维数组里面的值,也证明了二维数组里的值是线性排列的。
利用sizeof可以判断出指针的步长,指针的移动正是以步长为单位。下面的代码值得细细琢磨。
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
void printArray(int *a, int size)
{//说明了二维数组里的元素线性排列
//从二维数组指针转换为一维数组指针丢失了步长信息
int i = 0;
printf("-----------printArray函数中----------\n");
printf("sizeof(&a):%d \n", sizeof(&a));
printf("sizeof(a): %d\n", sizeof(a));
printf("sizeof(*a): %d\n", sizeof(*a));
printf("a数组的地址: %d\n", a);
for (i = 0; i < size; i++)
{
printf("%d ", a[i]);
}
printf("\n");
}
//其实下面三种函数形参的写法在编译器看来都一样,不信的话可以运行程序
void printArray01(int (*a)[3], int size)
{//推荐的写法
printf("-----------printArray01函数中----------\n");
printf("sizeof(&a):%d \n", sizeof(&a));
printf("sizeof(a): %d\n", sizeof(a));
printf("sizeof(*a): %d\n", sizeof(*a));
printf("a数组的地址: %d\n", a);
//printf("*a: %d\n", *a);
//printf("*a + 1: %d\n", *a + 1);
for (int i = 0; i < size; ++i)
{
for (int j = 0; j < 3; ++j)
{
printf("%d ", (*(a + i))[j]);
//printf("%x\n", (a + i) + j);
}
}
printf("\n");
}
void printArray02(int a[][3], int size)
{/丢失了一部分的信息,3的存在标志了步长,即*a的步长为12
printf("-----------printArray02函数中----------\n");
printf("sizeof(&a):%d \n", sizeof(&a));
printf("sizeof(a): %d\n", sizeof(a));
printf("sizeof(*a): %d\n", sizeof(*a));
printf("a数组的地址: %d\n", a);
for (int i = 0; i < size; i++)
{
for (int j = 0; j < 3; ++j)
printf("%d ", a[i][j]);
}
printf("\n");
}
void printArray03(int a[2][3])
{//虽然能用,但却是最低级的用法,即使这样写,a的步长也只不过是4
//换句话说,2没起到什么作用
printf("-----------printArray03函数中----------\n");
printf("sizeof(&a):%d \n", sizeof(&a));
printf("sizeof(a): %d\n", sizeof(a));
printf("sizeof(*a): %d\n", sizeof(*a));
printf("a数组的地址: %d\n", a);
for (int i = 0; i < 2; i++)
{
for (int j = 0; j < 3; ++j)
printf("%d ", a[i][j]);
}
printf("\n");
}
int main()
{
int a[2][3] = { { 1, 2, 3 }, { 4, 5, 6 } };
char cc[10][30];
printf("-----------main函数中----------\n");
printf("sizeof(&a):%d \n", sizeof(&a));
printf("sizeof(a):%d \n", sizeof(a));
printf("sizeof(*a):%d \n", sizeof(*a));
printf("sizeof(&cc):%d \n", sizeof(&cc));
printf("sizeof(cc):%d \n", sizeof(cc));
printf("sizeof(*cc):%d \n", sizeof(*cc));
int *p = (int *)a;
printArray(p, 6); //即使是用二级指针,也可以输出正确的结果
printArray01(a, 2);
printArray02(a, 2);
printArray03(a);
getchar();
return 0;
}
结论倒是挺简单的:
1.C语言中只会以机械式的值拷贝的方式传递参数(实参把值传给形参)
原因有两个:
* 高效
* C语言处理a[n]的时候,它没有办法知道n是几,它只知道&a[0]是多少,因此把它的值作为参数传递进去了,虽然c语言可以做到直接int fun(char a[20])
,然后函数能得到20这个数字,但是,C确实没有这么做。当然,这也提高了效率。
2.二维数组参数同样存在退化的问题。
二维数组可以看做是一维数组-->二维数组中的每个元素是一维数组-->二维数组参数中第一维的参数可以省略.
void f(int a[5]);
---> void f(int a[]);
---> void f(int* a);
void g(int a[3][3]);
---> void g(int a[][3]);
---> void g(int (*a)[3]);
3. 等价关系。
数组参数 | 等效的指针参数 |
---|---|
一维数组 char a[30] |
指针 char* |
指针数组 char *a[30] |
指针的指针 char **a |
二维数组 char a[10][30] |
数组的指针 char(*a)[30] |