Используя макро-результаты в неправильном выводе при использовании в качестве части большего математического выражения - почему это происходит?
Это - нормальная стандартная программа C, которую я узнал в некотором банке вопроса. Это показывают ниже:
#define CUBE(p) p*p*p
main()
{
int k;
k = 27 / CUBE(3);
printf("%d", k);
}
Согласно моему пониманию и знанию значение K должно быть 1, поскольку КУБ (3) был бы заменен 3*3*3 во время предварительной обработки и после последующей компиляции, это будет давать значение 1, но вместо этого это показало значение 81, который сделал меня любопытным знать, как это произошло.
Может любой выравнивать по ширине ответ 81 к этому вопросу выше.
13 ответов
Препроцессоры должны быть правильно скопированы. Замените его
#define CUBE(p) ((p)*(p)*(p))
и посмотрите.
#define CUBE(p) p*p*p
main()
{
int k;
k=27/CUBE(3);
printf("%d",k);
}
Согласно моему пониманию и знаниям значение K должно быть 1, поскольку Cube (3) будет заменен на 3 * 3 * 3 во время предварительной обработки
Да
и после последующего Компиляция это будет давать значение 1, но вместо этого он показал стоимость 81, что заставило меня любопытно узнать, как это случилось.
Нет,
k= 27/3*3*3
=(((27/3)*3)*3) (The precedence of `*` and `/` are same but the associativity is from left to right)
=((9*3)*3) =81
Заменить #define Cube (p) p * p * p с #define Cube (P) ((p) * (p) * (p))
Оба / и * операторы имеют одинаковый приоритет. Для выполнения 3 * 3 * 3 сначала вы Shoudl заключают их в скобках.
#include <stdio.h>
#define CUBE(p) p*p*p
int
main ()
{
int k;
k=27/(CUBE(3));
printf("%d",k);
return 0;
}
Это способ реализации ассоциативности и приоритет операторов. Когда выражение расширено, он становится 27/3 * 3 * 3, а не 27 / (3 * 3 * 3) Теперь разделение и умножение имеют одинаковый приоритет в C, но ассоциативность остается вправо для обоих. Так что это можно показать как: (27/3) * 3 * 3, что в свою очередь равно (9 * 3) * 3 = 81 Кроме того, если вы помните старое арифметическое правило Bodmas (вычитание добавления раздвижных кронштейнов от подразделения) . И снова мы получаем ответ на 81 за 27/3 * 3 * 3.
Из-за приоритета оператора 27/3 * 3 * 3 = 81
Вы могли бы использовать вместо этого:
inline int cube(int p) { return p*p*p; }
Препроцессор просто заменит
CUBE(3)
с
3*3*3
, поэтому вы в конечном итоге с:
k=27/3*3*3
, который, оценивая влево-направо с приоритетом оператора, на самом деле 81.
Если вы добавляете соревнования вокруг макроса , Вы должны найти результаты правильные:
#define CUBE(p) (p*p*p)
было бы даже лучше окружить каждый экземпляр P с соревнователями, как в:
#define CUBE(p) ((p)*(p)*(p))
, что позволит вам пропускать выражения к макросу Правильно (например, 1 + 2 ).
C MACros делают текстовую замену (то есть это эквивалентно копированию и копированию кода). Таким образом, ваш код выходит из:
k=27/CUBE(3);
на
k=27/3*3*3;
Отделение и умножение имеют одинаковый приоритет и имеют ассоциативность влево на правую, поэтому это анализируется как:
k=((27/3)*3)*3;
, который составляет 9 * 3 * 3 = 81.
Вот почему C MACros всегда следует определять с либеральным использованием скобок:
#define CUBE(p) ((p) * (p) * (p))
для получения дополнительной информации, см. http://c-faq.com/cpp/safemacros.html из комп. .c faq.
Ваш макрос не защищен. Попробуйте
#define CUBE(p) ((p)*(p)*(p))
Текущий макрос был расширен до
k=27/3*3*3
, который является ((27/3) * 3) * 3
27/3 * 3 * 3 = 9 * 3 * 3 = 81?
-121--4109652- [113359652-, потому что макросы - это текстовая замена, которая работает:
k = 27 / 3 * 3 * 3;
, поскольку умножение и разделение происходят слева направо, что работает:
k = ((27 / 3) * 3) * 3;
так, что вы хотите изменить это в Два способа:
#define CUBE(p) ((p)*(p)*(p))
Внешние скобки вызывают использование умножений перед любыми другими операциями.
Скобки вокруг отдельных P имеются в том случае, если вы делаете:
CUBE(1 + 2);
без этих внутренних скобок, приоритет оператора отключится вам.
k=27/CUBE(3); => k=27/3 * 3 * 3;
Вы видите это? Куб должен быть определен так, как это вместо этого:
#define CUBE(p) ((p)*(p)*(p))
Когда вы делаете макросы, вы должны быть осторожны о том, как вы размещаете скобки. В этом случае у вас нет, поэтому выражение становится 27/3 * 3 * 3, которое по правилам приоритета / и * становится (27/3) * 3 * 3.
Привет, ответ на это: 81 Объяснение: На шаге K = 27 / CUBE (3) CUBE (3) заменяется на 3 * 3 * 3 с помощью препроцессора. Затем выше утверждение становится как k = 27/3 * 3 * 3 В этом выражении 27/3 оценивается Compiler Compiler (приоритет оператора) Результат (27/3): 9 Заявление k = 27/3 * 3 * 3 становится как k = 9 * 3 * 3; Результат приведенного выше утверждения составляет 81: