个人主页~

C语言零基础纯干货教学（上）

C语言零基础纯干货教学（中）

C语言入门

• 四、数组
• • 1、概念
  • 2、一维数组
  • • （1）一维数组创建
    • （2）数组的初始化
    • 3、一维数组的使用
    • • （1）访问下标
      • （2）数组输入和打印
      • 4、一维数组在内存中的存储
      • 5、sizeof计算数组元素个数
      • 6、二维数组
      • • （1）概念
        • （2）二维数组的创建
        • 7、二维数组的初始化
        • 8、二维数组的使用
        • • （1）下标访问
          • （2）二维数组的输入输出
          • 9、二维数组在内存中的存储
          • 五、函数
          • • 1、函数的概念
            • 2、库函数
            • 3、自定义函数
            • • （1）概念
              • （2）例子
              • 4、形参和实参
              • 5、return语句
              • 6、数组做函数参数
              • 7、函数的声明和定义
              • • （1）单文件
                • （2）多文件
                • （3）extern和static
                • 六、函数递归
                • • 1、概念
                  • 2、例子
                  • • （1）n的阶乘
                    • （2）斐波那契数列

                      四、数组

                      1、概念

                      数组是一组相同类型元素的集合，分为一维数组和多维数组，其中多维数组中二维数组用的最多，至于三维数组及其以后的多维数组在生产生活中用的是比较少的

                      2、一维数组

                      （1）一维数组创建

                      type name[n];
                      

                      type是指数据类型，这里是你希望你创建的数组当中所有元素的数据类型

                      name是数组的名字

                      n是指数组的元素个数，是个常量，用方括号括起来

                      数组的类型是type[n]

                      （2）数组的初始化

                      C语言的初始化一般使用大括号，分为完全初始化以及不完全初始化

                      //完全初始化，此时数组元素的值就对应着这几个数字
                      int arr[5] = {1,2,3,4,5};
                      //不完全初始化，此时除了被初始化有值的元素外，其他的元素都是0
                      char ch[3] = {1};
                      //错误初始化，此时初始化的项数超过了数组的最大规格
                      double do[2] = {1,2,3};
                      

                      3、一维数组的使用

                      （1）访问下标

                      一维数组通过下标访问来使用，数组的第一个元素的下标为0，最后一个元素的下标为n-1

                      （2）数组输入和打印

                      通过循环来进行输入和输出

                      #include 
                      int main()
                      {
                      	int arr[10] = { 0 };
                      	for (int i = 0; i < 10; i++)
                      	{
                      		arr[i] = i + 1;
                      	}
                      	for (int i = 0; i < 10; i++)
                      	{
                      		printf("%d ", arr[i]);
                      	}
                      	return 0;
                      }
                      

                      

                      4、一维数组在内存中的存储

                      数组在内存中是连续存放的，比如一个int[5]类型的数组，开辟一块内存，数组元素紧紧相连，找到头就可以找到整个数组

                      

                      5、sizeof计算数组元素个数

                      sizeof(arr);
                      //可以求出整个数组的大小
                      sizeof(arr[0]);
                      //可以求出数组每个元素的大小
                      sizeof(arr)/sizeof(arr[0]);
                      //可以求出数组的元素个数
                      

                      6、二维数组

                      （1）概念

                      将一维数组作为元素的数组叫做二维数组

                      

                      （2）二维数组的创建

                      type name[m][n];
                      

                      type是每个一维数组元素的数据类型

                      name是数组名

                      m表示数组有m行

                      n表示数组每一行有n个元素

                      7、二维数组的初始化

                      跟一维数组一样，没有被初始化的数据为0

                      int arr1[3][5] = {1,2};
                      //不完全初始化，除了被初始化的0行0个以及0行1个其他的数据都为0
                      short arr2[2][4] = {1,2,3,4,5,6,7,8};
                      //完全初始化
                      char arr3[3][4] = {{1,2},{3,4},{5,6}};
                      //按照行初始化，此时第0行1行2行第2个3个数据都为0
                      

                      在初始化时可以省略行，但不能省略列

                      int arr1[][5] = {1,2};
                      

                      8、二维数组的使用

                      （1）下标访问

                      与一维数组一样，二维数组是从0行0列开始的

                      （2）二维数组的输入输出

                      int main()
                      {
                      	int arr[7][6] = {0};
                      	for (int i = 0; i < 7; i++)
                      	{
                      		for(int j = 0;j < 6;j++)
                      		    arr[i][j] = i + 1;
                      	}
                      	for (int i = 0; i < 7; i++)
                      	{
                      		for (int j = 0; j < 6; j++)
                      			printf("%d ",arr[i][j]);
                      		printf("\n");
                      	}
                      	return 0;
                      }
                      

                      

                      9、二维数组在内存中的存储

                      我在上边给了一张图：

                      

                      其实这个是不能表示二维数组在内存中的存储的，其实在第一行的最后一个数据与第二行的第一个数据是相邻存放的，我们在定义中提到过，二维数组的元素是一维数组，元素与元素之间是紧挨着的，所以每个一维数组之间也是紧挨着的，最终应该是一条直线而不是像上图一个的6*7的方格

                      五、函数

                      1、函数的概念

                      C语言中的函数就是一个完成某项特定的任务的一小段代码，函数作用很大，C语言程序一般都是由多个函数组成的，因为函数可以复用，大大提高了程序员的效率

                      2、库函数

                      C语言并不提供库函数，但编译器的厂商根据国际标准给出了一系列函数的实现，这些函数称为库函数，每个库函数都对应着一个头文件，使用这个库函数必须包含头文件

                      3、自定义函数

                      （1）概念

                      type name(a)
                      {
                          b;
                      }
                      

                      type是函数的返回类型，这些类型有：int，char，short，float，void（无类型，如果不想返回值，就使用void）等

                      name是函数名

                      a是形式参数

                      b就是函数体

                      （2）例子

                      加法函数

                      int Add(int x, int y)
                      {
                      	return x + y;
                      }
                      int main()
                      {
                      	int a = 1;
                      	int b = 2;
                      	int c = Add(a,b);
                      	printf("%d", c);
                      	return 0;
                      }
                      

                      

                      4、形参和实参

                      在上述例子代码中，a和b叫做实参，表示实际的参数，x和y叫形参，表示形式上的参数

                      形参是实参的一份临时拷贝，在传参的过程中，实参拷贝一份形成形参，由形参负责在函数中运算，在函数结束时，形参所占用的空间会被回收，形参消失

                      5、return语句

                      当return语句执行后，程序将彻底返回，后面所有的代码都不再执行

                      return后要有一个同type的值，如果不一样，就会强制转换成函数的type值

                      当type为void的时候，直接return就可以了

                      return后可以是一个数字，也可以是一个表达式，当是表达式时，先执行表达式再return表达式的值

                      6、数组做函数参数

                      当数组做函数参数时我们需要将整个数组传到函数当中，所以我们在参数中直接写入数组的名字，表示传参整个数组

                      这里有一条暗含的知识，直接写数组的名表示的是整个数组的地址，因为数组名就是地址，相当于将整个数组的地址取了出来，拷贝到形参当中，然后才在函数中进行函数活动

                      7、函数的声明和定义

                      （1）单文件

                      

                      函数的定义：

                      int Add(int x, int y)
                      {
                      	return x + y;
                      }
                      

                      函数的调用

                      int c = Add(a, b);
                      

                      函数定义是一种特殊的声明，当函数体定义在使用之前时，相当于声明，但如果函数体定义在使用的下边，需要提前声明，否则编译器会认为使用的函数不存在

                      int Add(int x, int y);
                      //函数的声明
                      int main()
                      {
                      	int a = 1;
                      	int b = 2;
                      	int c = Add(a, b);
                      	printf("%d", c);
                      	return 0;
                      }
                      int Add(int x, int y)
                      {
                      	return x + y;
                      }
                      

                      （2）多文件

                      

                      新建头文件Add.h存放函数的声明，Add.c存放函数体，test.c使用函数

                      Add.c

                      

                      Add.h

                      

                      test.c

                      

                      （3）extern和static

                      static可以用来修饰局部变量、全局变量以及函数

                      extern用来声明外部符号

                      ①static修饰局部变量可以改变变量的生命周期，也就是改变了该变量存储的类型，我们知道内存中有多个区，原本该变量应该是存储在栈区，在栈区中的局部变量在该函数结束后就会被销毁，但被static修饰后会存储到静态区，生命周期就会与程序的生命周期相同，只有程序结束，变量才会销毁，可以理解成用static修饰的变量就会变成全局变量，不过它并不是全局变量，全局变量也存储在静态区

                      ②static修饰全局变量会使该变量只能在本文件被使用，即使外部文件声明了也无法使用，也就是说static将全局变量的与外界相通的能力给掐断了，函数同上

                      ③extern用来声明外部符号，如果在其他文件定义的符号我们想要在本文件使用，那么就可以用extern进行声明后使用

                      六、函数递归

                      1、概念

                      递归通俗来讲就是在函数中调用该函数，也就是自己调用自己

                      2、例子

                      （1）n的阶乘

                      #include 
                      int Func(int n)
                      {
                      	if (n == 0)
                      		return 1;
                      	else
                      		return n * Func(n - 1);
                      }
                      int main()
                      {
                      	int n = 0;
                      	scanf("%d", &n);
                      	int ret = Func(n);
                      	printf("%d\n", ret);
                      	return 0;
                      }
                      

                      

                      函数的递归分为两个步骤，第一步为递推，第二步为回归

                      

                      （2）斐波那契数列

                      int count = 0;
                      int Fib(int n)
                      {
                      	if (n <= 2)
                      		return 1;
                      	else
                      		return Fib(n - 1) + Fib(n - 2);
                      }
                      int main()
                      {
                      	int n = 0;
                      	scanf("%d", &n);
                      	int ret = Fib(n);
                      	printf("%d\n", ret);
                      	return 0;
                      }
                      

                      

                      ---

                      C语言的基础内容就到这里了~