Question

我正在学习sizeof，这让我感到沮丧。我决定这样做。

#include<stdio.h>
#include<string.h>
int main(){
    char *myWord="PIZZA";
    printf ("The size of P is...:%d\n",sizeof("P"));
    printf ("The size of I is...:%d\n",sizeof("I"));
    printf ("The size of Z is...:%d\n",sizeof("Z"));
    printf ("The size of A is...:%d\n",sizeof("A"));
    printf ("The size of R is...:%d\n",sizeof("R"));
    printf ("The size of PIZZA is...:%d\n",sizeof("PIZZA"));
    printf ("The size of *PIZZA is..:%d\n",sizeof(myWord));
    return 0;
}

我很惊讶地看到结果：

The size of P is...:2
The size of I is...:2
The size of Z is...:2
The size of A is...:2
The size of R is...:2
The size of PIZZA is...:6
The size of *PIZZA is..:4

问题如下：

为什么

如何

让我解释一下我的第二个问题：

据我所知，C不会将字母存储为它是，而是将字母存储为ASCII码。

这是由此代码

证明的

printf ("ASCII CODE of A:%d",myWord[4]);

结果：

ASCII CODE of A:65

所以假设我是对的，那么C将单词存储为[80,73,90,65,65]，所以5个字符* 2个字节相等..... 10个字节！但上面的代码显示6个字节和4个字节！这就是我在第二个问题中的 crunch 的意思。 C将10个字节分成6个字节和4个字节。

赞赏任何启示=）

Answer 1

每个单个字母是一个由2个字符组成的字符串，字母和字符串标记的空末尾。＆＃34; PIZZA＆＃34;是5个字母+空6个字符和* PIZZA是变量的大小，一个指针，它是4个字节。

Answer 2

"P"不是char，它是字符串文字。字符串以空值终止，因此需要一个额外的存储字节。因此sizeof("P")是2.字符串文字存储为char类型的数组。

同样，"PIZZA"是六个字节以包含空终止符（'\0'）。

如果您选中sizeof('P')，则与sizeof(int)相同，因为'P'是字符文字，并且存储为int值，尽管它们通常分配给char，因为它们不超过ASCII范围。

myWord是一个指针，因此无论你的系统大小如何 - 显然是4。

Answer 3

一个字母不两个字节。它是一个字节。 "P"是一个字符串，但C字符串是0终止的：它们有一个由编译器自动添加的尾随0字节，因此N - 字母字符串的大小为{{1 }}

关于你的第二个问题：N + 1是一个字符串文字。它是6个"PIZZA"的数组。因此它的大小是6。

另一方面，

char声明char *myWord是指针。显然，平台上指针的大小为4.事实上你可以＆＃34;将数组分配给指针＆＃34;，i。即C中从myWord到T []的隐式转换只是C的一个（通常被误解的）特征。

Answer 4

“为什么数组char和指针char的大小分别为6个字节和4个字节”

该数组有6个元素 - 5个字符和零终结符。每个元素都是一个字节的字符。

Answer 5

只是一个疯狂的猜测，但我想如果每个字符串都有一个结束字符串char添加到每个案例，所以当你做一个sizeof（＆＃34; P＆＃34;），你实际上看到sizeof（＆＃39; P＆＃39; +＆＃39; \ 0＆＃39;）

Answer 6

sizeof("P");//size is 2 because each char takes 1 byte and 
//it is  trailed by '\0' so two Bytes

如果您尝试sizeof(char);，它会为您提供1个字节

如果你尝试sizeof(int);它会给你2个字节

但是这里sizeof("P")将是2个字节，因为它落后于＆＃39; \ 0＆＃39;需要多一个Byte.Same申请sizeof("Pizza"); // 5+ trailing \0 = 6 bytes

sizeof(myWord);是4字节，因为它是一个指针

Answer 7

让我们从这里开始：

char *myWord="PIZZA";

"PIZZA"是一个字符串文字;它以char（5个字母加0个终结符）的6元素数组存储，以便在程序的生命周期内可用。 myWord是char *类型的变量，并使用字符串中第一个字母的地址进行初始化。在内存中，它看起来像这样（这就是它在我的系统中的表现，但是）：

Item        Address          0x00 0x01 0x02 0x03
----        -------          ---- ---- ---- ----
"PIZZA"     0x4006e0          'P'  'I'  'Z'  'Z'
            0x4006e4          'A'   0    ??   ??
              ...
 myWord     0x7fffa7e983d0   0x00 0x00 0x00 0x00
            0x7fffa7e983d4   0x00 0x40 0x06 0x90

sizeof("PIZZA")（或sizeof "PIZZA";仅当操作数是类型名称时才需要括号）给出数组中的总字节数（在本例中为6）。

sizeof(myWord)（或sizeof myWord;再次，在这种情况下不需要括号）以字节为单位给出指针变量的大小;在你的情况下，4。

sizeof("P")为您提供字符串文字 "P"的大小，即2（一个字母加0终结符）。如果您希望字符的大小不变 'P'，您可以编写sizeof 'P'（注意单引号而不是双引号）。除了...

在C中，'P'之类的字符常量类型为int，而不是char，因此结果（最有可能）仍然不会是1.

以下是我的系统上发生的事情：

#include <stdio.h>

int main( void )
{
  char c = 'P';
  char *myWord = "PIZZA";

  printf( "sizeof \"PIZZA\"    == %zu\n", sizeof "PIZZA" );
  printf( "sizeof myWord     == %zu\n", sizeof myWord );
  printf( "value of myWord   == %p\n", (void *) myWord );
  printf( "sizeof *myWord    == %zu\n", sizeof *myWord );
  printf( "value of *myWord  == %c\n", *myWord );
  printf( "address of myWord == %p\n", (void *) &myWord );
  printf( "sizeof \"P\"        == %zu\n", sizeof "P" );
  printf( "sizeof 'P'        == %zu\n", sizeof 'P' );
  printf( "sizeof c          == %zu\n", sizeof c );

  return 0;
}

[fbgo448@n9dvap997]~/prototypes/sizes: gcc -o sizes -g -std=c99 -pedantic -Wall -Werror -Wa,-aldh=sizes.lst sizes.c
[fbgo448@n9dvap997]~/prototypes/sizes: ./sizes
sizeof "PIZZA"    == 6
sizeof myWord     == 8
value of myWord   == 0x4006e0
sizeof *myWord    == 1
value of *myWord  == P
myWord string     == PIZZA
address of myWord == 0x7fffd8a9eb40
sizeof "P"        == 2
sizeof 'P'        == 4
sizeof c          == 1
value of c        == P

C：为什么披萨的大小不是10个字节？

7 个答案: