Вычислите длину окружности

перевод
denisfrolov 17 марта 2015 в 13:41 85,9k
Оригинал: Bruce Dawson
«Пожалуйста, напишите на C++ функцию, которая получает диаметр круга как float и возвращает длину окружности как float».

Звучит как задание на первой неделе курса по C++. Но это только на первый взгляд. Сложности возникают уже на первых этапах решения задачи. Предлагаю рассмотреть несколько подходов.

Студент: Как вам такой вариант?

#include <math.h>
float CalcCircumference1(float d)
{
    return d * M_PI;
}

Преподаватель: Да, этот код может нормально откомпилироваться. А может и нет. M_PI не определена в стандартах C или C++. С компилятором в VC++ 2005 это сработает, но для более поздних версий придется использовать #define _USE_MATH_DEFINES перед включением math.h, чтобы получить доступ к этой нестандартной константе. Причем в результате вы напишете код, с которым могут не справиться другие компиляторы.

Сцена вторая


Студент: Благодарю за мудрость, учитель. Я убрал зависимость от нестандартной константы M_PI. Так лучше?

float CalcCircumference2(float d)
{
    return d * 3.14159265358979323846;
}

Преподаватель: Да, так лучше. Этот код будет скомпилирован, и вы получите искомый результат. Но ваш код неэффективен. Вы умножаете число с одинарной точностью на константу с двойной точностью. Компилятору придется привести параметр функции типа float к типу double, а затем выполнить обратное преобразование для получения возвращаемого значения. Если вы компилируете код для SSE2, то это добавляет две инструкции в цепочку зависимостей и вычисления могут выполняться втрое дольше! В большинстве случаев такие задержки вполне допустимы, но во внутреннем цикле негативный эффект может быть весьма значительным.

Если вы компилируете для платформы x87, то преобразование в тип double ничего не стоит, а вот обратное преобразование затратно – настолько затратно, что некоторые оптимизирующие компиляторы выбрасывают это преобразование, а в результате можно получить КРАЙНЕ НЕОЖИДАННЫЕ результаты – например, CalcCircumference( r ) == CalcCircumference( r ) вернет false!

Сцена третья


Студент: Спасибо, учитель. Честно говоря, я не знаю, что такое SSE2 и x87, но я вижу, насколько элегантным становится код, когда типы согласованы. Это настоящая поэзия. Я буду использовать константу одинарной точности. Как вам вот это?

float CalcCircumference3(float d)
{
    return d * 3.14159265358979323846f;
}

Преподаватель: Да, превосходно! Символ «f» в конце константы все меняет. Если бы вы посмотрели на сгенерированный машинный код, вы бы поняли, что этот вариант намного компактнее и эффективнее. Однако у меня есть замечания к стилю. Не кажется ли вам, что этой загадочной константе не место внутри функции? Даже если это число Пи, значение которого вряд ли изменится, лучше присвоить константе имя и поместить в заголовочный файл.

Сцена четвертая


Студент: Спасибо. Вы объясняете все очень доходчиво. Я помещу строку кода ниже в общий файл заголовка и буду использовать ее в своей функции. Так нормально?

const float pi = 3.14159265358979323846f;

Преподаватель: Да, отлично! С помощью ключевого слова «const» вы указали, что переменная не должна и не может быть изменена, кроме того, ее теперь можно поместить в заголовочный файл. Но, боюсь, теперь нам придется углубиться в некоторые тонкости определения областей видимости в C++.

Объявив pi с ключевым словом const, вы получите в качестве бонуса эффект ключевого слова static. Для целочисленных типов это нормально, но если вы имеете дело с другим типом данных (число с плавающей точкой, массив, класс, структура), память под вашу переменную может быть выделена отдельно в каждой единице трансляции, которая включает в себя ваш заголовочный файл. В некоторых случаях у вас в итоге будет несколько десятков или даже сотен экземпляров переменной типа float и ваш исполняемый файл будет неоправданно большим.

Сцена пятая


Студент: Вы шутите? И что делать?

Преподаватель: Да, мы пока далеки от идеала. Вы можете повесить на объявление константы атрибут __declspec(selectany) или __attribute __(weak), для того чтобы VC++ и GCC, соответственно, поняли, что достаточно сохранить одну из многочисленных копий этой константы. Но поскольку мы с вами находимся в идеалистическом мире науки, я настаиваю на применении стандартных конструкций C++.

Сцена шестая


Студент: То есть примерно так? С помощью constexpr из C++11?

constexpr float pi = 3.14159265358979323846f;

