Разделение size_t с помощью int vs double [duplicate]
Если вы получаете это сообщение во время сохранения или компиляции сборки, просто закройте все файлы, а затем откройте любой файл для компиляции и сохранения.
Для меня причина в том, что я переименовал файл, и старый файл все еще был открыт.
3 ответа
2 неявно преобразуется в double, потому что foo является двойным. Вы должны быть осторожны, потому что если foo было, скажем, целым, целочисленное деление было бы выполнено, и тогда результат будет сохранен в halfFoo.
Я считаю, что это хорошая практика всегда используйте литералы с плавающей запятой (например, 2.0 или 2., где бы вы ни планировали использовать их в качестве значений с плавающей запятой). Это более последовательно и может помочь вам найти пагубные ошибки, которые могут возникнуть с такими вещами.
-
1Вторая мысль, а как насчет сравнения? Подобно сравнению двойника, чтобы быть & lt; или & gt; 0? Мне интересно, использовать ли 0 или 0.0 – Anonymous 25 November 2009 в 20:02
-
2Я бы использовал 0.0, просто чтобы остаться в привычке, хотя в этом случае это действительно неважно. – David Thornley 25 November 2009 в 20:05
-
3@Person: конверсии происходят во время компиляции, а не во время выполнения, поэтому производительность (run-time) не является проблемой. Если LHS сравнения производит поплавок или двойной, RHS должен быть плавающей или двойной константой, для ясности для людей, читающих код. Но для компилятора существует незначительная разница. – Jonathan Leffler 25 November 2009 в 20:07
-
4Спасибо за всю информацию. – Anonymous 25 November 2009 в 20:11
Строго говоря, то, что вы пытаетесь достичь, кажется контрпродуктивным.
Как правило, можно было бы сократить количество преобразований типа явного типа в программе на языке C и, как правило, уменьшить все и любые зависимости типов в исходном коде. Хороший код C должен быть как можно более независимым от типа. Это, как правило, означает, что рекомендуется избегать явных синтаксических элементов, которые как можно чаще описывают конкретные типы. Лучше сделать
const double foo = 5; /* better */
, чем
const double foo = 5.0; /* worse */
, потому что последнее является избыточным. Неявные правила преобразования типов языка C будут гарантировать, что первое работает правильно. То же самое можно сказать и о сравнении. Этот
if (foo > 0)
лучше, чем
if (foo > 0.0)
, потому что, опять же, первый более независим от типа.
Неявное преобразование типа в этом случае - очень хорошая вещь, а не плохая вещь. Это поможет вам написать общий не зависящий от типа код. Почему вы пытаетесь избежать их?
Правда, в некоторых случаях у вас нет другого выбора, кроме как явно выражать тип (например, использовать 2.0 вместо 2 и т. Д.). Но обычно это можно делать только тогда, когда это действительно нужно. Почему кто-то сделает это без реальной потребности, находится вне меня.
Это известно как Тип Принуждение . Википедия имеет приятный бит об этом:
Неявное преобразование типа, также известное как принуждение, является автоматическим преобразованием типа компилятором. Некоторые языки позволяют или даже требуют, чтобы компиляторы обеспечивали принуждение.
В выражении смешанного типа данные одного или нескольких подтипов могут быть преобразованы в супертип по мере необходимости во время выполнения, чтобы программа работала правильно .
...
Такое поведение следует использовать с осторожностью, так как могут возникнуть непредвиденные последствия. Данные могут быть потеряны, когда представления с плавающей запятой преобразуются в интегральные представления, поскольку дробные компоненты значений с плавающей запятой будут усечены (округлены вниз). И наоборот, преобразование из интегрального представления в плавающую точку также может потерять точность, поскольку тип с плавающей запятой может быть неспособным точно представлять целое число (например, float может быть типом одиночной точности IEEE 754, который не может представлять integer 16777217 точно, в то время как 32-разрядный целочисленный тип может). Это может привести к таким ситуациям, как сохранение одного и того же целочисленного значения в две переменные типа integer и тип real, которые возвращают false, если сравнивать их для равенства.
В случае C и C ++ значение выражения интегральных типов (то есть longs, integers, shorts, chars) является наибольшим интегральным типом в выражении. Я не уверен, но я предполагаю, что что-то подобное происходит (предполагая, что значения с плавающей запятой «больше», чем целые) с выражениями, включающими числа с плавающей запятой.