Читая часть книги о 3D-графике, я пришел по следующему заданию:
const float vertexPositions[] = {
0.75f, 0.75f, 0.0f, 1.0f,
0.75f, -0.75f, 0.0f, 1.0f,
-0.75f, -0.75f, 0.0f, 1.0f,
};
Зачем нужен суффикс f? Можно ли определить тип литералов по типу переменной? Я считаю, что без f литералы с плавающей запятой интерпретируются как удвоения, но почему, когда массив явно имеет тип float?
Инициализация массива с плавающей запятой в вашем примере прекрасна в C, как если бы она использовала константы double. Для имеющихся значений также было бы хорошо, если бы это был массив double, инициализированный float константами, потому что имеющиеся значения точно представляются как float. У компилятора не было бы причин выдавать предупреждение даже в этом последнем случае, хотя было бы странно и сбивало с толку, что разработчик удосужился ввести дополнительные суффиксы, которые не соответствуют конечному типу.
Короче говоря, автор только говорит явно, что в случае массива float хорошо.
Для произвольных значений, записанных в десятичном формате, вы не хотите инициализировать float переменных double константами из-за округление» (в котором слово «двойной» означает дважды и не относится к одноименному типу). Если вы инициализируете f1 и f2 следующим образом, они получат разные значения, и f1 на самом деле ближе всего к предполагаемому значению 1,01161128282547:
float f1 = 1.01161128282547f;
float f2 = 1.01161128282547;
Объяснение состоит в том, что в случае f2 десятичное значение 1,01161128282547 сначала округляется до ближайшего double, а затем до ближайшего float. Эти два шага вносят больше ошибок, чем прямое округление до ближайшего float, как инициализируется f1.
Некоторые терминологические придирки.
{} (например, 1.0f), не является литералом, это константы. В C есть только строковые литералы и составные литералы, и все. В C 1.0 является константой с плавающей запятой.В языке C тип правой части (присваивания или инициализации) никогда не зависит от типа левой части. Тип значения в правой части всегда определяется независимо. Оно определяется исключительно тем, как указано это значение. Левая сторона никогда не принимается во внимание. Затем, когда тип правого размера известен, исходное значение преобразуется в тип левого. Другими словами, константа 1.0 всегда является константой типа double, даже если вы используете ее для инициализации объекта float.
Нет ничего неправильного в использовании константы double (например, 1.0) для инициализации объекта типа float. Как я сказал выше, значение double будет преобразовано в тип float. Однако некоторые компиляторы выдают предупреждение об этом преобразовании, уведомляя пользователя о возможной потере точности. В частности, чтобы подавить это предупреждение, люди использовали бы явный суффикс с плавающей запятой (например, 1.0f) или явное приведение к float (например, (float) 1.0) при инициализации объектов float. Это выглядит не очень хорошо, так как противоречит правилу DRY (Don't-Repeat-Yourself), но в реальной жизни такой способ работы с предупреждениями встречается довольно часто.
Хотя вы можете не получить никаких ошибок из-за пропуска f, это хорошая практика, и есть несколько причин, почему, например:
float num = 0.1;
(num == 0.1)
Оценка даст 0, потому что num округляется до 0.1 как число с плавающей запятой, а 0.1 в выражении удваивается. Так что на самом деле они не одинаковы, хотя могут показаться.
num, потому что вы сравниваете с двойным литералом
- person pqnet; 08.08.2014
num повысили до double в (num == 0.1). Кроме того, выражение (num == 0.1f) будет оцениваться как 1, как и ожидалось. Проблема в float num = 0.1; (num == 0.1) полностью связана со сравнением, и float num = 0.1f; (num == 0.1) даст точно такой же результат.
- person Pascal Cuoq; 08.08.2014
(num == 0.1) производит 0. Ни pqnet, ни я не спорим об этом.
- person Pascal Cuoq; 08.08.2014
0.0 преобразуется в число с плавающей запятой, а сравнение выполняется в число с плавающей запятой), вы действительно получите 1 в результате сравнения, поэтому я думаю, что вы нас неправильно поняли, мы на самом деле говорим одно и то же.
- person pqnet; 08.08.2014
Нет, тип литерала никогда не выводится. Без f они являются double литералами, а инструкция представляет собой преобразование, которое может потерять точность (не совсем в этом случае, потому что все литералы также точно представлены с плавающей запятой).
То же предупреждение, которое вы получите, если сделаете
float x = 3.0;
float x = 3.0;, называется конверсией. cast — это явная синтаксическая конструкция, которая вызывает преобразование. В float x = (float) 3.0; есть приведение, а в float x = 3.0; нет (есть конверсия).
- person Pascal Cuoq; 08.08.2014
FLT_RADIX является степенью 2 или 10, что почти наверняка так и есть (на самом деле FLT_RADIX != 2 встречается редко).
- person Keith Thompson; 08.08.2014
3.0 имеет точное представление в вещественном числе (на самом деле это верно для любых FLT_RADIX % 2 = 0 или FLT_RADIX % 3 = 0, а не только для степени двойки или десятки), но я не это имел в виду. Моя точка зрения заключалась в том, что существует неявное преобразование из одного типа в другой, поскольку тип для 3.0 является 64-битным числом с плавающей запятой, а тип для x — 32-битным числом с плавающей запятой, и это вызвало бы предупреждение от многих компиляторов.
- person pqnet; 08.08.2014
3.0 равен double (часто 64-битный, но это не гарантируется). Тип 3.0f — float (часто это 32 бита, но это также не гарантируется). double и float (а также long double) являются типами с плавающей запятой.
- person Keith Thompson; 08.08.2014
f, я не получаю никаких ошибок. - person TRKemp schedule 08.08.2014f. - person Igor schedule 08.08.2014floatдля IEEE 754 binary32 иdoubleдля binary64, так как они почти везде. blog.frama-c.com/ index.php?post/2011/11/08/Опрос с плавающей запятой - person Pascal Cuoq schedule 08.08.2014