Переменные и типы

Четыре строки, и в них весь разговор: слова float и bool, объявление с начальным значением и без него, две переменные через запятую, слово const и буква f после числа. Разберём по порядку.

У переменной есть три вещи:

• имя – по нему вы к ней обращаетесь (t);
• тип – какого рода значение в ней лежит (float);
• значение – само число, его можно менять сколько угодно.

Строка, в которой переменная появляется впервые, называется объявлением. Возьмём такую:

bool flying = false;   // тело ещё летит?

Тип bool – самый простой из всех: в переменной этого типа может лежать только одно из двух значений, правда (true) или ложь (false). Третьего нет. Такой переменной отвечают на вопрос, у которого есть только «да» и «нет»: тело ещё летит? в мишень попали? пауза нажата?

Значит, строка читается так: «заводим переменную flying, в ней будет правда или ложь, и прямо сейчас кладём туда ложь» – полёт ещё не начался.

Начальное значение можно и не задавать: float t; заводит ячейку, но что в ней лежит – неизвестно, пока туда что-нибудь не положат. В Task_0 время обнуляется в момент запуска полёта, а не при объявлении. Читать переменную, в которую ещё ничего не клали, нельзя – получите случайный мусор, и ошибку эту искать тяжело: программа не падает, просто считает не то.

Однотипные переменные объявляют через запятую: float x, y; – это ровно то же самое, что две отдельные строки.

Знак = здесь не равенство из математики, а приказ «положи справа налево». Поэтому строка t = t + dt; не абсурд, а совершенно обычное дело: возьми то, что лежит в t, прибавь dt и положи обратно в t.

Тип говорит две вещи: что за значение лежит в переменной и сколько места оно занимает. Чем больше место, тем шире диапазон – и тем больше памяти уходит, если таких чисел миллион.

Целые числа. Отличаются только размером ячейки:

Есть ещё long: на Windows он такой же, как int, а на Linux вдвое больше. Из-за этой разницы его стараются не использовать – если нужно длинное целое, пишут long long.

Что будет, если число не поместится: оно не «обрежется до максимума», а перескочит на другой конец диапазона. Прибавили единицу к самому большому int – получили самое маленькое отрицательное. Программа при этом не ругается никак.

Дробные числа. Тоже два размера:

«Около семи значащих цифр» – это не про диапазон, а про точность: float спокойно хранит и 0.000001, и 300000000, но записать в него 1.2345678901 целиком не получится, лишние цифры пропадут. Для школьной физики семи цифр хватает с запасом: измерений такой точности всё равно не бывает.

Правда или ложь. Тип bool, значения true и false, третьего нет.

Типов в C++ больше, но для вычислений в наших задачах хватает трёх: int для счётчиков и количеств, float для физических величин, bool для переключателей. float, а не double, по двум причинам: точности хватает, а библиотека курса и графики работают именно с float – взяли бы double, пришлось бы на каждой строке переводить одно в другое.

Тип выбирается один раз при объявлении и потом не меняется. Это не формальность: от типа зависит, как машина будет считать. Дальше вы увидите, что одна и та же запись 1 / 2 даёт разный ответ для целых и дробных чисел.

Слово const перед типом означает: значение задаётся один раз и дальше не меняется. Попытка присвоить такой переменной что-то другое – ошибка компиляции, программа просто не соберётся.

Через const записывают постоянные величины задачи:

const float g = 9.8f;            // ускорение свободного падения
const int   TARGET_POINTS = 50;  // из скольких точек мишень
const float HIT_RADIUS = 0.15f;  // радиус попадания, м

Зачем, если можно просто не менять? Во-первых, у числа появляется имя: HIT_RADIUS в формуле понятнее, чем 0.15f. Во-вторых, поменять его придётся в одном месте, а не в пяти – и компилятор проследит, что случайно вы его не тронули. Имена постоянных принято писать заглавными: так их видно среди обычных переменных.

