iOS学习之C语言数组

一、一维数组
     数组：具有相同类型的成员组成的一组数据
     1.定义
     元素：数组中存放的数据成为数组的元素
     数组是构造类型
     用{}来给构造类型赋初始值
     类型修饰符用来表示元素的类型
     类型修饰符 数组名[数组元素个数] = {值1，值2，值3....};
     第一种形式
    int ageArray[5] = {18, 22, 22, 1001, 1};
     第二种形式
     数据个数 > 设置初始值的个数，没有初始值的元素默认是0
    int ageArray1[5] = {22, 23, 29};
     第三种形式
     int ageArray2[5] = {0};
     第四种形式
     根据设置的初始值来推断元素个数
    int ageArray3[] = {22, 18, 19, 16, 23, 25, 26, 27, 38};
    [常量表达式]
   int age[1 + 2] = {0};
    int num = 3;
     [变量] 不能赋初始值
    int array[num];
     定义数组的错误形式
    内存溢出
    int heightArray[5] = {184, 183, 160, 168, 160, 190};
  2.数组的存储空间
    数组在存储时申请的是一块连续的存储空间
     数组的存储空间 = 元素个数 * 每一个元素所占的空间大小
    int array[5] = {1, 2, 3, 4, 5};
    printf("sizeArray = %lu\n", sizeof(array));
     3.数组的访问 [常量或者是变量]
     数组名[下标] 下标的范围：0~n-1,n代表数组元素个数
    int ageArray[5] = {27, 18, 22, 23, 32};
    printf("wanghai = %d\n", ageArray[4]);

printf("yanping = %d\n", ageArray[1]);
    修改
    ageArray[0] = 72;
    printf("age = %d\n", ageArray[0]);

printf("age = %d\n", ageArray[1]);
    printf("age = %d\n", ageArray[2]);

 // 使用循环访问数组中所有的元素(数组遍历，通常和for循环结合使用)
     ; i < ; i++) {
         printf("age = %d\n", ageArray[i]);
     }
     ] = {, , , , , };
     ; i < ; i++) {
         printf("weight = %.2f\n", weightArray[i]);
     }

     printf(]); // 访问越界

      //区别
      ];
      array[];

  //练习：定义一个具有 20个元素 的 整型数组，每个元素的 取值范围是30-70之间，求 数组元素的和

     ] = {};
     ;
     ; i < ; i++) {
        array[i] = arc4random() %  + ;
        sum += array[i];     

   printf("array[%d] = %d\n", i, array[i]);
     }

    printf("sum = %d\n", sum);

    //复制一个数组，即两个数组 容量一样，把其中一个数组中的元素 复制 到另外一个数组中

     ] = {, , , , };
     ] = {};
     array2 = array1;

     // 数组不能整体赋值

     ; i < ; i++) {
         array2[i] = array1[i];
         printf("array2[%d] = %d\n", i, array2[i]);
     }

  //定义 2个数组，每个数组都有 10个元素 ，元素取值范围 20-40之间，数组对应元素相加，放到另外一个数组中

     ] = {};
     ] = {};
     ] = {};
     ; i < ; i++) {
         a[i] = arc4random() %  +;
         b[i] = arc4random() %  +;
         c[i] = a[i] + b[i];

         printf(" %d, %d, c[%d] = %d\n", a[i], b[i], i, c[i]);
     }

二、 冒泡排序
    
     排序的规律：升序、降序
     基本思路：每次相邻的两个元素比较，按照升序或降序的顺序交换位置，直到所有的元素位置全部正确
     至少需要两层循环
     外层循环控制比较的趟数
     内存循环控制比较的次数
    
    int array[5] = {9, 3, 8, 1, 5};
   
     控制循环的趟数
    for (int i = 0; i < 5 - 1; i++) {
         控制每趟比较的次数
        for (int j = 0; j < 5 - i - 1; j++) {
           
             比较相邻的两个元素
            if (array[j] > array[j + 1]) {
               
                 交换两个元素的位置
                int temp = array[j];
                array[j] = array[j + 1];
                array[j + 1] = temp;           
            }       
        }
    } 
     遍历数组输出
    for (int i = 0; i < 5; i++) {
        printf("%d  ", array[i]);
    }
     对array数组降序排列
    int array[] = {12, 32, 18, 90, 43, 82};
     计算数组的元素个数
    int count = sizeof(array) / sizeof(int);
    for (int i = 0; i < count - 1; i++) {
        for (int j = 0; j < count - i - 1; j++) {
             比价相邻的元素
            if (array[j] < array[j + 1]) {
               int temp = array[j];
                array[j] = array[j + 1];
                array[j + 1] = temp;
            }
        }
    }
     遍历输出数组元素
    for (int i = 0; i < count; i++) {
        printf("%d\n", array[i]);

}

 // 练习：随机产生 10个[20,40]数 ，并对10个数 从小到大排序

     ] = {};
     // 遍历数组赋值
     ; i < ; i++) {
         array[i] = arc4random() %  + ;
         printf("%d ", array[i]);
     }

     printf("\n");

    // 冒泡排序
    ; i <  - ; i++) {
         ; j <  - i - ; j++) {
             ]) {
                 int temp = array[j];
                 array[j] = array[j + ];
                 array[j + ] = temp;
             }
         }
     }

     // 遍历数组输出
    ; i < ; i++) {
         printf("%d ", array[i]);
  }
    printf("\n");

