Этот курс является продолжением курса "Основы разработки на C++: жёлтый пояс". Основная цель курса — научить писать на С++ эффективный код. Кроме того рассмотрены некоторые возможности С++, которые не попали в предыдущие курсы. В курсе рассмотрены: - макросы - шаблоны классов - принципы оптимизации кода - эффективное использование потоков ввода/вывода - оценки сложности алгоритмов - модель памяти в С++ - эффективное использование линейных контейнеров (vector, deque, list, string) - move-семантика - введение в многопоточное программирование Кроме того, в курсе продемонстрировано, как, пользуясь знаниями только "Белого", "Жёлтого" и "Красного" поясов, разработать свой собственный профайлер. Так же, как и в предыдущих курсах, в конце вас ждёт финальный проект. Было бы странно в курсе от Яндекса не попросить вас создать свою поисковую систему! Именно этим вам и предстоит заняться в финальной задаче. Курс разработан ведущими специалистами Яндекса и преподавателями Школы анализа данных. За их плечами – годы разработки сервисов поиска, рекламы и инфраструктуры. Кроме того в подготовке заданий участвовали 1. Сотрудники Яндекса: - Алексей Аверченко - Даниил Петров - Константин Меренков - Алексей Зобнин 2. Выпускники «Жёлтого пояса по С++»: - Борис Егоров - Ольга Марчевская 3. Сотрудник Института проблем информатики РАН Олег Яковлев В создании урока «Шаблоны классов» принимал участие преподаватель Белого и Жёлтого «поясов» Евгений Парамонов.
Введение в арифметику указателей
Loading...
来自 Moscow Institute of Physics and Technology 的课程
Основы разработки на C++: красный пояс
52 个评分
Moscow Institute of Physics and Technology
52 个评分
课程 3（共 5 门，Specialization Искусство разработки на современном C++）
从本节课中
Модель памяти в C++
与讲师见面
Полднев Антон Вячеславович
Яндекс
Шишков Илья Ивановичкандидат технических наук
Яндекс
Сейчас от нашего вектора нет никакой пользы, потому что мы
только можем задать количество объектов в нем,
создать их и удалить.
Мы даже не можем никак обратиться по индексу к этим элементам.
Вот давайте мы, собственно, это и сделаем.
Давайте добавим в наш вектор возможность обращаться к отдельным элементам.
Для этого напишем в нем оператор квадратные скобки,
который принимает индекс и зададимся вопросом: а как же нам этот оператор реализовать?
Потому что у нас есть указатель - data, вот он,
это указатель на первый элемент нашего вектора. Давайте рассмотрим это на слайде.
У нас есть указатель data, он указывает на первый элемент вектора,
а мы хотим уметь обращаться не только к первому элементу,
но и произвольному, ко второму, к третьему и так далее.
Как же нам сделать такую вещь? Как нам отступить от этого элемента один элемент так,
чтобы получить указатель вот на этот? Или там, допустим, отступить от этого элемента 2,
чтобы получить указатель вот на этот элемент.
Это делается очень просто - прибавлением числа к указателю,
то есть если есть указатель data, которая указывает на первый элемент вектора, то,
если мы прибавим к data единицу, мы получим указатель на следующий, на второй элемент,
ну и аналогично для других элементов. Третий элемент вектора, это data+2,
а последний элемент, это дата data+size-1.
Таким образом наш оператор доступа по индексу реализуется очень просто.
Мы пишем return, звездочка, data+index.
Давайте мы это скомпилируем, это компилируется, и проверим, что это работает.
Давайте пока заменим стерлинг на Int и допустим, напишем вот так for
(int i=0; i<5; ++i), sv [i] =5-i,
а потом пройдемся по
нашему вектору и выведем значения нашего вектора.
Это компилируется, запускаем, и у нас вывелись числа 5,
4, 3, 2, 1.
То есть мы как раз записали убывающие числа,
начиная с пятерки, и действительно, они у нас записались.
Таким образом, вот такая вот реализация для оператора квадратные скобки,
она прекрасно работает, и мы действительно выполняем прибавляя к указателю число,
мы просто смещаемся к нужному нам элементу вектора.
На что здесь стоит обратить внимание?
Во-первых, смотрите, мы вот здесь,
вот этой командой по сути выделили в кучи пять целых чисел.
Если мы вот здесь попросим вывести,
например, двенадцатый элемент нашего вектора, при том,
что у нас их всего пять,
то наша программа скомпилируется, и даже может отработать.
Вот в данном случае у нас выявилось какое-то непонятное число, т.е.
в процессе работы программы нет никакого...
Сам язык С++ никак не контролирует доступ к данным,
которые мы осуществляем через указатель.
Вот мы сейчас смогли спокойно прочитать число,
которое лежит за границами нашего вектора.
Однако, это не значит, что мы это можем делать всегда.
Давайте, опять же, заменим int на string,
компилируем нашу программу, запустим и увидим, как она благополучно упала.
Так что, несмотря на то, что сам С++ не контролирует доступ,
есть еще операционная система, и вот она иногда реагирует на то,
когда ваша программа лезет не туда.
Собственно, почему со строкой у нас так не получилось?
Ну потому что string это класс,
у него есть какая-то своя внутренняя структура, какие-то внутренние варианты,
и естественно, когда мы пытаемся выводить строку,
мы обращаемся к какой-то случайной памяти, в которой, естественно,
для нас мусор, и там
никакие варианты класса stirng не выполняются и программа, естественно, падает.
Таким образом мы с вами немного познакомились с арифметикой указателей.
Давайте обратим внимание еще на такую вещь.
К указателям можно не только прибавлять целые числа, но и вычитать их.
Семантика здесь та же самая. Мы точно также отступаем в памяти на заданное
количество объектов, просто в другую сторону.
Вот на слайде приведен пример, у нас есть указатель p, который указывает на.
Третий элемент в наборе из пяти элементов типа T и тогда
указатели p+1 и p+2 указывают в одну сторону,
на эти элементы, а р-1 и р-2 указывают в другую сторону на эти элементы.
Хорошо, давайте рассмотрим еще один момент. Мы с вами говорили,
что локальные переменные функции хранятся на стэке.
Стэк это тоже область оперативной памяти, поэтому у этих переменных тоже
должен быть адрес должен быть адрес в оперативной памяти, где они размещены.
И этот адрес, его достаточно легко получить с помощью оператора &.
Вот давайте рассмотрим пример: у нас есть функция main,
в ней есть переменная x типа int, равная 5. И есть переменная у,
которой являются указателем на int и она хранит в себе адрес переменной x. И вот значит,
вы можете видеть как это выглядит схематично, т.е. переменная y является указателем
на переменную x. Она указывает на ту область памяти, где переменная x хранится.
Давайте посмотрим на это [inaudible] , пока что перестанем пользоваться нашим вектором,
объявим переменную x типа int, и объявим переменную y типа указатель на int
и присвоим ей адрес переменной x. Дальше напишем *у=7,
то есть присвоим объекту, на которую указывает переменная y,
значение 7 и выведем переменную x. Как вы думаете,
что у нас сейчас появится на экране, конечно же семерка, потому что переменная y
указывает на переменную x, мы туда, в ту область памяти,
где размещена переменный x, записали семерку, и естественно, когда мы вводим переменную x,
мы читаем из этой области памяти и получаем семерку.
Хорошо, давайте еще немного поиграемся с указателями на локальные переменные,
а также с арифметикой указателей.
Смотрите, давайте мы объявим 3 переменные, переменную a,
которая пусть будет равна 43, переменную b, которая будет ровна, например,
71 и переменную c,
которая будет равна 89.
Дальше мы сделаем вот что,
мы выведем на экран значение, который лежит по такому указателю.
Мы берем указатель на переменную b и вычитаем из него единицу.
И берем опять же указатель на переменную b и прибавляем к нему единицу.
Компилируем, запускаем, 43 89.
Ведь правда, вот это 43 очень похоже на вот это 43.
А вот это 89 очень похоже на вот это 89.
Этот пример, как раз таки,
еще раз демонстрирует, как работает арифметика указателей.
Мы взяли указатель на int, вот он,
адрес b,
b это переменная типа int,
поэтому &b, это указатель на int.
[inaudible] вычли из него единицу,
то есть мы переместились на один int,
скажем так, влево и попали в переменную а, которая равна 43.
Здесь мы взяли адрес, где лежит переменная b, сместились на один int в другую сторону
и попали в переменную c, в которой лежит значение 89.
Отлично, продолжаем развлекаться с указателями на переменные
и давайте посмотрим еще вот какой пример. Мы с вами говорили,
в самом начале этого блока,
про то, что локальные переменные функции размещаются в стэке, в стэковых фреймах.
Давайте заведем функцию f, объявим ей, пусть вот, перенесем в нее.
вот эти наши переменные a и b. Здесь ставим переменную c,
а вот здесь напишем вот такой цикл.
Это будет цикл по i от нуля до двадцати. Здесь мы будем делать вот что,
мы будем вызывать функцию f, потом будем выводить,
вернее, даже не выводить,
будем запоминать переменные x, значения по указателю адрес c-i.
И будем выводить. Компилируем, компилируется,
запускаем и вот, у нас вывелись какие-то числа.
Давайте обратим внимание на 14,15 строки.
Здесь записаны числа 43 и 71. 43, 71. Давайте поменяем эти числа,
снова запустим нашу программу, и в 14, 15 строке мы увидим 434 и 711.
Что мы с вами только что сделали?
Мы функцией main запустили функцию f, она запустилась,
выделила на стэке фрейм, разместила в этом фрейме свои переменные a и b,
а дальше мы, мы не знаем точно, где на стэке эти переменные лежат, но где-то они лежат.
Поэтому мы пробуем разные смещения относительно своей переменной c и пытаемся найти
стэковый фрейм функции f. И мы это сделали, вот на четырнадцать int-ов, скажем так,
влево от переменной c лежит переменная a. И на пятнадцать int-ов лежит переменная b,
то есть мы смогли из функции с
прямо залезть в стэковый фрейм функции f после того, как она отработала.
Мы в самом начале смотрели на то, что когда функция отработала,
то с ее стэковым фреймом ничего не происходит,
он не затирается никак, мы просто переносить вершину стэка.
Вот мы сейчас в этом убедились. Ну и здесь мог возникнуть вопрос,
а почему мы на каждую итерацию цикла вызываем функцию f. Ну дело в том,
что когда мы пополняем вывод в поток вывода, то,
как вы уже знаете, вот эти строки разворачиваются в вызов перегрузок операторов,
то есть в вызов других функций.
Эти функции, естественно, затирают стэковый фрейм функции f. Поэтому мы
перед каждым смещением пробуем,
эту функцию еще раз запускаем, чтобы ходить именно в ее стековый фрейм,
а не во фрейм вывода в поток.
Прекрасно, и у нас остался еще один важный, пример касающийся арифметики указателей.
Мы говорили, что указатель,
это адрес в памяти, и даже видели, что его целочисленное значение.
Давайте объявим переменную, назовем ее d, которая равна адресу переменной
c и объявим переменную e, равную d+1 и выведем эти переменные в консоль,
заодно вы увидите, что указатели можно выводить в консоль.
Компилируем, запускаем и мы видим два шестнадцатеричных числа,
которые вылились в консоль. Если мы вычтем одну из другого,
прямо вот я даже открою калькулятор, если мы вычтем из сорока шестнадцатеричный 3c,
у нас получится четыре. Теперь возьмем и допустим, прибавим 3.
Компилируем, запускаем, снова из 48 шестнадцатеричных вычитаем 3c.
Получилось с, или в десятичной системе - 12. Что этим примерам хочется показать?
Что когда мы прибавляем к указателю число,
это разворачивается в то, что реально, вот это значение, целочисленные,
которое хранится в указателе, оно изменяется на вот это вот число,
умноженное на размер типа, на который указывает наш указатель.
Вот здесь не зря было четыре, потому что это int.
у int-а на шестидесяти четыре битовых платформах размер 4.
Даже, например, мы можем поменять все на 64t,
запустить нашу программу, снова пойти в калькулятор, теперь вычесть из 50 38.
Получается 24, то есть три умножить на 8. 8 байт, это размер типа 64t.
Таким образом вы теперь понимаете, что собственно, лежит под арифметикой указателей,
и не только с логической точки зрения, что значит прибавление числа к указателю,
но и как оно отражается на конкретном значении,
конкретном адресе, который хранится в указателе.
Это все, что касается арифметики указателей за одним исключением.
Давайте вернемся, мы вообще в этом
видео писали оператор квадратные скобки для нашего вектора.
Давайте мы в него вернемся и скажем, что такой синтаксис, он достаточно громоздкий,
тут нужен скобки ставить, звездочку ставить. Это неудобно.
Ему, этому синтаксису, есть эквивалент, мы можем просто к указателю добавить в
квадратных скобках тот индекс и это развернется в обращение,
это вернет нам ссылку на объект, который на заданный индекс отстоит от нашего указателя.
Давайте мы это скомпилируем. Правда, чтобы это проверить,
нужно шаблон наш применить. Вот оно компилируется, отлично.
Давайте подведем итоги этого большого видео.
Мы узнали, что прибавление числа x к указателю t изменяет его адрес
на x умножить на размер типа t,
при этом мы получаем возможность обратиться к объекту типа t,
отстоящему на заданном расстоянии от нашего указателя.
А кроме того мы узнали, что оператор &, который
пишется слева от имени переменной, позволяет получить адрес этой локальной переменной.
Мы прекрасно посмотрели на то, что при обращении к указателям
не происходит никакого контроля доступа со стороны именно С++,
ну и наконец в финале мы увидели, что запись звездочка и p+5,
как на слайде, эквивалентно просто р [5].
