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