C语言函数和数组

一.数组

一.一维数组：

1.一维数组的创建:

2.一维数组的初始化：

3.一维数组的使用

4.一维数组在内存中的存储：

二.二维数组：

三.数组越界：

四.数组作为函数参数：

二.函数

一.函数是什么：

二.库函数：

三.自定义函数：

四.函数参数：

五.函数的嵌套调用和链式访问：

六.函数的声明和定义：

七.函数递归：

一.数组

一.一维数组：

1.一维数组的创建:

数组是一组相同类型元素的集合

数组的创建方式：

type_t arr_name [const_n];

//type_t 是指数组的元素类型

//const_n 是一个常量表达式，用来指定数组的大小

数组创建的实例：

int arr[10];

int cont=10;

int arr2[count]; //这样数组可以正常创建吗

char arr3[10];

float arr4[1];

double arr5[20];

数组创建，在C99标准之前，[]中要给一个常量才可以，不能使用变量，在C99标准支持了变长数组的概念，数组的大小可以使用变量指定，但是数组不能初始化

2.一维数组的初始化：

数组初始化是指在创建数组的同时给数组的内容一些合理初始值(初始化)。

int arr[10]={1,2,3};

int arr2[]={1,2,3,4};

int arr3[5]={1,2,3,4,5};

char arr4[3]=['a',98,'c'};

char arr5[]={'a','b','c'};

char arr6[]="abcdef"'

数组在创建的时候如果不想指定数组的却低的大小就得初始化，数组的元素个数根据初始化内容来确定

但是对于下面的代码要区分，内存中如何分配。

char arr1[]="abc";

char arr2[3]={'a','b','c'};

3.一维数组的使用

#include<stdio.h>
int main()
{int arr[10]={0};//数组的不完全初始化//计算数组的元素个数int sz=sizeof(arr)/sizeof(arr[0]);//对数组内容赋值，数组是使用下标来访问的，下标从0开始，所以：int i=0;for(i=0;i<10;i++){arr[i]=i;}for(i=0;i<10;++i){printf("%d ",arr[i]);}
}

数组是使用下标来访问的，下标是从0开始。

数组的大小可以通过计算得到。

4.一维数组在内存中的存储：

#include<stdio.h>
int main()
{int arr[10]={0};int i=0;int sz=sizeof(arr)/sizeof(arr[0]);for(i=0;i<sz;++i){printf("&arr[%d]=%p\n",i,&arr[i]);}
}

这里的地址随着下标的增长而以类型的大小增长可以得出：数组在内存中是连续存放的。

二.二维数组：

二维数组的创建：

int arr[3][4];

char arr[3][5];

double arr[2][4];

二维数组的初始化：

int arr[3][4]={1,2,3,4};

int arr[3][4]={{1,2},{4,5}};

int arr[][4]={{2,3},{4,5}};二维数组初始化时，行可以省略，列不能省略

二维数组也是通过下标使用的：

这里是创建了一个3行每行有4个元素的数组并使用i代表行j代表列依次给arr的每个空间赋值并打印出来。

arr[3][4]：

arr[0][0]=0     arr[0][1]=1 arr[0][2]=2       arr[0][3]=3

arr[1][0]=4 arr[1][1]=5 arr[1][2]=6       arr[1][3]=7

arr[2][0]=8 arr[2][1]=9 arr[2][2]=10     arr[2][3]=11

三.数组越界：

数组的下标是有范围限制的，

数组的下标规定是从0开始的，如果有n个元素最后一个下标就是n-1.

所以数组的下标如果小于0，或者大于n-1，就是越界访问了，超出了数组合法空间的访问，

C语言本身是不会对数组下标越界检查的，编译器也不一定报错，但是编译器不报错，并不意味着程序就是对的，所以写代码的时候要自己做检查，二维数组的行和列也可能存在越界。

arr[10]只有arr[0]到arr[9]并没有，这里打印出-858993460这片空间并没有值所以打印出来的是这个未知数，

四.数组作为函数参数：

数组名是数组首元素地址，有两个例外：

{

sizeof（数组名），计算整个数组的大小sizeof内部单独放一个数组名，数组名表示整个数组。

&数组名，取出的是数组的地址，&数组名，数组名表示整个数组。

}