三、 字符数组
   
        1.定义
        char array1[5] = {'h', 'e', 'l', 'l', 'o'};
         未设置的元素默认是0
        char array2[10] = {'w', 'o', 'r', 'l', 'd'};
        char array3[5] = {0};
        char array[] = {'i', 'P', 'h', 'o', 'n', 'e'};
        2.访问
        printf("%c\n", array1[0]);
        for (int i = 0; i < 5; i++) {
            printf("%c ", array1[i]);
        }
        3.字符串
        char array[] = "iPhone";
         相当于
        char array1[] = {'i', 'P', 'h', 'o', 'n', 'e', '\0'};
        printf("arraySize = %lu\n", sizeof(array));
        printf("array1Size = %lu\n", sizeof(array1));
         字符串以‘\0’结尾，字符串的本质就是字符数组
         访问字符串
         访问单个字符
        for (int i = 0; i < sizeof(array); i++) {
            printf("%c ", array[i]);
        }
         整体访问
        printf("%s\n", array1);
    
     字符数组和字符串的区别
     1.字符串就是一个字符数组
        char a[] = "iPad";
        char b[] = {'i', 'P', 'a', 'd', '\0'};
         数组a和数组b等价
     2.字符数组不一定是字符串
        char c[] = {'l', 'a', 'n', 'o', 'u'};
        char d[] = "lanou";
        c和d不等价，数组c包含5个有效字符，数组d包含6个字符,其中有5个有效字符， ‘\0’是结束标识符
    
        const int a = 10;  变量如果使用const修饰，为只读变量，不可以修改变量的值
        a = 20;
    
        字符串操作函数
        strlen():计算字符串有效字符的个数
        char array[] = "iPhone";
        unsigned long length = strlen(array);
        printf("length = %lu\n", length);
        char array1[] = "iMac";
        int length1 = (int)strlen(array1); // 类型强转
        printf("length1 = %d\n", length1);
    
        strcpy ():字符串拷贝
        strcpy(字符串1，字符串2)；
        把字符串2的内容拷贝到字符串1中
        字符串1的长度 >= 字符串2的长度
    
        char array1[] = "lanou";
        char array2[10] = {0};
        strcpy(array2, array1);
        printf("array2 = %s\n", array2);
    
    
        strcat（）：字符串拼接
        strcat(字符串1，字符串2)；
        把字符串2的内容拼接到字符串1后面，结果保存在字符串1中
        字符串1的存储空间要足够大
    
        char array1[30] = "lanou";
        char array2[] = "keji";
        strcat(array1, array2);
        printf("array1 = %s, array2 = %s\n", array1, array2);
    
    
        strcmp()字符串比较
        strcmp(字符串1, 字符串2)
        按照自左向右的顺序逐个字符比较（比较字符的ASCII值），直到遇到第一个不同的字符或者‘\0’结束。
   
        结果 > 0    字符串1 > 字符串2
        结果 < 0    字符串1 < 字符串2
        结果 = 0    字符串1 = 字符串2
        char array1[] = "lanou";
        char array2[] = "keji";
        printf("%d\n", strcmp(array1, array2));
        char array[10] = "iPhone";
        printf("%lu\n", sizeof(array));

 1  /*
      练习：将字符串 倒转：
      例如：“afjnpue”
      转变 成字符串“eupnjfa”
      （注：是改变 字符串本身，不是 反向输出）
       */

         char array[] = "afjnpue";
         int length = (int)strlen(array);
         ; i < length / ; i++) {

             int temp = array[i];
             array[i] = array[length -  - i];
             array[length -  - i] = temp;

         }
         printf("%s\n", array);

三、 宏定义
    
  无参的宏
#define 宏名称 定义的值
  宏命名： 1.k+驼峰命名法  2.字母全部大写
#define kPrint printf("3.8节快乐\n")
    kPrint;
#define COUNT 10
    int array[COUNT] = {1, 2, 3, 4, 5};
   for (int i = 0; i < COUNT; i++) {
        printf("%d\n", array[i]);
    }
    有参的宏

 #define MUL(A, B) ((A) * (B))
      //2 * 3
   , );
     printf("result = %d\n", result);

      //(3 - 1) * (4 + 2)
      - ,  + );
     printf("result1 = %d\n", result1);