Вы когда-нибудь пользовались указателями?

Язык C++ и программы, написанные на нём, являются очень быстрыми. C++ является очень низкоуровневым языком, что позволяет программистам работать с памятью на самом фундаментальном уровне и тем самым значительно оптимизировать программы.

Одним из инструментов для работы с памятью являются указатели.

Указатель – это числовое значение, обозначающее адреса какого-то значения в памяти.

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

Указатели в C++ с точки зрения типов данных указывают на объекты разных типов, а не на байты. То есть существуют указатели на числа, на символы, на строки, и всё это разные указатели.

Вот, как можно объявить указатель:

// Указатель на объект типа int
int* pointer;
// «pointer» переводится как «указатель»

Чтобы указатель хранил какой-то адрес, а не, как мы говорим, белиберду, его нужно инициализировать.

Для этого нужно получить адрес объекта, на который должен указывать указатель:

int number = 3;
int* pointer = &number;

Значок & означает, что мы берём адрес объекта (числа), который хранится в переменной number.

Мы можем вывести указатель, и тогда выведется адрес переменной number:

cout << pointer; // -> 0x7ffee4981224

Вывелся адрес в шестнадцатеричном виде. Это тоже число, и мы можем его перевести в десятичный вид (140732733592100), но обычно адреса записываются именно в шестнадцатеричном виде, ведь так удобнее.

Теперь мы можем работать с переменной number через этот указатель:

// *pointer - это получение указываемого объекта
// т.е. получение переменной number
cout << *pointer << endl  // -> 3
     << number   << endl; // -> 3

// Изменяем number через указатель
*pointer = 13;

cout << *pointer << endl  // -> 13
     << number   << endl; // -> 13

Таким образом мы продолжаем работать с переменной number, просто используем для этого её адрес, а не саму переменную.

Грамотное использование указателей в коде позволяет значительно ускорять программы. Однако для этого требуется достаточно знаний об указателях.

Нееет! Опять эти сложные и непонятные указатели!

На самом деле указатели – это весьма простая абстракция, которая ложится на фундаментальную работу памяти и немного на систему типов данных в C++. Чтобы хорошо знать указатели, нужно погрузиться в работу памяти, и именно это обычно вызывает все трудности при изучении.

В нашем курсе по C++ для продвинутых, который сейчас находится в разработке, будет освещена тема указателей, так что каждый сможет научиться работать с ними.

#интересные_факты

Вы когда-нибудь слышали о const в C++?

С помощью спецификатора const мы можем пометить, что объявляемая переменная не будет изменяться. Так любая операция изменения переменной приведёт к ошибке.

Сокращение const происходит от constant - постоянный

Мы должны указывать слово const в типе данных переменной:

const int number = 15;
const float pi = 3.14;

Можно сказать, что number имеет тип const int, а pi – const double. Слово const влияет на поведение значения переменной, а не самой переменной, поэтому оно является частью типа данных.

const int length = 13;

length = 15; // ошибка
// нельзя изменять const переменные

cin >> length; // тоже ошибка
// cin присваивает length новое значение

// а это не вызовет ошибки
int new_length = length + 2;
// здесь мы не меняем значение length

При объявлении const переменных их обязательно сразу инициализировать:

const int number; // Ошибка
// нужно сразу инициализировать const переменную

Мы можем выносить некоторые "магические числа" в отдельные переменные, улучшая читаемость кода.

float radius;
cin >> radius;

float length = 6.28 * radius
cout << length;

Людям, которые плохо знакомы с математикой, может быть неясно, что такое 6.28. Ведь это просто магическое число, которое, казалось бы, не имеет никакого смысла.

Лучше переписать этот код через const переменные:

const float pi = 3.14;

float radius;
cin >> radius;

float length = 2 * pi * radius
cout << length;

Теперь сразу становится понятно, что этот код вычисляет длину окружности через радиус.

Вынося "магические числа" в const переменные, мы можем значительно увеличить понятность кода.