除此两种之外所有的数组名都表示数组首元素地址。

知道啦上面的就可以做一个冒泡排序了：
同得出的大小在把arr的首地址传和arr的大小传给bubble_sort函数在函数内部就可以通过地址找到arr数组并对其进行排序，排序是是每个元素对他后面的每一个元素进行比如果比其大则两个元素交换位置，一直遍历完整个数组。

二.函数

一.函数是什么：

维基百科中对函数定义是：子程序

在计算机中，子程序(英语：Subroutine,procedure,funcion,routinemethod,subprogram,callable unit),是一个大型程序中的部分代码，由一个或多个语句块组成，他负责完成某项特定的任务，而且相较于其他代码，具备相对的独立性。

一般会有输入参数并有返回值，提供对过程的封装和细节的隐藏，这些代码通常被集成为软件库。

二.库函数：

我们在学习C语言的时候，总是在一个代码编写完成之后迫不及待的想知道结果，想把这个结果打印到我们的屏幕上看看，这个时候我们会频繁使用一个功能：将信息按照一定的格式打印到屏幕上（printf）。

在编程的过程中我们会频繁的做一些字符的拷贝工作（strcpy）。

在编程中我们也计算，总是会计算，n的k次方这样的运算（pow）。

像上面我们描述的基础功能，他们不是业务性的代码，我们在开发的过程中每个程序都可能

用到，为了支持可移植性和提高程序的效率，所以C语言的基础库中提供了一系列类似的库函数，方便程序员进行软件开饭

这里我们简单看看：www.cplusplus.com

使用库函数必须包含#include对应的头文件，

学会查询工具的使用：

www.cplusplus.com

http://en.cppreference.com（英文版）

http://zh.cppreference.com（中文版）

三.自定义函数：

因为库函数不能干所有的事。所以有自定义函数，自定义函数和库函数一样，有函数名，返回值类型和函数参数，但是这些都是我们自己来设计的。

函数的组成：

ret_type fun_name(paral, *)

{

statement;//语句项

}

ret_tupe 返回类型

fun_name 函数名

paral 函数参数

比如可一写一个能找出两个整数的最大值的函数

#include<stdio.h>
int get_max(int x,int y)
{
return (x>y)?(x):(y);
}
int main()
{
int num1=10;
int num2=20;
int max=get_max(num1,num2);
printf("max=%d\n",max);
}

还可一写一个交换两个整型变量的函数:第Swap1不能实现，swap2却可以，这是因为Swap1接收到的是形参，而swap2是接受到的是实参

#include<stdio.h>
void Swap1(int x, int y)
{int tmp = 0;tmp = x;x = y;y = tmp;
}
void swap2(int* px, int* py)
{int tmp = 0;tmp = *px;*px = *py;*py = tmp;
}
int main()
{int num1 = 1;int num2 = 2;Swap1(num1, num2);printf("Swap1::num1=%d,num2=%d\n", num1, num2);swap2(&num1, &num2);printf("Swap2::num1=%d,num2=%d\n", num1, num2);
}

四.函数参数：

传值调用：

函数的形参和实参分别占有不同内存块，对形参的修改不会影响实参。

传址调用：

传值调用是把函数外部创建变量的内存地址传给函数参数的一种调用函数的方式。

这种传参方式可以让函数和函数外边的变量建立起真正的联系，也就是函数内部可以直接操作函数外部的变量。

实际参数（实参）：

真实传给函数的参数，叫实参。

实参可以是：常量，变量，表达式，函数等。

无论实参是何种类型的量，在进行函数调用时，他们都必须有确定的值，以便把这些值传给形参。

形式参数（形参）：

形式参数是指函数名后括号中的变量，因为形式参数只有在函数被调用的过程中才实例化（分配内存单元），所以叫形式参数，形式参数当函数调用完之后就自动销毁了，因此形式参数只在函数中用效。

这里的Swap1没有改变num1和num2的值是因为他们拿到的是num1和num2的值而已交换值的时候是交换x，y空间里的值，对num1，num2空间里的值并没有影响。

swap2改变了num1和num2的值是因为px，py拿到的值是num1，num2的地址改变*px或*py的值等于改变num1，num2的值因为他们可以通过地址找到num1，num2的空间所以*px，*py等于num1，num2，px，py是改变他们自己空间里的值。

