Почему sizeof (x ++) не увеличивает x?

Вот код, скомпилированный в dev c ++ windows:

#include <stdio.h>

int main() {
    int x = 5;
    printf("%d and ", sizeof(x++)); // note 1
    printf("%d\n", x); // note 2
    return 0;
}

Я ожидаю, xчто будет 6 после выполнения примечания 1 . Тем не менее, вывод:

4 and 5

Может кто-нибудь объяснить, почему xне увеличивается после примечания 1 ?

Из стандарта C99 (акцент мой)

6.5.3.4/2

Оператор sizeof возвращает размер (в байтах) своего операнда, который может быть выражением или именем типа в скобках. Размер определяется по типу операнда. Результатом является целое число. Если тип операнда является типом массива переменной длины, операнд оценивается; в противном случае, операнд не оценивается, а результатом является целочисленная константа.

sizeofявляется оператором времени компиляции, поэтому во время компиляции sizeofего операнд заменяется значением результата. Операнд не вычисляется (кроме случаев , когда это переменная массива длины) на всех; имеет значение только тип результата.

short func(short x) {  // this function never gets called !!
   printf("%d", x);    // this print never happens
   return x;
}

int main() {
   printf("%d", sizeof(func(3))); // all that matters to sizeof is the 
                                  // return type of the function.
   return 0;
}

Вывод:

2

как shortзанимает 2 байта на моей машине.

Изменение типа возвращаемого значения функции double:

double func(short x) {
// rest all same

даст в 8качестве вывода.

sizeof(foo) очень старается определить размер выражения во время компиляции:

6.5.3.4:

Оператор sizeof возвращает размер (в байтах) своего операнда, который может быть выражением или именем типа в скобках. Размер определяется по типу операнда. Результатом является целое число. Если тип операнда является типом массива переменной длины, операнд оценивается; в противном случае, операнд не оценивается, а результатом является целочисленная константа.

Вкратце: массивы переменной длины, запускаемые во время выполнения. (Примечание. Массивы переменной длины - это особая функция, а не массивы, выделенные с помощью malloc(3).) В противном случае вычисляется только тип выражения и тот, который используется во время компиляции.

sizeofявляется встроенным оператором времени компиляции и не является функцией. Это становится очень понятным в тех случаях, когда вы можете использовать его без скобок:

(sizeof x)  //this also works

Запись

Этот ответ был объединен с дубликатом, который объясняет позднюю дату.

оригинал

За исключением массивов переменной длины sizeof не оценивает его аргументы. Мы можем видеть это из стандартного раздела проекта C99 6.5.3.4 Оператор SizeOf пункта 2 , который гласит:

Оператор sizeof возвращает размер (в байтах) своего операнда, который может быть выражением или именем типа в скобках. Размер определяется по типу операнда. Результатом является целое число. Если тип операнда является типом массива переменной длины, операнд оценивается; в противном случае, операнд не оценивается, а результатом является целочисленная константа.

Комментарий ( теперь удаленный ) спросил, будет ли что-то подобное оцениваться во время выполнения:

sizeof( char[x++]  ) ;

и действительно, что-то подобное будет работать ( смотрите их вживую ):

sizeof( char[func()]  ) ;

так как они оба массивы переменной длины. Хотя я не вижу большого практического использования ни в одном из них.

Обратите внимание, что массивы переменной длины описаны в черновом варианте стандартного раздела C99, описанном в разделе 6.7.5.2 4 :

[...] Если размер является целочисленным константным выражением, а тип элемента имеет известный постоянный размер, тип массива не является типом массива переменной длины; в противном случае тип массива является типом массива переменной длины.

Обновить

В C11 ответ изменяется для случая VLA, в некоторых случаях не определено, оценивается ли выражение размера или нет. Из раздела 6.7.6.2 Array объявлений, в котором говорится:

[...] В тех случаях, когда выражение размера является частью операнда оператора sizeof, и изменение значения выражения размера не повлияет на результат оператора, неизвестно, будет ли вычисляться выражение размера.

Например, в случае, как это ( см. Это в прямом эфире ):

sizeof( int (*)[x++] )

Поскольку операнд sizeofоператора не оценивается, вы можете сделать это:

int f(); //no definition, which means we cannot call it

int main(void) {
        printf("%d", sizeof(f()) );  //no linker error
        return 0;
}

Демо онлайн: http://ideone.com/S8e2Y

То есть вам не нужно определять функцию, fесли она используется sizeofтолько в. Эта техника в основном используется в метапрограммировании шаблонов C ++, поскольку даже в C ++ операнд sizeofне оценивается.

Почему это работает? Это работает, потому что sizeofоператор не оперирует значением , а работает с типом выражения. Поэтому, когда вы пишете sizeof(f()), он работает с типом выражения f(), и это не что иное, как тип возврата функции f. Тип возвращаемого значения всегда один и тот же, независимо от того, какое значение возвращает функция, если она действительно выполняется.

В C ++ вы можете даже это:

struct A
{
  A(); //no definition, which means we cannot create instance!
  int f(); //no definition, which means we cannot call it
};

int main() {
        std::cout << sizeof(A().f())<< std::endl;
        return 0;
}

Тем не менее, похоже, sizeofчто сначала я создаю экземпляр A, пишу A(), а затем вызываю функцию fэкземпляра, пишу A().f(), но ничего подобного не происходит.

Демо: http://ideone.com/egPMi

Вот еще одна тема, которая объясняет некоторые другие интересные свойства sizeof:

• sizeof принимает два аргумента

Выполнение не может произойти во время компиляции. Так ++i/ i++не случится. Также sizeof(foo())не будет выполнять функцию, но вернет правильный тип.

sizeofвыполняется во время компиляции, но x++может оцениваться только во время выполнения. Чтобы решить эту проблему, стандарт C ++ диктует, что операнд sizeofне оценивается. Стандарт C говорит:

Если тип операнда [of sizeof] является типом массива переменной длины, операнд вычисляется; в противном случае, операнд не оценивается, а результатом является целочисленная константа.

sizeof() Оператор задает только размер типа данных, он не оценивает внутренние элементы.