Спецификатор const позволяет:

• Защитить переменные от случайного изменения
• Увеличить понятность кода засчёт вынесения магических чисел
• Прояснять назначение некоторых переменных, например, численных идентификаторов

Также const переменные могут быть оптимизированы компилятором. В C++ при автоматической оптимизации кода часть операций производится на этапе компиляции, поэтому const переменные иногда могут быть удалены из скомпилированной программы.

#интересные_факты

Любые радикальные, странные и возможно фриковые изменения в любом продукте требуют тестирования.

Я чутка изменил насыщенность и яркость цветов и принёс новое цветовое выделение в урок «Массивы в циклах».

Попробуйте заново для себя пройти несколько заданий из этого урока с новым цветовым выделением.

Нам нужен ваш фидбек!

Если вдруг вам не понравится новое цветовое выделение или наоборот вы будете в восторге, напишите нам об этом! Можно в комментариях к этому посту, можно на платформе Stepik, главное – выскажите любые ваши мысли по этому поводу.

Если вам очень понравится, весь курс по основам и весь следующий курс будут иметь такое выделение в текстах заданий.

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

Вы же помните, какие есть математические функции в C++?

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

Функция abs возвращает модуль числа или его абсолютное значение

При вызове abs(5) она вернёт 5, а при вызове abs(-13) она вернёт 13. Абсолютно любое переданное ей отрицательное число теряет знак и становится положительным.

Однако существуют в C++ ограничения, которые лежат немного выше этой функции…

Этот пример кода как раз столкнётся с этими ограничениями:

int number = -2147483648;

cout << abs(number);

Разве целые числа – это только int?

В C++ есть знакомый нам тип данных int. Он позволяет хранить целые числа. Числа типа int занимают 4 байта, из-за чего int вмещает числа в диапазоне от -2,147,483,648 до 2,147,483,647.

А что если мне нужны большие числа? Или нужно сэкономить потребляемую память?

Для этого мы можем применить модификаторы short и long к типу int:

• Тип short int (или просто short) занимает 2 байта, хранит числа в диапазоне от -32,767 до 32,768
• Тип long int (или long) тоже занимает 4 байта (чаще всего)
• Тип long long int (или long long) занимает 8 байт

У типа long long диапазон от -9,223,372,036,854,775,808 до 9,223,372,036,854,775,807. Он позволяет хранить невероятно большие числа.

Эти диапазоны получены по формулам -2^n и 2^n-1, где n - количество бит в типе данных (для int это 32).

Если нужно работать с очень большими целыми числами, можно использовать тип long long, но он занимает в 2 раза больше памяти, чем int.

Если нужно экономить память, то отличным выбором будет short int, хотя у него более узкий диапазон чисел.

Например:

long long big_number = 42436356;
big_number = big_number * 26183 + 1984;

cout << big_number;
// Вывод: 1111111111132

Если бы мы использовали тип данных int, вывелось бы число -1,285,418,553. Это не то, что должно получиться при вычислениях, хотя похоже, что результат и не может влезть в тип int.

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

Простой пример:

// Наибольшее число для типа short
short number = 32768;
number += 1;

cout << number << endl;
// Вывод: -32767

// Слишком большое число
int population = 8000000000;

cout << population;
// Вывод: -589934592

Мы записали в переменные number и population слишком большие числа и произошло переполнение. В итоге получилось не то, что мы хотели.

#интересные_факты

Если вернуться к этому примеру кода, то теперь понятно, почему число при вызове abs не изменяется.

На самом деле функция abs возвращает число 2,147,483,648. Просто оно выходит за пределы диапазона чисел в типе int (на 1 больше, чем наибольшее возможное число).

Поэтому в переменную записывается число -2,147,483,648 – результат переполнения. Так уж совпало, что результатом переполнения для числа 2,147,483,648 становится число -2,147,483,648.

Вот так и пользуйся этими функциями...
А потом «Откуда ошибки? Почему у меня undefined behavior?»