【C语言笔记】<十一>数组

数组的基本概念

元素类型 数组名称[元素个数];
元素类型: 就是数组中需要存储的数据类型, 一旦指定, 数组中就只能存储该类型的数据
元素个数: 就是数组中能够存储的数据(元素)的个数

数组初始化

// 依次将{}中的每一个值赋值给数组中的每一个元素
    // 并且从0开始赋值
    // 也称之为数组的初始化(完全初始化)
    int scores[5] = {99,88,77,66,100};

数组遍历

int main(int argc, const char * argv[]) {
    // 取出数组中所有的值, 称之为遍历
    int scores[6] = {1, 23, 44, 66, 71, 88, 99 , 2};
    /*
    printf("scores[0] = %i\n", scores[0]);
    printf("scores[1] = %i\n", scores[1]);
    printf("scores[2] = %i\n", scores[2]);
    printf("scores[3] = %i\n", scores[3]);
    printf("scores[4] = %i\n", scores[4]);
    printf("scores[5] = %i\n", scores[5]);
     */
    
    // 注意: 在遍历数组的时候, 尽量不要把遍历的次数写死
    // 遍历多少次应该由数组来决定, 也就是说遍历多少次应该通过数组计算得出
    /*
    printf("scores = %lu\n", sizeof(scores)); // 计算出数组占用的总字节数
    printf("scores[0] = %lu\n", sizeof(scores[0])); // 计算出数组中某一个元素占用的字节数
    printf("一个有多少个元素 : %lu\n", sizeof(scores) / sizeof(scores[0]));
    */
    // 动态计算数组的元素个数
    int length = sizeof(scores) / sizeof(scores[0]);
    
    for (int i = 0; i < length; i++) {
        printf("scores[%i] = %i\n", i,scores[I]);
    }
    return 0;
}

数组的内存存储细节

int main(int argc, const char * argv[]) {
    // 变量在内存中的存储
    // 由于变量的内存寻址是从大到小, 所以存储数据时会从高字节开始存储
    int num = 10; // 0000 0000 0000 0000 0000 0000 0000 1010
    
    // 注意: 数组的存储和变量有点不一样, 数组存储元素, 是从所占用的低字节开始存储
    char charValues[4] = {'l', 'u', 'c', 'k'};
    /*
     charValues[0] = 0x7fff5fbff7c8
     charValues[1] = 0x7fff5fbff7c9
     charValues[2] = 0x7fff5fbff7ca
     charValues[3] = 0x7fff5fbff7cb
     */
    printf("charValues[0] = %p\n", &charValues[0]);
    printf("charValues[1] = %p\n", &charValues[1]);
    printf("charValues[2] = %p\n", &charValues[2]);
    printf("charValues[3] = %p\n", &charValues[3]);
    
    // &charValues == &charValues[0] == charValues
    printf("&charValues = %p\n", &charValues);
    // 其实数组名就是数组的地址
    printf("charValues = %p\n", charValues);
    
//    00000000 00000000 00000000 00000101
//    00000000 00000000 00000000 00000110
    int nums[2] = {5, 6};
    
    return 0;
}

注意点

int main(int argc, const char * argv[]) {
    char nums[2] = {1, 5};
//    0 , 1 , 2
    char values[3] = {7, 8, 9};
    
    // 注意点: 在使用数组的时候, 一定不要访问不属于字节的存储空间, 这样会导致数据混乱
    // 有时候如果访问了不属于自己的存储空间, 程序会报错
//    values[3] = 44;
//    printf("values[3] = %i\n", values[3]);
//    printf("nums[0] = %i\n", nums[0]);
    
    nums[-1] = 88;
    printf("values[2] = %i\n", values[2]);
    return 0;
}

函数和数组

/ 基本数据类型作为函数的参数是值传递
// 如果形参是基本数据类型, 在函数中修改形参的值不会影响到实参的值
void change(int value)
{
    value = 55;
}

// 注意: 数组名作为函数的参数传递, 是传递的数组的地址
// 因为数组名就是数组的地址 &number = &number[0] == number
// 注意: 如果数组作为函数的形参, 元素的个数可以省略
// 如果形参是数组, 那么在函数中修改形参的值, 会影响到实参的值
//void change2(int values[2])
void change2(int values[])
{
//    values[0] = 88;
    values[1] = 99;
}
int main(int argc, const char * argv[]) {
    /*
    int num = 10;
    change(num);
    printf("num = %i\n", num);
     */
    
    int nums[2] = {1, 5};
    /*
    change2(nums); // 相当于传递了数组的地址
    printf("nums[1] = %i\n", nums[1]);
     */
    change(nums[0]);
    printf("nums[0] = %i\n", nums[0]);
    return 0;
}

数组和函数

#include <stdio.h>
//void printArray(int values[5]);
void printArray(int values[5], int length);

int main(int argc, const char * argv[]) {
    // 要求定义一个函数, 实现遍历数组. (只要别人传递数组给函数, 就要求输出数组中所有元素的值)
    int nums[3] = {1 , 3 , 5};
//    printf("size = %i\n", sizeof(nums));
    
    int length = sizeof(nums) / sizeof(nums[0]);
    
    printArray(nums, length); // 数组名称就是数组的地址
    return 0;
}

// 如果传递的数组的名称, 其实传递的是地址
// 如果传递的是地址, 其实传递的是指针
// 指针在64位编译环境占8个字节

// 注意: 如果数组作为形参, 那么在函数中就不能通过数组的名称计算出数组元素的个数
// 因为系统会自动将数组形参转换为指针, 指针占用8个字节
void printArray(int values[5], int length)
{
//    printf("size = %i\n", sizeof(values));
    
    // 1.动态计算数组的元素个数
//    int length = sizeof(values) / sizeof(values[0]);
    // 2.遍历数组
    for (int i = 0; i < length; i++) {
        printf("values[%i] = %i\n", i,values[i]);
    }
}