众所周知，函数在传参数时会复制参数，但传指针时，只是复制了指针本身，而没有复制指针指向的值，所以可以通过传指针或引用来使函数内可以修改外部的值。那么，对于数组，会怎样？

上测试程序

#include<iostream>
#include<typeinfo>
using namespace std;

void func(int arr[]){
    arr[0]=1;
    
    cout<<"type of arr in func : "<<typeid(arr).name()<<endl;
    cout<<"address of arr in func : "<<arr<<endl;
}

int main(){
    int arr[10];
    arr[0]=0;
    
    func(arr);
    
    cout<<arr[0]<<endl;
    cout<<"type of arr outside : "<<typeid(arr).name()<<endl;
    cout<<"address of arr outside : "<<arr<<endl;
    return 0;
}

这段程序定义了一个参数为int数组并修改了这个数组索引为0处的值为1的函数，在主函数中调用了它，并打印相关的信息。

输出：

type of arr in func : Pi
address of arr in func : 0x7ffd09a12cb0
1
type of arr outside : A10_i
address of arr outside : 0x7ffd09a12cb0

按回车键返回


从输出可以看出，在主函数中，arr的类型为A10_i，即大小为10的 int 数组；而在func函数中，arr的类型为Pi，即 int 指针。这说明了，在函数传参数时，将数组转化为了对应的指针。arr的首地址都是0x7ffd09a12cb0，并且func函数中修改的arr[0]的值成功的影响到了主函数中的arr，这也说明了，函数参数传数组时并没有复制数组，而是传了数组首地址对应的指针。

目录

知识点1：多文件编程

知识点2：二级指针

知识点3：指针作为函数的参数

案例1：普通变量作为函数的参数（函数内部修改不了函数外部的值）

案例2：指针变量作为函数的形参

知识点4：数组名作为函数的参数

知识点5：字符数组名作为函数的参数

知识点7：字符串指针变量 与 字符数组的区别

知识点8：字符指针数组

知识点1：多文件编程

指针数组: 本质是数组只是每个元素的类型是指针





 

知识点2：二级指针



 

知识点3：指针作为函数的参数


	
案例1：普通变量作为函数的参数（函数内部修改不了函数外部的值）
	



	
案例2：指针变量作为函数的形参
	


 

知识点4：数组名作为函数的参数

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

void myinputarray(int *arr, int n)
{
	printf("请输入%d个int数据：", n);
	for (size_t i = 0; i < n; i++)
	{
		scanf("%d", arr + i);
	}
}

void mymaxint(int *arr, int n, int *p_max)
{
	int tmp_max = 0;
	for (size_t i = 0; i < n; i++)
	{
		if (tmp_max < arr[i])
		{
			tmp_max = arr[i];
		}
	}
	*p_max = tmp_max;
}

void myprintintarray(int *arr, int n)
{
	printf("数组总大小：%d\n", sizeof(arr));
	for (size_t i = 0; i < n; i++)
	{
		printf("%d ", arr[i]);
	}
	printf("\n");
}


void test()
{
	int arr[5] = { 0 };
	int n = sizeof(arr) / sizeof(arr[0]);

	//定义函数：给arr元素获取键盘输入
	myinputarray(arr, n);

	int max = 0;
	//定义函数：求最大值
	mymaxint(arr, n, &max);
	printf("max=%d\n", max);

	//遍历
	myprintintarray(arr, n);
}

int main(int argc, char *argv[])
{
	test();
	system("pause");
	return 0;
}

 

知识点5：字符数组名作为函数的参数

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

void myinputchararray(char *arr, int n)
{
	printf("请输入一个字符串，长度小于%d\n", n);
	fgets(arr, n, stdin);
}

int mystrlen(char *arr)
{
	int count = 0;
	while (arr[count] != '\0')
	{
		count++;
	}
	return count;
}

void mychange(char *arr)
{
	int i = 0;
	while (arr[i] != '\0')
	{
		if (arr[i]>='a' && arr[i]<='z')
		{
			arr[i] -= 'a' - 'A';
		}
		else if (arr[i] >= 'A' && arr[i] <= 'Z')
		{
			arr[i] += 'a' - 'A';
		}
		i++;
	}
}




void test()
{
	char buf[32] = "";
	//给buf获取键盘输入
	myinputchararray(buf, sizeof(buf));
	buf[strlen(buf) - 1] = 0;
	printf("buf = %s\n", buf);

	//获取字符串的实际长度（遇到\0结束）
	int len = 0;
	len = mystrlen(buf);
	printf("len=%d\n", len);

	//将buf大写字符变小写，小写字符变大写
	mychange(buf);
	printf("buf=%s\n", buf);
}


int main(int argc, char *argv[])
{
	test();
	system("pause");
	return 0;
}

 

知识点7：字符串指针变量 与 字符数组的区别





 

