在我的代码中:
char *str[] = {"forgs", "do", "not", "die"};
printf("%d %d", sizeof(str), sizeof(str[0]));
我得到的输出为12 2
,所以我的疑问是:
- 为什么有区别?
str
和都是str[0]
char 指针,对吧?
通过这个问题已经得到回答和接受,但我添加了一些我认为对新用户有帮助的描述(也回答了原始问题)。(正如我搜索的那样,此描述在其他任何地方都没有解释(至少在stackoverflow上),因此我现在添加。
6.5.3.4 sizeof 运算符,1125:
将sizeof
运算符应用于数组类型时,结果是数组中的总字节数。
根据 this when sizeof
应用于静态数组标识符的名称(不是通过 malloc 分配的),结果是整个数组的大小(以字节为单位),而不仅仅是地址。这是数组名称被转换/衰减为指向数组第一个元素的指针的规则的少数例外之一,这可能只是因为实际数组大小在编译时是固定的并且已知的,当sizeof
运算符评估。
为了更好地理解它,请考虑以下代码:
#include<stdio.h>
int main(){
char a1[6], // One dimensional
a2[7][6], // Two dimensional
a3[5][7][6]; // Three dimensional
printf(" sizeof(a1) : %lu \n", sizeof(a1));
printf(" sizeof(a2) : %lu \n", sizeof(a2));
printf(" sizeof(a3) : %lu \n", sizeof(a3));
printf(" Char : %lu \n", sizeof(char));
printf(" Char[6] : %lu \n", sizeof(char[6]));
printf(" Char[5][7] : %lu \n", sizeof(char[7][6]));
printf(" Char[5][7][6]: %lu \n", sizeof(char[5][7][6]));
return 1;
}
它的输出:
sizeof(a1) : 6
sizeof(a2) : 42
sizeof(a3) : 210
Char : 1
Char[5] : 6
Char[5][7] : 42
Char[5][7][6]: 210
检查上面在@codepad的工作,注意大小char
是一个字节,你在上面的程序中替换它char
然后int
每个输出将sizeof(int)
在你的机器上乘以。
char* str[]
两者之间以及char str[][]
如何存储在内存中的区别声明一: char *str[] = {"forgs", "do", "not", "die"};
在这个声明str[]
中是一个指向char的指针数组。每个索引都str[i]
指向{"forgs", "do", "not", "die"};
.
逻辑上str
应按以下方式排列在内存中:
Array Variable: Constant Strings:
--------------- -----------------
str: 201 202 203 204 205 206
+--------+ +-----+-----+-----+-----+-----+-----+
343 | |= *(str + 0) | 'f' | 'o' | 'r' | 'g' | 's' | '\0'|
| str[0] |-------| +-----+-----+-----+-----+-----+-----+
| 201 | +-----------▲
+--------+ 502 503 504
| | +-----+-----+-----+
347 | str[1] |= *(str + 1) | 'd' | 'o' | '\0'|
| 502 |-------| +-----+-----+-----+
+--------+ +-----------▲
| | 43 44 45 46
351 | 43 | +-----+-----+-----+-----+
| str[2] |= *(str + 2) | 'n' | 'o' | 't' | '\0'|
| |-------| +-----+-----+-----+-----+
+--------+ +-----------▲
355 | |
| 9002 | 9002 9003 9004 9005
| str[3] | +-----+-----+-----+-----+
| |= *(str + 3) | 'd' | 'i' | 'e' | '\0'|
+--------+ | +-----+-----+-----+-----+
+-----------▲
Diagram: shows that str[i] Points to first char of each constant string literal.
Memory address values are assumption.
注意:str[]
存储在 continue 内存分配中,每个字符串都存储在内存中的随机地址(而不是 continue 空间中)。
[回答]
根据Codepad以下代码:
int main(int argc, char **argv){
char *str[] = {"forgs", "do", "not", "die"};
printf("sizeof(str): %lu, sizeof(str[0]): %lu\n",
sizeof(str),
sizeof(str[0])
);
return 0;
}
输出:
sizeof(str): 16, sizeof(str[0]): 4
在此代码中是一个包含4 个str
字符地址的数组,其中每个字符的大小为 4 个字节,因此根据上面的引用,数组的总大小为= 16 个字节。 char*
4 * sizeof(char*)
的数据类型str
是char*[4]
。
str[0]
只不过是指向 char 的指针,所以它是四个字节。的日期类型str[i]
是char*
。
(注意:在某些系统地址可以是 2 字节或 8 字节)
在任何架构上,第一个值应该是第二个值的 4 倍。在 32 位机器上,你应该得到 16 4,在 64 位机器上应该得到 32 8。在非常老的机器上或在嵌入式系统上,你甚至可能得到 8 2,但永远不会得到 12 2,因为数组包含 4 个元素相同大小
附加点:
str[i]
指向一个 char*
(和字符串)是可变的,str[i]
可以分配一个新的字符串的地址,例如:str[i] = "yournewname";
对i = 0 to < 4
.还有一点需要注意:
在我们上面的示例str[i]
中,指向无法修改的常量字符串;因此str[i][j] = 'A'
是无效的(我们不能在只读内存上写入),这样做将是一个运行时错误。
但是假设 ifstr[i]
指向一个简单的 char 数组 thenstr[i][j] = 'A'
可以是一个有效的表达式。
考虑以下代码:
char a[] = "Hello"; // a[] is simple array
char *str[] = {"forgs", "do", "not", "die"};
//str[0][4] = 'A'; // is error because writing on read only memory
str[0] = a;
str[0][5] = 'A'; // is perfectly valid because str[0]
// points to an array (that is not constant)
在这里检查工作代码:键盘
声明 2 char str[][6] = {"forgs", "do", "not", "die"};
::
这str
是一个大小为 4 * 6 的二维字符数组(其中每一行的大小相等)。(请记住,在这里你必须在声明中str
明确给出列值,但行是 4,因为字符串的数量是 4)
在内存str[][]
中将如下图所示:
str
+---201---202---203---204---205---206--+
201 | +-----+-----+-----+-----+-----+-----+|
str[0] = *(str + 0)--►| 'f' | 'o' | 'r' | 'g' | 's' | '\0'||
207 | +-----+-----+-----+-----+-----+-----+|
str[1] = *(str + 1)--►| 'd' | 'o' | '\0'| '\0'| '\0'| '\0'||
213 | +-----+-----+-----+-----+-----+-----+|
str[2] = *(str + 2)--►| 'n' | 'o' | 't' | '\0'| '\0'| '\0'||
219 | +-----+-----+-----+-----+-----+-----+|
str[3] = *(str + 3)--►| 'd' | 'i' | 'e' | '\0'| '\0'| '\0'||
| +-----+-----+-----+-----+-----+-----+|
+--------------------------------------+
In Diagram:
str[i] = *(str + i) = points to a complete i-row of size = 6 chars.
str[i] is an array of 6 chars.
内存中二维数组的这种排列称为行主要:线性内存中的多维数组被组织成行一个接一个地存储。这是 C 编程语言使用的方法。
注意两个图中的差异。
i = 0 to 2
,str[i]
和str[i + 1]
value 相差 6 个字节(即等于一行的长度)。str
表示完整的 6 * 4 = 24 个字符。 现在考虑您在问题中针对二维字符数组发布的类似代码,请查看Codepad:
int main(int argc, char **argv){
char str[][6] = {"forgs", "do", "not", "die"};
printf("sizeof(str): %lu, sizeof(str[0]): %lu\n",
sizeof(str),
sizeof(str[0])
);
return 0;
}
输出:
sizeof(str): 24, sizeof(str[0]): 6
根据sizeof
运算符对数组的处理,在应用二维数组大小时,应返回整个数组大小,即 24 字节。
众所周知,sizeof
运算符在应用数组名称时返回整个数组的大小。因此,sizeof(str)
它返回 = 24,即完整的 2D 字符数组的大小,由 24 个字符(6 列 * 4 行)组成。
在这个声明类型中str
是char[4][6]
。
更有趣的一点是str[i]
表示一个数组 chats,它的类型是char[6]
. 并且sizeof(str[0])
是完整数组的大小 = 6(行长)。
附加点:
在第二个声明str[i][j]
中不是常量,它的内容可以改变,例如str[i][j] = 'A'
是一个有效的操作。
str[i]
是 char 类型的数组的名称char[6]
是一个常量,分配给str[i]
egstr[i] = "newstring"
是非法操作(感染它将是编译时错误)。
两个声明之间的另一个重要区别:
在Declaration-1 :char *str[] = {"forgs", "do", "not", "die"};
中,类型&str
为char*(*)[4]
char 指针数组的地址。
在Declaration-2 :char str[][6] = {"forgs", "do", "not", "die"};
中,类型&str
为char(*)[4][6]
4 行 6 列的二维字符数组的地址。
如果想阅读一维数组的类似描述:返回什么sizeof(&array)
?
在大多数情况下,数组名称将衰减为其第一个元素的地址值,并且类型与指向元素类型的指针相同。因此,您会期望 barestr
的值等于&str[0]
指向指针的类型指针char
。
但是,情况并非如此sizeof
。在这种情况下,数组名称保持其类型为sizeof
,这将是 4 指针的数组char
。
的返回类型sizeof
是 a size_t
。如果您有 C99 编译器,则可以%zu
在格式字符串中使用以打印sizeof
.
它16 4
在我的电脑上,我可以解释一下:str
是一个数组char*
,所以 sizeof(str)==sizeof(char*)*4
我不知道你为什么会得到12 2
。
两个指针不一样。str
是一个array of char pointers
,在你的例子中是一个(char*[4]
),并且str[0]
是一个char pointer
。
第一个sizeof
返回包含的四个 char 指针的大小,第二个返回char*
.
在我的测试中,结果是:
sizeof(str[0]) = 4 // = sizeof(char*)
sizeof(str) = 16
= sizeof(str[0]) + sizeof(str[1]) + sizeof(str[2]) + sizeof(str[3])
= 4 * sizeof(char*)
= 4 * 4
= 16