C语言---数组_c语言数组是一组共用同一-CSDN博客

int a; 
// 变量本身的类型 变量名; 
// 数组本身的类型 数组名; 
// 数组本身的类型 ==> 数组元素的类型 [数组的长度] 
// 数组元素的类型 数组名 [数组的长度]; 
int Card[10]; 
// 定义了一个数组,取名叫做Card 
// 数组元素的类型:int 数组长度:10 
// 数组本身的类型:int [10] 
// 数组元素的类型 数组名 [数组的长度];

类型

数组元素的类型: 存储的数据类型

数组本身的类型: 数组元素的类型 [数组的长度]

数组名：合法标识符

大小

又叫数组长度

数组里面能够存储的元素的个数

在定义数组的时候: 整型常量

内存

数组整体所占的字节数 = 单个元素所占的字节数 * 元素的个数

数组的内存是连续的
数组的长度是有限的
数组元素的类型是相同的

数组的长度可以使用sizeof()求求出来的是字节数

注意：

数组的长度在定义之后就确定了,不能再更改

size_t相当于unsigned int

当一段内存没有被利用的时候，就会在上面交替的存上1、0、1、0…….

初始化

// 1 给全部元素初始值 
// 数组元素的类型 数组名 [数组长度] = {值1,值2,....值n}; 
// 注意:值的个数不能超过数组长度 
int arr1[10] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }; 

// 2 给部分元素初始值 
// 数组元素的类型 数组名 [数组长度] = {值1,值2,....值n}; 
int arr2[10] = { 0, 1, 2, 3, 4, 5, 6, 7 }; 

// 3 不给值 
// 数组元素的类型 数组名 [数组长度] = {}; 
int arr3[10] = {}; 
// 有={}就叫做初始化了,没有那就是没有初始化. 

// 4 不指定数组长度 
// int arr[]; // 不能够在不给初始值的情况下省略数组长度 
// int arr[] = {}; // 光有={}不行,必须要有初始值 
int arr4[] = { 1, 2, 3, 4, 5 }; 

// 注意: 1 实际上给了几个初始值那就表示数组长度是多少 
// 2 长度可以省略,但是[]不能省略 
// 3 定义时给了多少个初始值,数组长度就确定是多少

赋值

int arr[10]; 
// arr = { 1, 2, 3, 4, 5 }; 
// ==> 数组名是一个常量 
// arr[10] = { 1, 2, 3, 4, 5 };
赋值,实际上是给数组元素赋值 
应该先访问到单个的元素,再给元素赋值

数组元素的访问

// 数组名[下标] 
下标:编号 从0开始到数组长度-1 
1 单个元素的访问 
2 使用循环访问
int arr[10] = { 10, 20, 30, 4, 5, 6, 7, 8, 9, 10 }; 
printf("arr[0] = %d\n", arr[0]); 
arr[0] = 666; 
printf("arr[0] = %d\n", arr[0]); 
printf("arr[1] = %d\n", arr[1]); 
printf("arr[2] = %d\n", arr[2]); 
// ... 
printf("arr[9] = %d\n", arr[9]); 
printf("arr[10] = %d\n", arr[10]); 

for (int i = 0; i < sizeof(arr)/sizeof(int); i++) 
{ 
    printf("arr[%d] = %d\n", i,arr[i]); 
}
int arr[10] = {}; 
for (int i = 0; i < sizeof(arr) / sizeof(arr[0]); i++) 
{ 
    printf("arr[%d] = %d\n", i,arr[i]); 
}

字符数组

字符数组也是数组,只是他的元素类型是字符.

初始化与赋值

普通数组形式
字符串形式

元素访问

char str[5] = { 'A', 99, 48 }; 
for (int i = 0; i < 5; i++) 
{ 
    printf("%c %d\n",str[i],str[i]); 
}
// char str[5] = "12345"; 注意结束符:'\0' 
char str1[5] = "1234"; 
char str2[5] = "123"; 
char str3[5] = ""; 
char str4[] = "1234"; 
char str5[] = ""; // 注意结束符:'\0'

for (size_t i = 0; i < 5; i++) 
{ 
    printf("str1 %c %d %X\n", str1[i]); 
    printf("str2 %c %d %X\n", str2[i]); 
    printf("str3 %c %d %X\n", str3[i]); 
}
可以使用%s直接输出整个字符数组的内容
char str[10] = "123456789"; 
printf("%s\n", str); 
char str[10] = "12345689"; 
printf("%s\n", str); 
for (int i = 0; i < 10; i++) 
{ 
    printf("str[%d] = %c\n", i,str[i]); 
}

二维数组

当元素类型是一维数组时此时的数组就是二维数组

#include <stdio.h> 
int main() 
{ 
/* 二维数组 */ 
// 元素类型 数组名 [行][列] = {}; 
// 每一行:都是一个一维数组 
    int arr[3][4] = { 
        { 0, 01, 02, 03 }, // arr[0]; 
        { 10, 11, 12, 13 }, // arr[1]; 
        { 20, 21, 22, 23 } // arr[2]; 
    };
    arr[0]; 
    arr[0][0]; 
    int arr1[3][4] = { 
        0,1,2,3,4,5 
    };
    
    for (size_t i = 0; i < 3; i++) 
    { 
        for (size_t j = 0; j < 4; j++) 
        { 
            printf("%3d", arr[i][j]); 
        }
        printf("\n"); 
    }
}

三维数组

// 元素类型 数组名[层][行][列] = {}; 
// 每一层:都是一个二维数组 
int a[2][3][4] = { 
    { 
        { 0, 01, 02, 03 }, 
        { 10, 11, 12, 13 }, 
        { 20, 21, 22, 23 } 
    },
    { 
        { 0, 01, 02, 03 }, 
        { 10, 11, 12, 13 }, 
        { 20, 21, 22, 23 } 
    } 
};

a[0][0][0]; 
return 0;

福利部分：

// 1
char a = 0XA5; 
unsigned int b = a >> 4 + 1; 
printf("b = %d\n", b); 

// 2
char a = -0XA5; 
unsigned int b = a >> 4 + 1; 
printf("b = %d\n", b); 

// 3
unsigned char a = 0XA5; 
int b = a >> 4 + 1; 
printf("b = %d\n", b);

第一题

首先，先看a的值转换过来就是165，但是他是char类型，而有符号的char类型取值范围在-128~127之间，造成了数据溢出，即在165的基础上减去256，得到-91。

而-91的二进制为1101 1011，而a>>4+1的意思即为向右位移5位，且高位需要补符号位，即得a为1000 0101。所以b为-3。

第二题也是同理

a需要加上256，后面的方法与第一题的方法相同。b为2。

第三题

a仅需要转换为二进制，再向右移5位即可得到b，b为5。

对数据溢出、和位操作不太清楚的可以去看看我之前写的那几篇。

以下给出文章地址，不太清楚的可以点以下链接进行查看。

数据溢出(在第3点sizeof()处)

字符串的取值范围(在数据类型下的字符型处)

位操作(在第5点处)