知识点8：字符指针数组





 

 

 

 

 


C语言中可以求任意一个int型数组的长度吗？ 近来在写程序的时候遇到了一个问题，就是传递一个数组指针进入一个函数的时候，虽然指针能够顺利的传递，但是，我们无法求出该数组的大小。见下面的代码：
#include <stdio.h>
void setNum(int *p,int a);
void setNum(int *p);

int main()
{
    int a[] = {1,2,4,5};
    printf("%d\n",sizeof(a)/sizeof(a[0]));
    setNum(a);
}

void setNum(int *p,int a)
{
    *p = a;
}

void setNum(int *p)
{

    int Num = sizeof(p)/sizeof(p[0]);
    printf("%d\n",Num);
}
结果是，输出分别是4和1.


原因分析：

1.对于第一个输出，由于在main函数中定义的为数组，所以可以直接利用sizeof函数来求出a数组的长度。

2.对于传递参数类型，比如上面的setNum函数（未传递个数版本），此时，调用该函数的时候，a退化为一个普通的指针，也就是说，此时sizeof(p)求出来的就是一个指针的大小，除以int的大小，恰好为1.


启示：

C语言中，不能够根据一个数组指针就求出来任意一个数组的大小。解决办法就是传第一个参数进来，指定大小。


ps：参考资料（详实）：http://topic.csdn.net/t/20060205/18/4540750.html


摘录：
>   如果作为函数的参数是没法求的, 

>   但这样是可以的: 

>   

>   #define   LENGTH(s)   (sizeof(s)   /   sizeof(int)) 

>   

>   int   s[12]; 

>   int   length   =   LENGTH(s); 

================================================== 

这样的方法只能用于数组变量的数组名，对于指向数组的指针，以及作为参数的数组名都是没有效果的，上面已经有人解释了 

》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》
不可能有办法的。 

当你定义一个数组的时候： 

int   a[]   =   {1,   2,   3};     //   实际上被编译为   int   a[3]   =   {1，2，3} 


数组名代表的是数组的地址。注意   ——   你绝对没有办法通过数组名动态获得数组的大小。当你丢失a的长度信息的时候，你永远不可能知道他的长度。 


那么   sizeof   是怎么回事呢？他不是通过   a   的名字获得   a的大小了么？   ——   大错特错！ 


关键字   sizeof   产生的是一个编译期常量（注1）   他的运作方式是这样的： 


当你写： 

sizeof   a   

实质是: 

sizeof   (   a的类型   ) 


而a的类型是什么呢？编译器察看   a的定义发现，   是   int   [3] 

就是说，这里   sizeof   a   实质是： 

sizeof   (   int[3]   ) 

完全等同于常量   12   （假定int为4字节）。 



考虑一个函数 

void   func(   int   a[]   );     

//   写成   int   a[3]   也不会有本质区别——也许你该试试写成   int   (&a)   [3]   ？ 


C++规定，数组作为形参的时候，a代表数组首地址。 

他的底层意义是：   a   退化为了一个4字节的指针，没有任何变量表示数组的大小会“自动”被传递进来。 


我们看看这个时候   sizeof   a是什么： 

sizeof(   函数形参的a[]   )     =   sizeof(   int*   const   )   =   4     //   当然a[]不是合法的C++类型 



仍然不服气？好——我们反问一个问题：若你是C   /C++的设计者，   你怎么在兼容原有设计的基础上让void   func(   int   a[]   )同时传递地址和大小？ 


首先，a是一个变量，而且类似数组。他必须是一个地址，否则你不知道如何索引元素。 

他怎么再带上一个变量表示他的大小呢？ 


扩充   sizeof   (a)   的能力？ 


sizeof   a   必须产生代码——不管是常量还是什么。   要让他在运行时决定   a的值，   a就必须带上他的大小信息。   


1   你必须修改C标准，让C支持“两种”数组。一种是定义处的数组，他分配大片连续内存，和原来的C标准相同。 


2   另一种是作为参数传递数组。   你必须传递地址和数组大小；这个数组实际上是一个8字节的结构{   地址;   大小}（事实上可能更加复杂，考虑多纬数组如何实现？   ）   


3   系统必须根据两种不同数组分别实现其   []、*   、&等。   原有的数组根据其首地址偏移（这是个常量）和下标寻址；   而参数数组则首先取“地址”内容（这是个变量），然后根据这个地址寻址.... 


厄...   再考虑多维数组——听起来这不是一整套vector模型么？ 


----------------------------------------------- 

注1:   对于C99支持的   flexible   array   ，其   sizeof   运算是运行时求值

声明函数时的格式：
functin 返回值类型 函数名 ([ref]类型 参数名[],...)library '函数库说明'
调用前：
类型 数组名[]//必须定义成可变长度数组
.....数组赋值.....
//调用
函数名(数组名,....)//也可以用“函数名(数组名[],....)”