C: Почему размер моей пиццы не равен 10 байтам?

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 

на вопрос, является следующим:

Почему размера полукокса массива и указатель полукокса соответственно, 6 байт и 4 байта

Как приходят они «cruncuh» 5 букв * 2bytes = 10 байт. в 6 байтов и 4 байта?

Позвольте мне объяснить мой второй вопрос:

Из того, что я знаю, C не хранит письма как это, но хранить письма в ASCII коде.

Это оборудована устройством с помощью этого кода

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

результаты:

ASCII CODE of A:65

Так предполагая, что я прав, то С хранит слово, как [80,73,90,65,65], так 5 символов * 2 байты равны ..... 10 байт! Но приведенный выше код показывает 6 байтов и 4 байта! Вот что я подразумеваю под crunch в вопросе номер два. C сует 10 байтов на 6 байтов и 4 байта.

Любое просветление ценится =)

Answer 1

Каждая отдельная буква представляет собой строку из 2 символов, букв и нулевой конец строки маркера. «PIZZA» - 5 букв + null для 6 символов и * PIZZA - это размер переменной, указатель, который составляет 4 байта.

Answer 2

"P" не является char, это строка литерала. Строки имеют нулевое завершение, поэтому требуется один дополнительный байт хранилища. Следовательно, sizeof("P") - 2. Строковые литералы хранятся в виде массивов типа char.

Аналогичным образом, "PIZZA" - это шесть байтов для включения нулевого терминатора ('\0').

Если вы проверяете sizeof('P'), вы получите такой же, как sizeof(int), так как 'P' является литерой, и те, которые хранятся в виде ИНТ значений, хотя они, как правило, назначается char, так как они не превышают ASCII.

myWord - указатель, следовательно, любой размер, который находится на вашей системе - очевидно 4.

Answer 3

«Почему размер полукокса массива и указателя полукокс соответственно, 6 байт и 4 байта»

Массив состоит из 6 элементов - 5 символов и нулевой терминатор. Каждый элемент является символом, который является одним байтом.

Answer 4

Одна буква: не два байта. Это один байт. Однако "P" является строкой, а строки C имеют 0-конце: они имеют байты с байтом 0, автоматически добавленные компилятором, поэтому размер строки N составляет N + 1.

Что касается вашего второго вопроса: "PIZZA" является строковым литералом. Это массив из 6 char s. Следовательно, его размер равен 6.

char *myWord, с другой стороны, объявляет myWord указателем . По-видимому, размер указателя на вашей платформе равен 4. Тот факт, что вы можете «назначить массив указателю», т.е. е. что существует неявное преобразование от T [] до T * в C, это просто функция (n часто неправильно понимаемая) C.

Answer 5

Просто дикая догадка, но я думаю, что в случае каждой из этих строк есть символ конца строки, добавленный к каждому дело так, когда вы делаете SizeOf ("P") на самом деле вы видите SizeOf ('P' + '\ 0')

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 байта, так как он прицепной «\ 0», который принимает еще один Byte.Same применять для sizeof("Pizza"); // 5+ trailing \0 = 6 bytes

---

sizeof(myWord); 4 байта, поскольку он является указателем

Answer 7

Давайте начнем отсюда:

char *myWord="PIZZA"; 

"PIZZA" является строка литерал; он хранится в виде 6-элементного массива char (5 букв плюс 0 терминатора) таким образом, что он доступен в течение всего жизненного цикла программы. myWord - это переменная типа char *, и она инициализируется адресом первой буквы в строке. В памяти, это будет выглядеть примерно так (это то, как он играет на моей системе, Anway):

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.

Вот как вещи играть на моем system:

#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