C语言中指针数组的初始化
上一页
下一页
一个指针是一个存储另一个变量地址的变量。指针变量名必须以“*”符号作为前缀。就像普通变量一样，我们也可以声明一个“指针数组”，其中数组的每个下标都保存一个数组类型的地址。
如何在C语言中初始化指针数组？
在声明时，可以通过为指针变量赋值现有变量的地址来初始化它。以下代码片段显示了如何初始化一个指针：
int x = 10;
int *y = &x;
默认情况下，所有变量（包括指针变量）都属于“自动存储类别”。这意味着指针变量将存储一个不可预测的、垃圾的、随机的内存地址，这可能导致未定义的行为和潜在的程序风险，例如分段错误。因此，如果我们在声明时没有特定的值要存储，则应将其初始化为 NULL。
int *ptr = NULL;
“指针数组”在每个元素中存储地址。数组的类型必须与目标变量的类型匹配。
使用 static 关键字初始化指针数组
您还可以使用static关键字初始化指针数组，以在每个下标中存储“0”。
示例
#include
int main(){
static int *ptr[5];
for (int i = 0; i < 5; i++){
printf("ptr[%d] = %d\n", i, ptr[i]);
}
return 0;
}
输出
运行代码并检查其输出：
ptr[0]= 0
ptr[1]= 0
ptr[2]= 0
ptr[3]= 0
ptr[4]= 0
初始化整数指针数组
在这里，我们声明一个整数指针数组，并存储三个整数变量的地址。
示例
#include
int main(){
int a = 10, b = 20, c = 30;
int *ptr[3] = {&a, &b, &c};
for (int i = 0; i < 3; i++){
printf("ptr[%d]: address: %d value: %d\n", i, ptr[i], *ptr[i]);
}
return 0;
}
输出
运行代码并检查其输出：
ptr[0]: address: 6422040 value: 10
ptr[1]: address: 6422036 value: 20
ptr[2]: address: 6422032 value: 30
通过直接地址初始化指针数组
我们可以将普通数组的每个元素的地址存储在指针数组的相应元素中。
示例
#include
int main(){
int arr[] = {10, 20, 30};
int *ptr[3] = {&arr[0], &arr[1], &arr[2]};
for (int i = 0; i < 3; i++){
printf("ptr[%d]: address: %d value: %d\n", i, ptr[i], *ptr[i]);
}
return 0;
}
输出
运行代码并检查其输出：
ptr[0]: address: 6422032 value: 10
ptr[1]: address: 6422036 value: 20
ptr[2]: address: 6422040 value: 30
使用基地址遍历数组
当我们获得数组的基地址（在本例中为“&arr[0]”）时，我们可以知道指针会根据数据类型的尺寸递增，从而获得其后续元素的地址。
因此，只需使用基地址（数组名与第 0 个元素的地址相同），我们就可以遍历数组。
示例 1
看看下面的例子：
#include
int main(){
int arr[] = {10, 20, 30};
int *ptr=arr;
for (int i = 0; i < 3; i++){
printf("ptr[%d]: address: %d value: %d\n", i,ptr+i, *(ptr+i));
}
return 0;
}
输出
运行代码并检查其输出：
ptr[0]: address: 6422020 value: 10
ptr[1]: address: 6422024 value: 20
ptr[2]: address: 6422028 value: 30
示例 2：使用指针数组遍历二维数组
在这个例子中，我们有一个二维数组。每一行的第 0 个元素的地址都存储在一个指针数组中。遍历时，指针数组中每个元素存储的地址（指向对应行的第 0 个元素）都会递增，以获取每一行中的值。
#include
int main(){
// 2d array
int arr[3][4] = {
{1, 2, 3, 4},
{5, 6, 7, 8},
};
int ROWS = 2, COLS = 4;
int i, j;
// pointer
int (*ptr)[4] = arr;
// print the element of the array via pointer ptr
for (i = 0; i < ROWS; i++) {
for (j = 0; j < COLS; j++) {
printf("%d ", *(ptr[i]+j));
}
printf("\n");
}
return 0;
}
输出
运行此代码时，将产生以下输出：
1 2 3 4
5 6 7 8
示例 3
这里我们实际上并不需要指针数组，因为我们可以使用这个二维数组的名称作为它的基指针，并逐行逐列地递增它来获取给定二维数组中的元素：
#include
int main(){
// 2d array
int arr[3][4] = {
{1, 2, 3, 4},
{5, 6, 7, 8},
};
int ROWS = 2, COLS = 4;
int i, j;
// pointer
int *ptr = arr;
// print the element of the array via pointer ptr
for (i = 0; i < ROWS; i++){
for (j = 0; j < COLS; j++){
printf("%d ", *(ptr + i * COLS + j));
}
printf("\n");
}
return 0;
}
输出
输出与之前的代码类似：
1 2 3 4
5 6 7 8
初始化字符指针数组（字符串）
在 C 编程中，字符串是 char 数据类型的数组。由于数组的名称也表示其第 0 个元素的地址，因此可以声明一个字符串为：
char arr[] = "Hello";
使用指针表示法，字符串被赋值给 char 指针为：
char *arr = "Hello";
然后，我们可以声明一个 char 指针数组来存储多个字符串，如下所示：
char *arr[3] = {"string1", "string2", "string3", . . . };
示例
下面的例子有一个char 指针数组，用于存储计算机语言的名称：
#include
int main(){
char *langs [10] = {
"PYTHON", "JAVASCRIPT", "PHP",
"NODE JS", "HTML", "KOTLIN", "C++",
"REACT JS", "RUST", "VBSCRIPT"
};
for(int i = 0; i < 10; i++)
printf("%s\n", langs[i]);
return 0;
}
输出
运行此代码时，将产生以下输出：
PYTHON
JAVASCRIPT
PHP
NODE JS
HTML
KOTLIN
C++
REACT JS
RUST
VBSCRIPT
在这个程序中，“langs”是一个指向包含 10 个字符串的数组的指针。因此，如果“langs[0]”指向地址 5000，“langs + 1”将指向地址 5004，该地址存储指向第二个字符串的指针。
因此，我们也可以使用以下循环变体来打印字符串数组：
for (int i = 0; i < 10; i++){
printf("%s\n", *(langs + i));
}
动态指针数组的初始化
您可以使用malloc() 函数以动态方式声明和初始化指针数组。
示例
看看下面的例子：
#include
int main(){
int *arr = (int *)malloc (sizeof (int) * 5);
for(int i = 0; i < 5; i++){
arr[i] = i;
}
for (int x = 0; x < 5; x++){
printf("%d %d\n", x, arr[x]);
}
return 0;
}
输出
运行此代码时，将产生以下输出：
0 0
1 1
2 2
3 3
4 4
您甚至可以请求用户输入并将值赋给指针数组中的元素：
for(i = 0; i < 5; i++){
scanf("%d", &x);
arr[i] = x;
}
打印页面
上一页 下一页
广告