>> [Играет музыка]
>> ДАГ Lloyd: Указатели, вот мы здесь.
Это, вероятно, будет наиболее трудная тема
что мы говорим о в CS50.
И если вы читали что-нибудь о указателей
прежде чем может быть немного запугать вдаваясь в этом видео.
Это правда указатели позволяют вам возможность
чтобы, возможно, испортить очень плохо, когда вы
Для работы с переменными и данными, и вызывая ваша программа к краху.
Но на самом деле они действительно полезны и они позволяют нам действительно отличный способ
для передачи данных и обратно вперед между функциями,
что мы в противном случае не в состоянии сделать.
>> И так, что мы на самом деле хочу сделать здесь поезд
Вы иметь хорошую указатель дисциплины, так что вы можете эффективно использовать указатели
чтобы сделать ваши программы, которые намного лучше.
Как я уже сказал указатели дают нам разные способ передачи данных между функциями.
Теперь, если вы помните из ранее видео, когда
мы говорим о Переменная сфера, я упомянул
что все данные, которые мы пройти между Функции в С передаются по значению.
И я не мог использовать, что Термин, что я имел в виду там
было то, что мы передаем копии данных.
Когда мы передать переменную в функцию, мы на самом деле не передавая переменную
функции, не так ли?
Мы передавая копию что данные функции.
Функция делает то, что он будет и он вычисляет некоторое значение,
и, возможно, мы используем это значение когда он дает его обратно.
>> Был одним исключением это правило передаче по значению,
и мы вернемся к тому, что, что немного позже в этом видео.
Если мы используем указатели вместо использования переменных,
или вместо использования переменных Сами или копии переменных,
Теперь мы можем перейти переменные вокруг между функциями по-другому.
Это означает, что если мы сделаем изменение в одной функции,
что изменение будет на самом деле взять эффект в ином функции.
Опять же, это то, что мы не могли сделать ранее,
и если вы когда-нибудь пытались поменять местами Значение двух переменных в функции,
Вы заметили, эту проблему вроде подкрадывается, верно?
>> Если мы хотим, чтобы поменять X и Y, и мы передать их функции под названием подкачки,
внутри функции своп Переменные сделать валютные ценности.
Человек становится два, два становится , но мы на самом деле не
ничего изменить в оригинале Функция, в вызывающей.
Потому что мы не можем, мы только работы с их копий.
С указателями, хотя, мы можем на самом деле проходят X и Y в функцию.
Эта функция может сделать что-то с ними.
И эти переменные значения может реально изменить.
Так что вполне изменение наша способность работать с данными.
>> Прежде чем мы углубимся в указатели, я думаю, что это стоит
принимая несколько минут до вернуться к основам здесь.
И есть посмотрим, как Работы памяти компьютера
потому что эти две темы идут на самом деле довольно взаимосвязаны.
Как вы, наверное, знаете, на вашем компьютере
у вас есть жесткий диск или возможно, твердотельный накопитель,
своего рода место для хранения файлов.
Это, как правило, где-то в окрестность 250 гигабайт
, может быть, пару терабайт сейчас.
И это, где все ваши Файлы в конечном счете, жить,
даже когда ваш компьютер выключен выключен, вы можете включить его обратно на
и вы найдете ваши файлы есть снова, когда вы перезагрузите систему.
Но диски, как жесткий диск, с жесткими, или твердотельный накопитель, твердотельного накопителя,
просто место для хранения.
>> Мы не можем на самом деле ничего общего с данные, которые на жестком диске,
или твердотельным накопителем.
Для того, чтобы реально изменить данных или переместить его вокруг,
у нас есть, чтобы переместить его ОЗУ, оперативное запоминающее устройство.
Теперь ОЗУ, у вас есть много меньше в вашем компьютере.
Вы можете иметь где-то в окрестность 512 мегабайт
если у вас есть старый компьютер, , может быть, два, четыре, восемь, 16,
возможно, даже немного Более того, гигабайт оперативной памяти.
Так вот гораздо меньше, но это где все летучие данных существует.
Вот где мы можем что-то изменить.
Но когда мы переходим наш компьютер выключен, все данные в оперативной памяти разрушается.
>> Так вот почему мы должны иметь жесткий диск для более постоянного места ней,
так, что она будет exists- он действительно плохо, если мы каждый раз
Оказалось наш компьютер выключен, каждый Файл в нашей системе был уничтожен.
Так мы работаем внутри оперативной памяти.
И каждый раз, когда мы говорим о памяти, в значительной степени, в CS50,
мы говорим о памяти, а не на жестком диске.
>> Поэтому, когда мы переместить вещи в память, она занимает определенное количество пространства.
Все типы данных, которые мы работаем с
взять разные количество пространства в памяти.
Таким образом, каждый раз, когда вы создать целое переменная, четыре байта памяти
отведены в оперативной памяти, чтобы вы может работать с этим числом.
Вы можете объявить число, изменить его, назначить его
до величины 10 увеличенным одной, так далее и так далее.
Все, что должно произойти в Оперативной памяти, и вы получите четыре байта
для работы с для каждого целое число, вы создаете.
>> Каждый персонаж вам создать получает один байт.
Вот только, сколько пространства необходимо хранить символ.
Каждый поплавок, реальная Количество, получает четыре байта
если это не двойной точности с плавающей точкой
число, которое позволяет есть более точные или более цифр
после десятичной точки без потери точности,
которые занимают восемь байт памяти.
Длинные жаждет, действительно большие числа, также принимать восемь байт памяти.
Сколько байт памяти у строки занимают?
Ну давайте булавку в этом вопросе сейчас, но мы вернемся к нему.
>> Итак, вернемся к этой идее памяти как большой массив байт размером ячеек.
Вот и все, что есть, это просто огромный массив ячеек,
как и любой другой массив, который вы знакомы с и посмотреть,
кроме каждый элемент один байт.
И так же, как массив, каждый элемент имеет адрес.
Каждый элемент массива имеет индекс, и мы
можно использовать этот индекс, чтобы сделать так называемый произвольного доступа в массиве.
Мы не должны начать на начало массива,
перебора каждый один ее элемент,
чтобы найти то, что мы ищем.
Мы можем только сказать, я хочу, чтобы добраться до 15-элемент или 100-стихия.
А можно просто в тот номер и получить значение, которое вы ищете.
>> Аналогично каждая локация в памяти имеет адрес.
Так ваша память может искать что-то подобное.
Вот очень мало кусок память, это 20 байт памяти.
Первые 20 байт, потому что мой адресов есть на дне
0, 1, 2, 3, и так на всем пути до 19.
И когда я заявляю, переменных и когда я начинаю работать с ними,
система собирается установить в сторону некоторое пространство для меня
В этой памяти для работы с моими переменных.
Так что я мог бы сказать, символ C равна капитал Х. А что случится?
Ну система будет отложите для меня одного байта.
В этом случае выбрал номер байта четыре байта по адресу четырех,
и он собирается хранить заглавная буква Н в там для меня.
Если я говорю, то скорость INT предел равен 65, это
собирается выделить четыре байт памяти для меня.
И это будет относиться к тем, четыре байта, как единое целое
потому что то, что мы работаем с представляет собой целое число здесь.
И это будет хранить 65 там.
>> Теперь уже я вроде говорю вам немного лжи,
правильно, потому что мы знаем, что компьютеры работают в двоичной системе.
Они не понимают, обязательно, что столица Н
или то, что 65 есть, они только понять бинарные, нули и единицы.
И так на самом деле, что мы там хранить
не буква Н, и число 65, но скорее двоичные представления
его, что выглядеть кое-что как это.
И в частности в контекст целой переменной,
он не собирается просто плевать его в, он не собирается рассматривать его как один четыре
байт кусок обязательно, это на самом деле происходит
чтобы рассматривать его как один байт четырех кусков, которые могли бы выглядеть следующим образом.
И даже это не совсем верно либо,
из-за чего-то под названием порядок байт, который мы не
собирается получить в настоящее время, но если вам интересно, о,
Вы можете прочитать на немного и большой порядок байт.
Но ради этого аргумента, ради этого видео,
давайте предположим, что, в То,, как число 65 будет
быть представлены в память на каждой системе,
хотя это не совсем верно.
>> Но давайте на самом деле просто получить избавиться от всех бинарных полностью,
и думать только о качестве H и 65, это намного проще,
думать о нем, как что в человеческом существе.
Ладно, так оно и кажется, может быть, немного случайным, что моя система I've-
не дать мне байт 5, 6, 7, и 8 для хранения целое число.
Там причина для этого тоже, что мы не сможем получить в прямо сейчас, но достаточно
сказать, что то, что Компьютер делает здесь
Вероятно, это хороший ход с его стороны.
Чтобы не дать мне память, что это обязательно спиной к спине.
Несмотря на то, что это собирается сделать это сейчас если я хочу, чтобы получить другую строку,
называется фамилия, и я хочу, положить Ллойда там.
Я собираюсь необходимо установить один характер, каждая буква, что это
будет требовать один характер, один байт памяти.
Так что, если я мог бы поставить Ллойда в моей массива как это я довольно хорошо идти, верно?
Чего не хватает?
>> Помните, что каждая строка мы работаем с в С заканчивается обратной косой черты нулевой,
и мы не можем опустить, что здесь, либо.
Мы должны отложить один байт памяти для хранения, что таким образом мы
знаете, когда наша строка закончилась.
Итак, еще раз это соглашение из, как вещи
появляются в мощи памяти немного случайным,
но на самом деле, как большинство систем разработаны.
Для выстроить их по мультипликаторам из четырех человек, по причинам, снова
что мы не должны попасть в прямо сейчас.
Но это, так достаточно сказать, что после этих трех строк кода,
это то, что память может выглядеть.
Если мне нужно ячеек памяти 4, 8 и 12, чтобы держать мои данные,
это то, что моя память может выглядеть.
>> И только быть особенно педантичный вот, когда
мы говорим о памяти адреса, как правило, мы
сделать это, используя шестнадцатеричные обозначения.
Так почему бы нам не превратить все это от десятичной шестнадцатеричной форме
только потому, что, как правило, это как мы называем памятью.
Таким образом, вместо того, чтобы быть от 0 до 19, что мы имеем нулевой
х от нуля до нуля x1 три.
Те 20 байт памяти, что мы Иметь или мы смотрим на на этом изображении
Прямо здесь.
>> Таким образом, все, что было сказано, давайте отойти от памяти на секунду
и обратно к указателям.
Вот самое главное помнить
как мы начали работать с указателями.
Указатель ничего более адреса.
Я скажу это снова, потому что это то, что важно,
указатель ничего более адреса.
Указатели адреса в местах в памяти, где переменные жить.
Зная, что она становится, надеюсь, немного легче работать с ними.
Другое дело, мне нравится чтобы сделать, это есть своего рода
диаграмм визуально представляющий то, что происходит с различными строк кода.
И мы будем делать это пару раз в указатели,
и когда мы говорим о динамической распределение памяти, а также.
Потому что я думаю, что эти диаграммы могут быть особенно полезны.
>> Так что, если я говорю, например, INT к в моем коде, что происходит?
Ну что же происходит в основном в Я получаю память отведенных для меня,
но я даже не хотел бы думаю об этом, как, что, я
нравится думать о нем, как ящик.
У меня есть окно, и это цвета зеленый, потому что я
может поставить целые числа в зеленые коробки.
Если бы это был персонаж, которого я может иметь синий ящик.
Но я всегда говорю, если я создаю коробка, которая может держать целые
что коробка окрашена в зеленый цвет.
И я беру постоянный маркер и я пишу к на стороне.
Так у меня есть коробка под названием K, в котором я могу положить целые числа.
Поэтому когда я говорю Int K, это что происходит в моей голове.
Если я говорю, к равна пяти, что я делаю?
Ну, я ставлю пять в коробке, правильно.
Это довольно просто, если Я говорю INT к, создать окно под названием K.
Если я говорю, к равна 5, поставил пять в поле.
Надеюсь, что это не слишком много прыжком.
Вот где дела идут немного интересно, хотя.
Если я говорю, INT * рк, хорошо, даже если я не знаю, что это неизбежно означает,
это явно есть что-то сделать с целым числом.
Так что я собираюсь покрасить это поле зеленый иш,
Я знаю, что есть что-то сделать с целым числом,
но это не само по себе целое, потому что это INT звезда.
Там что-то немного отличается о нем.
Так участие целое х, но в противном случае это
не слишком отличается от то, что мы говорили.
Это коробка, ее получили ярлык, это носить ярлык рк,
и он способен холдинга INT звезды, все, что это такое.
Они что-то делать с целыми числами, ясно.
Вот последняя строка, хотя.
Если я говорю, рк = & K, эй, что только что произошло, верно?
Так что это случайное число, казалось бы, случайные Количество, выкинут в коробке.
Все, что есть, рк получает адрес к.
Так я придерживаюсь, где к живет в памяти, его адрес, адрес его байт.
Все, что я делаю, я говорю это значение то, что я собираюсь
положить в моей коробке под названием рк.
И потому, что эти вещи Указатели и потому ищет
в строке, как нулевой х восемь нулей с семи четырех восемь
два ноль, вероятно, не очень значимым.
Когда мы, как правило визуализировать указатели, мы на самом деле сделать это в качестве указателей.
Рк дает нам информацию мы должны найти K в памяти.
Так в основном рк имеет стрелку в нем.
И если мы ходим длину этой стрелкой, представьте себе,
это то, что вы можете ходить по, если мы ходить вдоль стрелки,
на самом кончике этого стрелки, мы будет найти место в памяти
где к жизни.
И, что очень важно, потому что как только мы знаем, где живет к,
мы можем начать работать с данными внутри этом месте памяти.
Хотя мы получаем маленький бит впереди себя сейчас.
>> Так что указатель?
Указатель является элемент данных которого значение адрес памяти.
Это было то, что ноль ноль восемь х вещи происходит, это было адрес памяти.
Это было место в памяти.
И тип указателя описывает вид
данных, которые вы найдете в что адрес памяти.
Так что это INT звезда часть правый.
Если я следовать, что стрелка, это собирается привести меня к месту.
И, что место, что я найдете там в моем примере,
зеленый цвета коробка.
Это целое число, это то, что я найдете, если я иду на этот адрес.
Тип данных для Указатель описывает то, что
Вы найдете по этому адресу памяти.
Так вот действительно здорово вещь, хотя.
Указатели позволяют перейти переменные между функциями.
А на самом деле передать переменные и не пройти их копии.
Потому что, если мы точно знаем, где в памяти, чтобы найти переменную,
мы не должны сделать копию это, мы можем просто пойти в это место
и работать с этой переменной.
Таким образом, в сущности указателей рода из сделать компьютерную среду
намного больше, как в реальном мире, верно.
>> Так вот аналогия.
Давайте предположим, что у меня есть ноутбук, справа, и он полон заметок.
И я бы хотел, чтобы вы обновите его.
Вы это функция, которая Обновления отмечает, право.
В пути мы были работает до сих пор, то, что
происходит, вы будете принимать мой ноутбук, Вы идете в магазин, копирования,
вы будете делать ксерокопию каждая страница записной книжки.
Вы оставить свой ноутбук обратно на моем столе, когда вы закончите,
вы будете идти и вычеркнуть вещи в моем ноутбук, который устарели или не так,
и тогда вы будете проходить обратно мне стопку страниц Xerox
что является точной копией моего ноутбука с изменения, которые вы внесли в него.
И в тот момент, это до меня, как вызывающая функция, как абоненту,
чтобы решить ваши заметки и интегрировать их обратно в моем блокноте.
Таким образом, есть много шагов участие здесь, прямо.
Как это не было бы лучше, если я просто говорю, эй, вы можете
обновить ноутбук для мне, вручить вам мой ноутбук,
и вы берете вещи и буквально пересечь их
и обновлять свои записи в блокноте.
А потом дать мне свой ноутбук обратно.
Это вроде того, что указатели позволяют сделать,
они делают это окружение много более нравится, как мы работаем в реальности.
>> Все права, так вот что указатель, давайте поговорим
о том, как указатели работают в C, и как мы можем начать работать с ними.
Таким образом, есть очень простой указатель в С называется нулевой указатель.
Нулевой указатель указывает на ничего.
Это, вероятно, кажется, что это на самом деле не очень полезная вещь,
но, как мы увидим Чуть позже на тот факт,
что это нулевой указатель существует на самом деле очень может пригодиться.
И всякий раз, когда вы создаете указатель, а вы не установите его значение immediately-
пример установки его значение сразу
будет несколько слайдов назад где я сказал рк равна & K,
рк получает адрес K, поскольку мы увидим, что это значит,
мы увидим, как код, который shortly- если мы не установите его значение на что-то
смысл сразу, Вы должны всегда
установить указатель, чтобы указать на нуль.
Вы должны установить это, чтобы указать на нет.
>> Это очень отличается от просто оставить значение, как это
а затем возможность объявления Указатель и только при условии,
это нуль, потому что это редко правда.
Таким образом, вы всегда должны устанавливать значение указателя
до нуля, если вы не установите его значение чтобы что-то значимое немедленно.
Вы можете проверить, является ли значение указателя в является недействительным с помощью оператора равенства
(==), Так же, как вы сравните любое целое число значения или символьные значения, используя (==)
также.
Это особый вид постоянной значение, которое можно использовать для тестирования.
Так что это было очень просто указатель, нулевой указатель.
Другой способ создания указатель является извлечение
адрес переменной вы уже создали,
и вы делаете это с помощью & Добыча адрес оператора.
Который мы уже видели ранее в первом примере схемы я показал.
Так что, если х является переменной, что мы уже создали целого типа,
то и х является указателем на целое число.
и Х означает помните, и собирается извлечь адрес вещи справа.
А так как указатель это просто адрес, чем и х является указателем на целое число
значение которого, где в памяти х жизней.
Это адрес Х.
Так и х является адрес х.
Давайте еще один шаг дальше и подключить к чему-то
Я ссылался на в предыдущем видео.
Если обр массив двойников, то и обр квадратная скобка я является указателем
в два раза.
ХОРОШО.
обр квадратную скобку я, если обр массив двойников,
Затем обр квадратную скобку я это I-й элемент этого массива,
и & обр квадратную скобку я где в памяти я-й элемент обр существует.
>> Так в чем же смысл здесь?
Массивы имя, значение из всей этой вещи,
является то, что имя массива является на самом деле сам указатель.
Вы работали с указателями вдоль всего
каждый раз, когда вы использовали массив.
Запомнить на примере по области определения переменной,
в конце видео я представляю пример, где мы имеем функцию
называется множество INT и Функция называется множество массив.
И ваша задача, чтобы определить, или нет, или то, что
ценности, которые мы распечатанные конец функции,
В конце основной программы.
>> Если вы помните из этого примера или если вы смотрели видео,
Вы знаете, что, когда вам-вызов Набор INT эффективно ничего не делает.
Но вызов, чтобы установить массив делает.
И я вроде умалчивается, почему что было на то время.
Я просто сказал, хорошо это массив, это специальное, вы знаете, есть причина.
Причина в том, что массив-х Название на самом деле просто указатель,
и есть этот особый Синтаксис квадратная скобка, что
сделать вещи намного лучше работать.
И они делают идею о указатель много менее пугающим,
и вот почему они вроде из представленных в этом пути.
Но на самом деле массивы просто указатели.
И вот почему, когда мы внесли изменения в массиве,
когда мы прошли массив в качестве параметра на функцию или в качестве аргумента
к функции, содержимое массива фактически изменили в обоих вызываемого абонента
и в вызывающей функции.
Какой для каждого другого вида переменная, которую мы видели, было не так.
Так что это просто что-то, чтобы держать в ум, когда вы работаете с указателями,
является то, что имя Массив на самом деле указатель
на первый элемент этого массива.
>> ОК, так что теперь у нас есть все эти факты, давайте продолжать идти, правильно.
Почему мы заботимся о где-то живет.
Ну, как я уже сказал, это довольно Полезно знать, где что-то живет
так что вы можете пойти туда и изменить его.
Работа с ней и на самом деле есть вещь, которую вы
хочу сделать с этой переменной эффекта отбора, и не вступили в силу на некоторых копии.
Это называется разыменования.
Мы идем к ссылке и мы меняем значение там.
Так что, если у нас есть указатель, и это называется шт, и это указывает на характер,
то можно сказать, * * ПК и ПК является Имя того, что мы найдем, если мы идем
на адрес ПК.
То, что мы найдем там персонаж и * шт как мы обращаемся к данным на что
место нахождения.
Таким образом, мы могли бы сказать, что-то вроде * шт = D или что-то подобное,
и это означает, что что бы ни был на адреса памяти компьютера,
любого характера ранее там, в настоящее время D, если мы говорим * PC = D.
>> Так вот мы идем снова некоторые странные вещи С, право.
Таким образом, мы видели ранее * как то часть с типом данных,
и в настоящее время он используется в немного другой контекст
для доступа к данным на месте.
Я знаю, это немного запутанным и что на самом деле часть этого целого
как, почему указатели имеют эту мифологию вокруг них как настолько сложны,
это своего рода проблемы синтаксиса, честно.
Но * используется в обоих контекстах, и как часть имени типа,
и мы увидим, немного позже еще что-то, тоже.
И сейчас это разыменовать оператор.
Так он идет к ссылке, это доступ к данным
на месте указателя, и позволяет манипулировать по своему желанию.
>> Теперь это очень похоже на посещения вашего соседа, право.
Если вы знаете, что Сосед живет, вы
не болтаться с вашим соседом.
Вы знаете, случается, знаю, где они живут,
но это не значит, что силу того, что знания
Вы взаимодействующих с ними.
Если вы хотите, чтобы взаимодействовать с ними, Вы должны пойти в их доме,
Вы должны пойти туда, где они живут.
И как только вы это сделаете, то вы можете взаимодействовать
с ними так же, как вы хотели бы.
И точно так же с переменными, Вы должны пойти в их адрес
если вы хотите, чтобы взаимодействовать их, Вы не можете просто знать адрес.
И то, как вы идете на адреса использовать *, оператор разыменования.
Что вы думаете произойдет если мы будем пытаться разыменовать
указатель, значение которого равно нулю?
Напомним, что нуль указатель указывает ничего.
Так что, если вы попробуете и разыменования ничего или перейти к адресной ничего,
что вы думаете происходит?
Ну, если вы догадались сегментации вина, вы были бы правы.
Если вы попробуете и разыменования пустой указатель,
Вы страдаете сегментации вина. Но ждать,
не говорю вам, что если вы не собираетесь
чтобы установить значение вашего указатель на что-то значимое,
Вы должны установить на нуль?
Я сделал, и на самом деле сегментация неисправность рода хорошее поведение.
>> Вы когда-нибудь объявили переменную и не сразу присваивается его значение?
Таким образом, вы просто сказать Int х; Вы не на самом деле присвоить его ни к чему
а затем позже в коде, Вам распечатать значение х,
имея до сих пор не назначен его ни к чему.
Часто вы получите нулю, но иногда вы
может получить случайное число, и Вы понятия не имеете, где он пришел.
Точно могу вещи произойдет с указателями.
Когда вы объявляете указатель INT * рк например,
и вы не назначить его значение, Вы получаете четыре байта для памяти.
Каковы бы ни были четыре байта памяти система может
обнаружите, что есть некоторые значимые ценности.
И, возможно, было то там уже, что
не больше не нужен другой Функция, так что вы просто должны
все данные там.
>> Что делать, если вы пытались сделать разыменование некоторые адрес, который вы don't- было
уже байты и информации в там, что теперь в указатель.
Если вы попробуете и разыменования указателя этого, Вы могли бы возиться с какой-то памяти
что вы не намерены возиться со всем этим.
И в самом деле вы могли бы сделать что-то действительно разрушительным,
как сломать другую программу, или сломать другую функцию,
или сделать что-то, что вредоносный Вы не намерены делать вообще.
И вот почему это на самом деле хорошая идея
установить свои указатели на нуль, если вам не установлен их что-то осмысленное.
Это, вероятно, лучше на Конец дня для вашей программы
к краху, то для того, чтобы сделать то, что винты вверх
другая программа или другая функция.
Такое поведение, возможно, даже менее идеальным, чем просто сбой.
И вот почему это на самом деле хорошая привычка
чтобы попасть в ваши установить указатели до нуля, если вы не установите их
к значимому стоимости немедленно, значение, что вы знаете
и что вы можете безопасно выполнять разыменования.
>> Итак, давайте вернемся в настоящее время и взглянуть в общем синтаксисе ситуации.
Если я говорю, INT * р ;, что я только что сделал?
Что я сделал это.
Я знаю, что величина р является адрес потому что все указатели только
адреса.
Я могу разыменования р используя оператор *.
В этом контексте здесь, в самом топ вспомнить * является частью типа.
Int * тип данных.
Но я могу разыменования р, используя оператор *,
и если я делаю так, если я иду по этому адресу, то, что я найду по этому адресу?
Я найду целое.
Так INT * р в основном говоря, р представляет собой адрес.
Я могу разыменования р и если Я, я найду целое
в этом месте памяти.
>> ОК, так что я сказал, что был еще один раздражающая вещь со звездами
и вот где, что раздражающая вещь со звездами есть.
Вы когда-нибудь пытались объявить несколько переменных одного и того же типа
на той же строке кода?
Таким образом, для второго, делать вид, что линии, код, который я на самом деле у них там в зеленый
там нет, и он просто говорит INT х, у, г ;.
То, что это будет сделать, это на самом деле создать три целочисленные переменные для вас,
одна называется х, одна называется у, и один называется г.
Это способ сделать это без того, чтобы разделить на три линии.
>> Вот где звезды получают раздражает снова, хотя,
потому что на самом деле * часть является из имени типа и части
имени переменной.
И поэтому, если я говорю, INT * рх, ру, рг, то, что я на самом деле получить указатель на целое
называется ПВ и два целых числа, ру и рг.
И это, наверное, не то, что мы хотим, это не хорошо.
>> Так что, если я хочу, чтобы создать несколько указателей на той же линии, того же типа,
и звезды, то, что я на самом деле нужно чтобы сделать, это сказать INT * годовых, * PB * шт.
Теперь только что сказал, что и теперь говорю вам это,
вы, вероятно, никогда не будет делать этого.
И это, наверное, хорошо, честно говоря, потому что вы можете случайно
опустить звезду, что-то вроде этого.
Это, вероятно, лучше, может быть, объявить указатели на отдельных линиях,
но это просто еще один из тех раздражающих синтаксиса
вещи со звездами, которые делают указатели так трудно работать.
Потому что это просто синтаксический это беспорядок, вы должны работать через.
С практикой это делает действительно стала второй натурой.
Я до сих пор делают ошибки с ним еще после программирования в течение 10 лет,
так что не расстраивайтесь, если что-то случится Вам, это довольно распространено, честно говоря.
Это действительно своего рода недостаток синтаксиса.
>> ОК, так что я вроде обещал что мы вновь
понятие, как большая строка.
Ну, если я сказал вам, что Строка, мы действительно вид
лежал к вам все время.
Там нет тип данных называется строка, а на самом деле я
упомянул об этом в одном из наших Первые видео на типы данных,
что строка была типом данных, был создан для вас в CS50.h.
Вы должны #include CS50.h для того, чтобы использовать его.
>> Ну строка на самом деле просто псевдоним на что-то
называется символ *, а указатель на символ.
Ну указатели, напомним, просто обращается.
Так что размер в байтах строки?
Ну, это четыре или восемь.
И почему я говорю четыре или восемь, потому что есть на самом деле
зависит от системы, если вы используете CS50 язь, голец * является размер гольца
* Восемь, это 64-разрядная система.
Каждый адрес в памяти 64 бита.
Если вы используете прибор CS50 или с помощью любой 32-битной машины,
и вы слышали, что термин 32-бит машина, что 32-битные машины?
Ну это просто означает, что каждый адрес в памяти длиной 32 бита.
И так 32 бит на четыре байта.
Таким образом, символ * четыре или восемь байт в зависимости от вашей системы.
И в самом деле какие-либо типы данных, и указатель на любых данных,
типа, так как все указатели только адреса, четыре или восемь байт.
Итак, давайте вернемся в этом График и давайте заключить
это видео с небольшого упражнения здесь.
Так вот схема мы остановились с в самом начале видео.
Так что теперь, если я говорю * рк = 35?
Так что это значит, когда я говорю, * рк = 35?
Возьмите второй.
* рк.
В контексте здесь, является * разыменовать оператор.
Поэтому, когда разыменовать оператор используется,
мы идем в адрес указал по рк, и мы меняемся, что мы находим.
Так * рк = 35 эффективно делает это на картинке.
Так что это в основном синтаксически идентичны в том, сказал K = 35.
>> Еще один.
Если я говорю, INT м, я создаю новая переменная называется м.
Новое поле, это потому, что зеленый ящик он собирается провести целое,
и это помечены м.
Если я говорю, M = 4, я ставлю число в этом поле.
Если скажем рк = & м, как же это изменение схема?
Рк = & м, вы вспомнить, что в И оператор делает или как называется?
Помните, что некоторые & имя переменной это адрес переменной имя.
Итак, что мы хотим сказать, рк получает адрес м.
И так эффективно, что происходит, схема, что рк дольше без очков
К, но указывает на м.
>> Опять указатели очень сложно работать
и они занимают много практика, а потому, что
их способности, чтобы позволить вам для передачи данных между функциями
и на самом деле есть те Изменения вступят в силу,
получать вашу головку вокруг это очень важно.
Это, вероятно, является самым сложным Эту тему мы обсудим в CS50,
но значение, что вам получить от использования указателей
значительно перевешивает осложнений которые приходят от обучения их.
Так что я желаю вам лучше удачи узнать о указатели.
Я Дуг Ллойд, это CS50.