Исключение – величины, у которых есть привычное обозначение в физике: ускорение свободного падения остаётся g с маленькой буквы. Заглавная G в формулах занята гравитационной постоянной, и спутать их дороже, чем отступить от соглашения об именах. Общее правило то же, что и для переменных: код должен читаться как формула на доске.

Число 0.0 без буквы для компилятора – это double, «дробное число двойной точности». Оно занимает вдвое больше памяти, чем float, и считается медленнее.

Запись 0.0f говорит: это именно float. Если написать float t = 0.0;, программа соберётся, но компилятор может предупредить о потере точности – он сужает double до float.

Практическое правило: если переменная объявлена как float, пишите f у всех чисел, которые в неё попадают.

Выбор между int и float кажется мелочью, пока не выберешь неправильно.

Пусть в задаче про маятник длина стержня объявлена так:

int l = 1;

Пока длина равна метру, всё работает. Но стоит взять задание «постройте зависимость периода колебаний от длины» – и оказывается, что длину надо менять плавно, а int дробных значений не хранит: 1.5 в нём станет 1, 1.9 тоже станет 1. График получится ступенчатым, а половина точек – одинаковыми, и всё из-за одного слова в объявлении.

Правило: если величина физическая – она float. Целыми бывают счётчики, номера и количества: сколько частиц, номер шага, сколько точек рисовать.

Кроме чисел программа работает с текстом: название окна, подпись оси, имя графика, название ползунка, имя файла, сообщение об ошибке. Текст называется строкой, и в C++ для него есть свой полноценный тип – std::string. Строку можно объявить, сравнить, сложить с другой, спросить её длину, передать в функцию и вернуть из неё – всё то же самое, что и с числами:

std::string name = "Тело";
std::string label = name + " (эксперимент 2)";   // сложение строк
int n = label.size();                            // сколько символов

Чтобы такие переменные работали, в начале файла нужна строка:

#include <string>

В наших задачах строки чаще всего не хранят в переменных, а пишут прямо в вызове функции – потому что подпись известна заранее и меняться не будет:

add_float_param("Угол броска", 30.0f);        // подпись ползунка
set_plot_axes(PLOT, "x, м", "y, м");          // подписи осей
add_plot_line(PLOT, ground_x, ground_y, "Земля", GREEN, 1.f);

Важно, что строка здесь не только подпись для человека. По ней библиотека находит нужную величину: ползунок заведён строкой "Угол броска", и расчёт получает его значение по той же строке.

add_float_param("Угол броска", 30.0f);          // в main
alpha = get_float_param("Угол броска");         // в расчёте

Связывает эти две строки кода только совпадение текста, буква в букву. Опечатка – не ошибка компиляции: программа соберётся, запустится, напишет в консоль предупреждение «параметр не найден» и молча подставит ноль. Тело улетит не туда, а причина будет выглядеть как ошибка в физике.

Именно поэтому имя графика в Task_0 вынесено в переменную – оно встречается в тексте программы почти десять раз:

const char* PLOT = "Полёт тела";

const char* – доставшийся от языка C способ записать строку, которая не меняется. Здесь он равноправен: можно было объявить и так –

std::string PLOT = "Полёт тела";

все функции библиотеки принимают такую строку точно так же.

Имя переменной пишется латиницей, без пробелов, не начинается с цифры. Регистр важен: alpha и Alpha – разные переменные.

В физических задачах принято называть переменные так же, как величины в формулах: t, v, alpha, dt. Это правильно: код и формула на доске должны читаться одинаково. А вот a1, x2, tmp через неделю не расшифруете и вы сами.

Теперь четыре строки из начала читаются целиком: заводим дробные t, x и y, переменную flying со значением «ложь» и постоянную g, равную 9.8.

Следующий шаг – научиться считать: записывать формулы так, чтобы машина посчитала именно то, что вы имели в виду.