Преподаватель: Да. Теперь ваш код идеален. Конечно, VS 2013 не сможет его откомпилировать, потому что не знает, что делать с constexpr. Но вы всегда можете воспользоваться набором инструментов Visual C++ Compiler Nov 2013 CTP либо последней версией GCC или Clang.

Студент: А #define можно использовать?

Преподаватель: Нет!

Студент: А, к черту все это! Лучше я стану бариста.

Сцена седьмая


Студент: Стоп, я кое-что припоминаю. Это же просто! Вот как будет выглядеть код:

mymath.h:
extern const float pi;
mymath.cpp:
extern const float pi = 3.14159265358979323846f;

Преподаватель: Точно, в большинстве случаев это будет верное решение. Но что если вы работаете над DLL, как внешние функции будут обращаться к mymath.h в вашей DLL? В таком случае вам придется обеспечить экспорт и импорт этого символа.

Проблема в том, что правила для целочисленных типов абсолютно другие. Целесообразно и рекомендуется добавить в заголовочный файл C++ следующее:

const int pi_i = 3;

Число Пи здесь указано недостаточно точно, но дело в том, что целочисленные константы в заголовочных файлах не требуют выделения памяти в отличие от остальных констант. Чем такое отличие обусловлено, не совсем понятно, но чаще всего это и не важно.

О том, что значит «static» в «const», я узнал несколько лет назад, когда меня попросили выяснить, почему одна из наших ключевых библиотек DLL вдруг прибавила в весе 2 МБ. Оказывается, в заголовочном файле был массив констант, и мы получили тридцать копий этого массива в DLL. То есть иногда это все же имеет значение.

И да, я по-прежнему считаю, что #define — ужасный выбор в данном случае. Может быть, это еще не самое худшее решение, но мне оно совершенно не нравится. Однажды я столкнулся с ошибками компиляции, вызванными объявлением pi с помощью #define. Приятного мало, скажу я вам! Замусоривание пространства имен — вот главная причина, почему следует избегать #define, насколько это возможно.

Заключение


Не знаю точно, какой урок мы извлекли из всего этого. Суть проблемы, которая возникает, когда мы объявляем в заголовочных файлах константу типа float или double либо структуру или массив констант, ясна далеко не всем. В большинстве серьезных программ из-за этого возникают дубликаты статических констант, и иногда они неоправданно большого размера. Полагаю, constexpr может избавить нас от этой проблемы, но у меня нет достаточного опыта его использования, чтобы знать наверняка.

Я сталкивался с программами, которые были на сотни килобайт больше своего «реального» размера — и все из-за массива констант в заголовочном файле. Я также видел программу, в которой в конечном счете оказалось 50 копий объекта класса (плюс еще по 50 вызовов конструкторов и деструкторов), потому что этот объект класса был определен как тип const в заголовочном файле. Иначе говоря, тут есть над чем подумать.

Вы можете увидеть, как это происходит с GCC, загрузив тестовую программу отсюда. Соберите её с помощью команды make, а затем выполните команду objdump -d constfloat | grep flds, чтобы найти четыре инструкции чтения со смежных адресов в сегменте данных. Если вы хотите занять больше пространства, добавьте в header.h следующее:

const float sinTable[1024] = { 0.0, 0.1, };

В случае с GCC прирост составит 4 КБ на одну запись преобразования (исходный файл), то есть исполняемый файл вырастет на 20 КиБ, даже если к таблице ни разу никто не обращается.

Как обычно, операции над числами с плавающей точкой связаны со значительными трудностями, но в данном случае, как мне кажется, в этом виновата слишком медленная эволюция языка С++.

Что еще почитать по теме:


VC++: как избежать дублирования и как понять, что дублирования не избежать

У компилятора в VC++ 2013 Update 2 появился параметр /Gw, который помещает каждую глобальную переменную в отдельный контейнер COMDAT, позволяя компоновщику выявлять и избавляться от дубликатов. Иногда такой подход помогает избежать негативных последствий объявления констант и статических переменных в заголовочных файлах. В Chrome такие изменения помогли сэкономить около 600 КБ (подробности). Частично такой экономии удалось добиться (сюрприз!) путем удаления тысячи экземпляров twoPiDouble и piDouble (а также twoPiFloat и piFloat).

Однако в VC++ 2013 STL есть несколько объектов, объявленных как static или const в объявлении класса, которые /Gw не может удалить. Все эти объекты занимают по одному байту, но в итоге набегает свыше 45 килобайт. Я сообщил разработчикам об этой ошибке и получил ответ, что в VC++ 2015 она была исправлена.

По просьбе автора делимся ссылкой на оригинал здесь
Проголосовать:
+123
Сохранить: