什么'；C中的char*s[]和char s[][20]之间的区别是什么？

检查第一个代码，如果我写的是

char*tracks[]

而不是

char tracks[][80]

，它似乎仍然可以完美地工作

#include <stdio.h>
#include <string.h>

char tracks[][80] = { "I left my heart in Harvard Med School",
        "Newark, Newark - a wonderful town", "Dancing with a Dork",
        "From here to maternity", "The girl from Iwo Jima", };

void find_track(char search_for[]) {    //'char *search_for' is equivalent.
    int i;
    for (i = 0; i < 5; i++) {
        if (strstr(tracks[i], search_for))
            printf("Track %i(Line %i):'%s'\n", i, i + 1, tracks[i]);
    }
}

int main() {
    char search_for[80];
    printf("Search for: ");
    scanf("%79s", search_for);  //fgets(search_for,80,stdin);
    find_track(search_for);
    return 0;
}

这很奇怪，因为若您检查下面的第三个代码，它将给出错误，因为指向字符串文本的指针无法更新。如果事情是这样的，那么在第二个代码中，

char*juices[]

是指向字符串文本的指针数组，而

juices[2]

是指向

“sharonfruit”

的指针，如何更新它

#include <stdio.h>

int main()
{

char *cards = "JQK";  //you should use char cards[]="JQK";
char a_card = cards[2];

cards[2] = cards[1];
cards[1] = cards[0];
cards[0] = cards[2];
cards[2] = cards[1];
cards[1] = a_card;

puts(cards);

return 0;

}

#包括
int main（）
{
char*cards=“JQK”；//您应该使用char cards[]=“JQK”；
char a_card=卡片[2]；
卡片[2]=卡片[1]；
卡片[1]=卡片[0]；
卡片[0]=卡片[2]；
卡片[2]=卡片[1]；
卡[1]=一张U卡；
扑克牌;；
返回0；
}

在C中，“最外层”数组（即第一个

[]

）自动转换为指向第一个元素的指针

因此,

char tracks[][80] 

声明指向

char

数组（长度为80）的指针

然而

char *tracks[]

显然是一个字符指针数组，这是不同的。编译器知道这一点，不会让您这么做

此外，这些东西在内存中是不同的：数组化合物在内存中肯定是线性的，指针数组可能包含指向内存中任何位置的指针。

在C中，“最外层”数组（即第一个

[]

）会自动转换为指向第一个元素的指针

char tracks[][80] = { "I left my heart in Harvard Med School",
    "Newark, Newark - a wonderful town", "Dancing with a Dork",
    "From here to maternity", "The girl from Iwo Jima", };

因此,

char tracks[][80] 

声明指向

char

数组（长度为80）的指针

然而

char *tracks[]

显然是一个字符指针数组，这是不同的。编译器知道这一点，不会让您这么做

此外，这些东西在内存中是不同的：数组化合物在内存中肯定是线性的，指针数组可能包含指向内存中任何位置的指针。

在C中，“最外层”数组（即第一个

[]

）会自动转换为指向第一个元素的指针

char tracks[][80] = { "I left my heart in Harvard Med School",
    "Newark, Newark - a wonderful town", "Dancing with a Dork",
    "From here to maternity", "The girl from Iwo Jima", };

因此,

char tracks[][80] 

声明指向

char

数组（长度为80）的指针

然而

char *tracks[]

显然是一个字符指针数组，这是不同的。编译器知道这一点，不会让您这么做

此外，这些东西在内存中是不同的：数组化合物在内存中肯定是线性的，指针数组可能包含指向内存中任何位置的指针。

在C中，“最外层”数组（即第一个

[]

）会自动转换为指向第一个元素的指针

char tracks[][80] = { "I left my heart in Harvard Med School",
    "Newark, Newark - a wonderful town", "Dancing with a Dork",
    "From here to maternity", "The girl from Iwo Jima", };

因此,

char tracks[][80] 

声明指向

char

数组（长度为80）的指针

然而

char *tracks[]

显然是一个字符指针数组，这是不同的。编译器知道这一点，不会让您这么做

而且，这些东西在内存中是不同的：数组复合在内存中肯定是线性的，指针数组可能包含指向内存中任何位置的指针

char tracks[][80] = { "I left my heart in Harvard Med School",
    "Newark, Newark - a wonderful town", "Dancing with a Dork",
    "From here to maternity", "The girl from Iwo Jima", };

创建

char

数组，或者换句话说，创建

char

二维数组，并用每个字符串初始化每个索引。字符串的数量由编译器在编译时确定，每个字符串的最大大小为80

char *tracks[] = { "I left my heart in Harvard Med School",
    "Newark, Newark - a wonderful town", "Dancing with a Dork",
    "From here to maternity", "The girl from Iwo Jima", };

声明

char

指针数组。每个指针都指向每个字符串文字。指针的数量由编译器在编译时确定

字符串文本是不可变的意味着它不能更改

在使用

曲目的前两个程序中，第一个版本（
char-tracks[][80]
）和第二个版本（
char*tracks[]
）的工作方式是不更改字符串和不分配数组

在使用
juices
的后两个程序中，第一个版本可以工作（
char*juices[]
），因为指针可以更改，也就是说，指针指向的位置可以更改，但是第二个版本（
char juices[][80]
）不能工作，因为您分配了数组。请记住，数组是不可分配的

要解决此问题，可以使用
string.h
库中的
strcpy
函数交换存储在
char-juice[][80]
中的字符串。请注意，如果要尝试此操作，则需要为变量
a
分配内存

创建
char
数组，或者换句话说，创建
char
二维数组，并用每个字符串初始化每个索引。字符串的数量由编译器在编译时确定，每个字符串的最大大小为80

char *tracks[] = { "I left my heart in Harvard Med School",
    "Newark, Newark - a wonderful town", "Dancing with a Dork",
    "From here to maternity", "The girl from Iwo Jima", };

声明
char
指针数组。每个指针都指向每个字符串文字。指针的数量由编译器在编译时确定

字符串文本是不可变的意味着它不能更改

在使用
曲目的前两个程序中，第一个版本（
char-tracks[][80]
）和第二个版本（
char*tracks[]
）的工作方式是不更改字符串和不分配数组

在使用
juices
的后两个程序中，第一个版本可以工作（
char*juices[]
），因为指针可以更改，也就是说，指针指向的位置可以更改，但是第二个版本（
char juices[][80]
）不能工作，因为您分配了数组。请记住，数组是不可分配的

要解决此问题，可以使用
string.h
库中的
strcpy
函数交换存储在
char-juice[][80]
中的字符串。请注意，如果要尝试此操作，则需要为变量
a
分配内存

创建
char
数组，或者换句话说，创建
char
二维数组并初始化ea