五.函数的嵌套调用和链式访问：

函数和函数之间可以根据实际需求进行组合的，也就是相互调用的，称为嵌套调用，

函数可以嵌套调用不能嵌套定义。

这里的void是没有返回值，可以接收参数。

#include<stdio.h>
void new_lien()
{printf("hehe\n");
}
void three_lien()
{int i = 0;for (i = 0; i < 3; i++){new_lien();}
}
int main()
{three_lien();return 0;
}

把一个函数的返回值作为另一个函数的参数，这样叫做链式访问。

strlen是用来计算字符串的长度的，strcat是把bit这个字符追加到arr这给数组里的。

所以计算出来的答案是8

#include<stdio.h>
#include<string.h>
int main()
{char arr[20]="hello";int ret=strlen(strcat(arr,"bit"));printf("%d\n",ret);return 0;
}

六.函数的声明和定义：

函数声明：

告诉编译器有这个函数他叫什么，参数是什么，返回类型是什么，但是存不存在，函数声明绝地不了。

函数声明一般出现在函数使用前，要满足先声明后使用，因为函数声明放在函数后面就没用意义了。

函数声明一般放在头文件中的。

函数定义：

函数定义是指函数具体实现。

int Add(int x,int y);//函数声明

int Add(int x,int y)//函数实现

{
return x+y;

}

七.函数递归：

程序调用自身的编程技巧称为递归（recursion）。

递归做为一种算法在程序设计语言中广泛应用。一个过程或函数在其定义或说明中有直接或间接调用自身的一种方法，它通常把一个大型复杂的问题层层转化为一个与原问题相识的规模较小的问题来求解，递归策略只需要少量的程序就可以描述出解题过程所需要的多次重复计算，大大地减少了程序的代码量。

递归必须要这两个条件：

存在限制条件，当满足这个条件的时候，递归便不再继续。

每次递归调用之后越来越接近这个限制条件。

比如按顺序打印每一位:

输入1234，输出1 2 3 4，

#include<stdio.h>
void print(int n)
{if (n > 9){print(n/10);}printf("%d ", n % 10);
}
int main()
{int num = 1234;print(num);return 0;
}

编写函数不允许创建临时变量，求出字符串的长度。

#include<stdio.h>
int Strlen(const char* str)
{if (*str == '\0')return 0;elsereturn  1+Strlen(str + 1);
}
int main()
{char* p = "abcdef";int len = Strlen(p);printf("%d\n", len);
}

n的阶乘（不考虑益出）

int factorial(int n)
{if(n<=1)return 1;elsereturn n*factorial(n-1);
}

在调试fib函数的时候，如果参数比较大，那就会报错：stack overflow（栈溢出）这样的信息。

int count=0;
int fib(int n)
{if(n=3)count++;if(n<=2)return 1;elsereturn fib(n-1)+fib(n-2);
}

系统分配给程序的空间是有限的，但是出现了死循环，或者（死递归），这样有可能导致一直开辟栈空间，最终产生空间耗尽的情况，这样的想象我们称为栈溢出。

将递归改成非递归就行了。

使用static对象代替nonstatic局部变量，在递归函数设计中，可以使用static对象代替nonstatic局部对象（即栈对象），这不仅可以减少每次递归调用和返回是产生的释放nonstatic对象的开销，而且static对象还可以保存递归调用时的中间状态，并且可为各个调用层所访问。

比如下面就拆用了，非递归的方式来实现

许多问题是以非递归的形式进行解释的，这只是因为它比非递归的形式更为清新。

但是这些问题的迭代实现往往比递归实现效率更高，虽然代码的可读性稍差些。

当一个问题相当复杂，难以用迭代实现时，此时递归实现的简洁便可以补偿它所带来的运行时开销。

//求n的阶乘
int factorial(int n)
{int resule = 1;while (n > 1){resule *= n;n -= 1;}return resule;
}
//求第n个斐波那契数
int fib(int n)
{int result;int pre_result;int next_older_result;result = pre_result = 1;while (n > 2){n -= 1;next_older_result = pre_result;pre_result = result;result = pre_result + next_older_result;}return result;
}