[Powered by Google Translate] [Преглед] [квиз 0]
>> [Lexi Рос, Томи MacWilliam, Лукас Freitas, Јосиф Ong] [Универзитетот Харвард]
>> [Ова е CS50.] [CS50.TV]
>> Еј, сите.
Добредојдовте на преглед сесија за 0 квиз, што се одржува оваа среда.
Она што ние ќе правиме вечерва, Јас сум со 3 други TFS,
и заедно ние ќе одиме преку преглед на она што ние го направивме во текот досега.
Тоа нема да биде 100% сеопфатен, но тоа треба да ви даде подобра идеја
на она што веќе го имаат долу и што уште треба да учат пред средата.
И се чувствуваат слободни да ја подигне својата рака со прашања како што се случува заедно,
но имајте на ум дека ние, исто така, ќе имаат малку време на крајот-
ако добиеме преку со неколку минути да се резервни да направите општи прашања,
па задржи тоа во предвид, и така ние ќе започне во почетокот со недела 0.
>> [Квиз 0 Преглед!] [Дел 0] [Lexi Рос] Но, пред да го направите тоа, ајде да зборуваме за
логистика на квизот.
>> [Логистика] [квиз се одвива во средата 10/10 наместо на предавање]
>> [(Види http://cdn.cs50.net/2012/fall/quizzes/0/about0.pdf за детали)] Таа е на Среда, 10 Октомври.
>> Тоа е оваа среда, а ако одите на оваа адреса тука,
кој исто така е достапна од CS50.net-Има еден линк до него-
можете да видите информации за тоа каде да одат врз основа на
Вашето презиме или училиште припадност, како и
тоа кажува за што точно квизот ќе ги покрие и видови на прашања кои си оди за да се добие.
Имајте на ум дека, исто така, ќе имаат шанса да ги видиш за квиз во делот,
па вашите TFS треба да се оди над некои пракса проблеми,
и тоа е уште една добра шанса да се види каде се уште треба да учат за квизот.
Ајде да започне на почетокот со Бајти битови 'N'.
Се сеќавам на еден малку е само 0 или 1,
и бајт е збирка од 8 на оние делови.
Ајде да погледнеме во оваа колекција на парчиња токму тука.
Ние треба да бидеме во можност да дознаам колку делови има.
Каде што смета има само 8 од нив, осум 0 или 1 единици.
И бидејќи има 8 бита, тоа е 1 бајт,
и ајде да го претворат во хексадецимален.
Хексадецимален е база на 16, и тоа е прилично лесно да конвертирате
број во бинарен, што е она што е, на број во хексадецимално.
Сите што го правиме е гледаме групи од 4,
и ние ги претворат во соодветните хексадецимално цифра.
Започнуваме со право на-повеќето група на 4, па 0011.
Тоа ќе биде еден 1 и една 2, па заедно што го прави 3.
А потоа нека се погледне на други блок 4.
1101. Тоа ќе биде еден 1, едно 4, и еден 8.
Заедно дека ќе биде 13, што го прави Д
И ние ќе се запамети дека во хексадецимално не само оди од 0 до 9.
Одиме 0 до F, па после 9, 10 одговара на,
11 до Б, и така натаму каде F е 15.
Еве 13 е D,
така да го претворите во децимална сите што го правиме е ние всушност
третираат секоја позиција како моќта на 2.
Тоа е една 1, едно 2, нула 4S, нула 8s, еден 16, и така натаму,
и тоа е малку тешко да се пресмета во вашата глава, но ако одиме на следниот слајд
можеме да видиме одговорот на тоа.
>> Во суштина ние ќе карши право назад кон лево,
и ние сме множење секоја цифра од соодветните моќта на 2.
И запомнете, за хексадецимален ние означуваат овие броеви со 0x на почетокот
па ние не го мешаме со децимален број.
Продолжува, ова е ASCII табелата,
и она што го користи ASCII за е да ги мапира од ликови на нумерички вредности.
Запомни во pset криптографијата ние направивме широка употреба на ASCII табелата
со цел да се користат разни методи на криптографијата,
на Цезар и на шифра Vigenère, за претворање на различни букви
во низа според клучните дадени од страна на корисникот.
Да ги погледнеме малку на ASCII математика.
Гледајќи "P" + 1, во знак форма што би била П,
и се сеќавам дека '5 '≠ 5.
И како точно би конвертирате помеѓу оние 2 форми?
Тоа не е всушност премногу тешко.
Со цел да се добие 5 ние одземе '0 '
бидејќи постојат 5 места меѓу '0 'и 5.'
Со цел да се оди на друг начин ние само додадете 0,
па тоа е вид на како редовни аритметика.
Само сети се дека кога нешто има наводници околу неа тоа е карактер
и на тој начин одговара на вредноста во ASCII табелата.
Движат во повеќе општи компјутерски науки теми.
Ние научив што алгоритам е и како ние ги користиме програмирање
да се имплементираат алгоритми.
Некои примери на алгоритми се нешто навистина едноставно како
проверка дали бројот е дури и или непарни.
За таа сеќавам ние современи бројот со 2 и проверете дали резултатот е 0.
Ако е така, тоа е дури. Ако не, тоа е чудно.
И тоа е пример на еден навистина основни алгоритам.
>> А малку повеќе вклучени еден е бинарна пребарување,
кои ние ќе одиме во текот подоцна во текот на преглед на сесија.
И програмирање е термин кој се користи за полагање на алгоритам
и конвертирање на тоа да се кодот на компјутер може да се прочита.
2 примери на програмирање е нула,
што е она што ние го сторивме во недела 0.
Иако ние не, всушност тип надвор на код, тоа е начинот на спроведување
овој алгоритам, кој е печатење на броеви 1-10,
и тука ние го стори истото во C програмскиот јазик.
Овие се функционално еквивалентни, само напишани во различни јазици или синтакса.
Ние тогаш дознал за рационален израз,
и рационален е вредност тоа е точно или неточно,
и тука често рационален израз
оди во внатрешноста на услови, па ако (x ≤ 5),
Па, ние веќе се воспоставени x = 5, така што состојбата се случува да се оцени на true.
И ако тоа е вистина, без оглед кодот е под услов
ќе треба да се оценува од страна на компјутерот, така што стринг ќе се печатат
до стандарден излез, а терминот состојба
се однесува на она што е внатре во заградите на ако изјава.
Се сеќавам на сите оператори.
Запомни тоа е && и | | кога ние се обидуваме да се комбинираат 2 или повеќе услови,
== Не = да се провери дали 2 работи се еднакви.
Запомнете дека = е за доделување додека == е рационален оператор.
≤, ≥, а потоа конечниот 2 се очигледен.
Општ преглед на Булова логика тука.
И рационален израз се исто така важни во петелки,
која ќе одиме над сега.
Учевме за 3 видови на јамки досега во CS50, за, време, и не време.
А тоа е важно да се знае дека додека за повеќето намени
ние всушност може да се користи било кој тип на јамка обично
постојат одредени видови на цели или заеднички обрасци
во програмирање што конкретно се јавите за една од овие петелки
кои го прават тоа на најефикасен или домот да го кодот на тој начин.
Ајде да одиме над она што секој од овие петелки има тенденција да се користи за најчесто.
>> Во за телефонска линија ние обично веќе знаете колку пати сакаме да iterate.
Тоа е она што ние го стави во состојба.
Зашто, i = 0, i <10, на пример.
Ние веќе знаеме што сакаме да направиме нешто 10 пати.
Сега, за време јамка, генерално не мора да значи
знам колку пати сакаме јамка да се кандидира.
Но ние знаеме некој вид на услов што сакаме да
секогаш да биде вистина или секогаш се лажни.
На пример, додека е поставена.
Да речеме дека е Булова променлива.
Иако тоа е вистина ние сакаме кодот да се оцени,
па малку повеќе растеглива, малку поопшта од за телефонска линија,
но секој за телефонска линија, исто така, може да се конвертира време јамка.
Конечно, дали додека петелки, кој може да биде trickiest да се сфати веднаш,
често се користи кога сакаме да се оцени код прво
пред прв пат да се провери состојбата.
Честа употреба случај за не додека јамка
е кога сакате да добиете корисник влез, и знаете дека сакате да побара од корисникот
за влез барем еднаш, но ако тие не ви даде добар влез веднаш
сакате да го задржите барајќи од нив се додека тие ви даде добар влез.
Тоа е најчестата употреба на не додека јамка,
и нека се погледне на актуелната структура на овие петелки.
Тие обично секогаш имаат тенденција да се следат овие модели.
>> На for внатре имате 3 компоненти:
иницијализација, обично нешто како int i = 0 каде што е контра,
состојба, каде што сакаш да го кажеш извршите оваа за јамка се додека оваа состојба се 'уште има,
како јас <10, а потоа конечно, ажурирање, кој е како ние прираст
контра променлива на секоја точка во јамка.
А заеднички нешто да се види дека постои само i + +,
што значи зголемување јас од 1 секое време.
Вие исто така може да се направи нешто како i + = 2,
што значи додадете 2 до јас секој пат кога ќе одам низ јамката.
А потоа го направите ова едноставно се однесува на било код кој всушност работи како дел од циклусот.
И за време јамка, овој пат ние всушност имаат иницијализација надвор од јамка,
Така на пример, да речеме ние се обидуваме да го стори истото вид на јамка што јас само што е опишано.
Ние би рекол int i = 0 пред јамка почнува.
Тогаш можеме да речеме додека јас <10 ​​направите ова,
така што истиот блок од код како порано,
и овој пат ажурирање дел од кодот, на пример, i + +,
всушност оди во внатрешноста на јамка.
И конечно, за направите додека, тоа е слично на време јамка,
но ние треба да се запамети дека кодот ќе ги оценува еднаш
пред состојба се проверува, па тоа го прави многу повеќе смисла
ако се погледне во него, со цел на врвот до дното.
Во направите додека јамка код евалуира дури и пред да се погледне на време состојба,
а додека јамка, се проверува во прв план.
Извештаи и променливи.
Кога сакаме да се создаде нова променлива ние прво ќе сакате да го иницијализира.
>> На пример, int бар иницијализира на променлива бар,
но тоа не го даде вредност, па она што е вредност бар сега?
Ние не знаеме.
Тоа може да биде некои ѓубре вредност што беше претходно зачувани во меморијата таму,
и ние не сакаме да ја користат таа променлива
додека ние всушност го даде вредност,
па ние го прогласи тука.
Тогаш ние се иницијализира да биде 42 подолу.
Сега, се разбира, ние знаеме дека тоа може да се направи една линија, int бар = 42.
Но, само за да се расчисти повеќе чекори што се случуваат,
декларација и иницијализација се случува одделно тука.
Тоа се случува на еден чекор, а следниот, int baz = бар + 1,
оваа изјава подолу, кои постепено baz, па на крајот на овој блок
ако ние требаше да се печати вредноста на baz тоа ќе биде 44
затоа што декларираат и се иницијализира да биде 1> бар,
и тогаш тоа прираст уште еднаш со + +.
Отидовме во текот на овој прилично кратко, но тоа е добро да имаш општо
разбирање на она што се теми и настани.
Ние, главно, го направи ова во нула,
па можете да мислам на теми како повеќе секвенци на кодот
работи во исто време.
Во реалноста, тоа најверојатно не работи во исто време,
но вид на апстрактно можеме да размислуваме за тоа на тој начин.
>> Во почеток, на пример, имавме повеќе sprites.
Тоа може да се извршување на различни кодот во исто време.
Еден може да се шетаат додека другите кажува нешто
во различен дел од екранот.
Настани се уште еден начин на одделување на логиката
помеѓу различните елементи на вашиот код,
и гребење бевме во можност да симулираат настани употребувајќи го објавување,
и тоа е всушност кога ќе примам, а не кога ќе чујам,
но во суштина тоа е начин да пренесува информации
од една фигура на друга.
На пример, можеби ќе сакате да се пренесе од игра,
и кога друг самовила добива повеќе од игра,
тој одговара на одреден начин.
Тоа е важен модел за да се разбере за програмирање.
Само да одиме во текот на основните недела 0, она што го помина во текот досега,
нека се погледне на овој едноставен Ц програма.
Текстот може да биде малку мали од тука, но јас ќе одам над неа навистина брзо.
Ние сме вклучувајќи 2 насловот датотеки на врвот, cs50.h и stdio.h.
Ние потоа дефинирање на постојана наречена граница да биде 100.
Ние потоа спроведувањето на нашата главна функција.
Бидејќи ние не користите командната линија аргументи тука ние треба да се стави празнина
како аргументите за главните.
Гледаме int над главниот. Тоа е враќање тип, па оттука се врати 0 на дното.
И ние сме со користење CS50 библиотека функција се int
да побара од корисникот за влез, а ние се чува во овој променливата x,
па ние прогласи x погоре, и ние да се иницијализира со x = GetInt.
>> Ние тогаш провери да се види дали на корисникот ни даде добар влез.
Ако тоа е ≥ ГРАНИЧНИТЕ ние сакаме да се врати грешка код на 1 и печати порака за грешка.
И конечно, ако корисникот ни даде добар влез
ние ќе плоштад бројот и печати од кои се резултат.
Само за да бидете сигурни дека тие сите хит дома
можете да видите на етикетите на различни делови на код овде.
Јас спомнав константна, насловот датотеки.
О, int x. Бидете сигурни да се запамети дека е локална променлива.
Дека контрасти од една глобална променлива, што ние ќе зборуваме за
малку подоцна во текот на преглед сесија,
и ние се јавувате на библиотека функција printf,
па ако ние не било вклучено stdio.h хедер датотека
ние не ќе биде во можност да се јавите printf.
И јас верувам дека на стрелката што доби отсечени тука е да се покажува кон% d,
која е форматирање стринг во printf.
Таа вели печати ја оваа променлива како број,% d.
И тоа е за недела 0.
Сега Лукас ќе продолжи.
Еј, момци. Моето име е Лукас.
Јас сум сафомор во најдобар куќа на кампусот, Mather,
и јас одам да се зборува малку за недела 1 и 2,1.
[Недела 1 и 2,1!] [Лукас Freitas]
Како Lexi велеше, кога почнавме преведување на вашата кодот од нула до C
една од работите што ги забележав е дека не можете да само
напишете вашиот код и да ја стартувате со користење на зелено знаме веќе.
Всушност, треба да користите некои чекори да направите вашиот C програма
стане извршна датотека.
Во суштина она што го правите кога сте пишување програма е тоа што
Можете Преведете вашата идеја на јазик што го компајлерот може да се разбере,
Значи, кога сте пишување програма во C
она што го правиш е всушност пишување нешто што вашиот компајлерот ќе разбере,
а потоа компајлерот ќе преведе овој код
во нешто што вашиот компјутер ќе се разбере.
>> И Работата е, вашиот компјутер е всушност многу глупава.
Вашиот компјутер може да се разбере 0-ти и 1S,
па, всушност, во првите компјутери луѓето обично програмирани
користење на 0-ти и 1S, но не повеќе, благодарам на Бога.
Ние не треба да се запаметат секвенци за 0-ти и 1S
за за јамка или за некое време јамка и така натаму.
Тоа е причината зошто имаме компајлерот.
Што компајлерот не е основа преведува кодот Ц,
во нашиот случај, на јазик што вашиот компјутер ќе се разбере,
која е предмет код, и компајлерот дека ние сме користење
се нарекува ѕвекот, така што ова е всушност симбол за ѕвекот.
Кога имате програма, што треба да направите 2 работи.
Прво, морате да ги собере својата програма, а потоа ви се случува да се кандидира на вашиот програма.
Да ги собере вашата програма имаш многу опции за да го стори тоа.
Првиот е да се направи ѕвекот оваа апликација
во која програма е името на вашата програма.
Во овој случај можете да видите тие се само велејќи: "Еј, состави мојата програма."
Вие не сте велејќи: "Сакам ова име за мојата програма" или ништо.
>> Втората опција е давање на име за вашата програма.
Може да се каже ѕвекот-о а потоа името што сакате
извршна датотека да се именува како и тогаш оваа апликација.
И исто така можете да прават програма, и да видиме како во првите 2 случаи
Ставив. В, а во третата, ми останува само програми?
Да, вие всушност не треба да се стави. В кога користите направи.
Инаку компајлерот е, всушност, ќе се развикам.
И, исто така, јас не знам дали вие момци се сеќавам,
но многу пати ние исто така се користи-lcs50 или-филмот.
Тоа се нарекува поврзува.
Тоа само кажува на компајлерот дека ќе го искористите овие библиотеки право таму,
па ако сакате да го користите cs50.h вие всушност треба да напишете
ѕвекот оваа апликација-lcs50.
Ако не го сторат тоа, компајлерот нема да знаете
дека сте користење на овие функции во cs50.h.
И кога ќе сакате да се кандидира на вашиот програма ќе имаат 2 опции.
Ако не ѕвекот оваа апликација ќе не даде името на вашата програма.
Мора да го стартувате користење. / A.out.
A.out е стандард име кое ѕвекот дава вашата програма, ако не го даде името.
Инаку си оди за да се направи. / Програмата, ако даде името на вашата програма,
а исто така и ако не се направи програма за името дека програмата се случува да се
веќе се случува да биде програмиран со истото име како датотека c.
Тогаш ние разговаравме за типови на податоци и податоци.
>> Во суштина типови на податоци се иста работа како што е малку кутии кои ги користат
за чување на вредности, па типови на податоци се всушност само како Pokémons.
Тие доаѓаат во сите големини и видови.
Јас не знам дали тоа аналогија прави смисла.
Големината на податоците, всушност, зависи од машина архитектура.
Сите податоци големини што јас ќе одам да покаже тука
се всушност за 32-битна машина, што е случај и на нашата апаратот,
но ако се всушност кодирање вашиот Mac или во Windows, исто така,
веројатно сте ќе имаат 64-битна машина,
па не заборавајте дека податоците големини кои јас ќе одам да покаже тука
се за 32-битна машина.
Првиот што го видовме беше int,
што е прилично јасна.
Можете да го користите int да ја запази цел број.
Ние, исто така, видов карактер, знак.
Ако сакате да го користите писмо или малку симбол ти си веројатно се случува да се користи знак.
А знак има 1 бајт, што значи 8 бита, како Lexi рече.
Во суштина ние имаме ASCII табелата дека има 256
можни комбинации на 0-ти и 1S,
а потоа, кога ќе напишете знак дека ќе се преведе
ликот кој влезови сте број кој го имате во ASCII табелата, како Lexi рече.
Ние исто така имаат плови, кои ние ги користиме за чување на децимални броеви.
Ако сакате да изберете 3,14, на пример, сте ќе треба да се користи плови
или двојно дека има поголема точност.
А плови има 4 бајти.
Двоен има 8 бајти, па само разликата е прецизност.
Ние, исто така имаат долг кој се користи за цели броеви,
и можете да видите за 32-битна машина на int и долго имаат иста големина,
па тоа не е никаква смисла да се користи долго во 32-битна машина.
>> Но, ако сте со користење на Mac и 64-битна машина, всушност долго има големина 8,
па тоа навистина зависи од архитектура.
За 32-битна машина не дава никаква смисла да се користи долго навистина.
И потоа долго долго, од друга страна, има 8 бајти,
па затоа е многу добар, ако сакате да имате подолг број.
И, конечно, имаме низа, што е, всушност, char *,
што е покажувач кон char.
Тоа е многу лесно да се мисли дека големината на низата ќе биде како
бројот на карактери кои имате таму,
но всушност char * себе
има големина од покажувач кон char, што е 4 бајти.
Големина на char * е 4 бајти.
Тоа не е важно дали имате мал збор или буква или ништо.
Тоа ќе биде 4 бајти.
Ние исто така, научив малку за леење,
Па како што можете да видите, ако имате, на пример, програма со која вели
int x = 3, а потоа printf ("% d", x / 2)
ви момци знаат што се случува да се печати на екран?
>> Некој? >> [Студентите] 2.
1. >> 1, да.
Кога ќе го направите 3/2 тоа се случува да се добие 1.5,
но бидејќи ние сме со користење на целобројна тоа се случува да се игнорира децимална дел,
и ви се случува да имаат 1.
Ако не сакате тоа да се случи што можете да направите, на пример,
се прогласи плови y = x.
Тогаш х кои се користат да биде 3 е сега ќе биде 3.000 во y.
А потоа можете да печатите на y / 2.
Всушност, јас треба да имаат 2. таму.
Тоа се случува да се направи 3.00/2.00,
и си оди за да се добие 1.5.
И ние имаме овој 0,2 ѓ само да прашам за 2 децимална единици во децималниот дел.
Ако имате 0,3 ѓ тоа се случува да имаат всушност 1,500.
Ако е 2 тоа се случува да биде 1.50.
Ние, исто така, имаат овој случај.
Ако го направите плови x = 3,14, а потоа можете printf x
сте ќе добие 3,14.
И ако не x = ИНТ на x,
што значи третираат x како int и ќе се печати x сега
ви се случува да имаат 3,00.
Дали тоа има смисла?
Затоа што ти си прв лекување x како цел број, па ти си го игнорира децимална дел,
а потоа сте печатење х.
И, конечно, исто така можете да го направите ова,
int x = 65, а потоа ќе се изјасни за знак c = x,
а потоа доколку ги отпечатите в сте всушност ќе добие
А, значи, во основа она што го правиш тука
е преведување на цел број во лик,
како само ASCII табелата прави.
Ние, исто така зборуваше за математика оператори.
Повеќето од нив се прилично јасна, така +, -, *, /,
а исто така и ние разговаравме за современи, што е остатокот од поделба на 2 броја.
Ако имате 10% 3, на пример,
тоа значи подели 10 од 3, а што е остатокот?
Тоа ќе биде 1, па тоа е всушност многу корисно за многу од програмите.
За Vigenère и Цезар Јас сум прилично сигурен дека сите од вас момци користи МО.
За математика оператори, да бидат многу внимателни при комбинирањето * и /.
>> На пример, ако се направи (3/2) * 2 она што ви се случува да се добие?
[Студентите] 2.
Да, затоа што 3/2, 2 ќе биде 1,5,
но бидејќи правиш операции помеѓу 2 броеви
ти си, всушност само ќе се разгледа 1,
а потоа 1 * 2 ќе биде 2, па да биде многу, многу внимателно
кога го прави аритметички со цели броеви, бидејќи
можете да добиете дека 2 = 3, во тој случај.
И исто така да бидат многу внимателни за предност.
Обично треба користете загради за да бидете сигурни дека знаете што правите.
Некои корисни кратенки, се разбира, е i + + или i + = 1
или со користење + =.
Тоа е истото што го прават i = i + 1.
Можете исто така да го направам - или I - = 1,
која е истото како i = i -1,
нешто што момци користат многу во за петелки, барем.
Исто така, за * ако користите * = а ако не, на пример,
i * = 2 е истото како вели i = i * 2,
и истото за поделба.
Ако го направите I / = 2 тоа е истото како i = i / 2.
>> Сега за функции.
Вие момци дозна дека функции се многу добра стратегија да се спаси код
додека си програмирање, па ако сакате да се изврши истата задача
во кодот повторно и повторно, веројатно ќе сакате да користите функција
само така да не мора да копирате и залепите кодот одново и одново.
Всушност, главната е во функција, а кога ќе ви покаже формат на функција
сте ќе видите дека тоа е многу очигледно.
Ние исто така користиме функции од некои библиотеки,
на пример, printf, GetIn, кој е од библиотеката CS50,
и други функции, како toupper.
Сите тие функции се всушност спроведени во други библиотеки,
и кога ќе се стави оние јаже датотеки во почетокот на вашата програма
ти си велејќи дека може да ми даде код за тие функции
па јас не треба да ги имплементираат од мене?
И исто така можете да напишете своја сопствена функции, па кога ќе почнете програмирање
ќе сфатите дека библиотеки немаат сите функции кои ви се потребни.
За последните pset, на пример, ние напиша подготви, трка, и побара,
и тоа е многу, многу важно да се биде во можност да пишувам функции
бидејќи тие се корисни, а ние ги користите во секое време во програмирање,
и тоа заштедува многу код.
Форматот на функција е оваа.
Имаме враќање тип на почетокот. Што е враќање тип?
Тоа е само кога функцијата ќе се врати.
Ако имате некоја функција, на пример, факториел,
што се случува да се пресмета факториел од цел број,
веројатно дека ќе се врати цел број, исто така.
Тогаш враќање тип ќе биде int.
Printf всушност има враќање тип празнина
затоа што не си се враќа ништо.
Сте само печатење работи на екран
и напуштање на функцијата потоа.
Тогаш го имате име на функција што можете да одберете.
Треба да бидете малку разумен, како не избере име како xyz
или како x2f.
Обидете се да се направи до името што има смисла.
>> На пример, ако тоа е факториел, велат факториел.
Ако тоа е функција што се случува да нацрта нешто, името го нацрта.
И тогаш имаме параметри, кои се викаат исто така аргументи,
кои се како средства кои вашата функција треба
од кодот да се изврши својата задача.
Ако сакате да се пресмета факториел од голем број
веројатно ќе треба да имаат голем број да се пресмета факториел.
Еден од аргументите што ви се случува да имаат е бројот себе.
А потоа тоа се случува да се направи нешто и да се врати вредноста на крајот
освен ако тоа е празнина функција.
Ајде да видиме еден пример.
Ако сакам да пишувам функција која ги сумира сите броеви во низа на цели броеви,
Прво на сите, на враќање тип ќе биде int
бидејќи имам низа од цели броеви.
И тогаш ќе одам да имаат функција име како sumArray,
а потоа тоа се случува да се земе низа себе, да int nums,
и тогаш должината на низата па знам колку броеви морам да резимираме.
Потоа морам да се иницијализира со променлива наречена сума, на пример, на 0,
и секој пат кога ќе видите елемент во низата јас треба да го додадете во неа, толку направив за телефонска линија.
Исто како Lexi рече, ќе се направи int i = 0, I <должина и i + +.
И за секој елемент во низата што го направив сума + = nums [i],
а потоа се вратив сумата, па тоа е многу едноставна, и тоа заштедува многу код
ако сте со користење на оваа функција многу пати.
Тогаш ние се погледне во услови.
Имаме ако, друго, и друго, ако.
Ајде да видиме што е разликата меѓу нив.
Фрлите поглед на овие 2 кодови. Која е разликата меѓу нив?
Првиот е-основа кодови сакате да кажете
Ако бројот е +, -, или 0.
Првиот вели дека ако тоа е> 0, тогаш тоа е позитивно.
Ако тоа е = на 0, тогаш тоа е 0, и ако е <0, тогаш тоа е негативно.
>> А другиот е тоа ако друго ако, на друго место.
Разликата меѓу двете е дека и оваа всушност се случува да
проверете дали> 0, <0 или = 0 три пати,
па ако имаш број 2, на пример, тоа се случува да дојде тука и да кажам
ако (x> 0), и тоа се случува да се каже да, па јас печати позитивни.
Но, иако знам дека тоа е> 0 и тоа нема да биде 0 или <0
Јас сум уште се случува да се направи тоа е 0, тоа е <0,
па јас сум всушност се случува во внатрешноста на IFS дека не треба да
бидејќи јас веќе знам дека тоа нема да се задоволи некој од овие услови.
Може ли да користам ако друго ако, друго изјава.
Тоа во основа вели дека ако x = 0 Се печати позитивни.
Ако не е, јас одам да се, исто така се тестираат ова.
Ако е 2 не одам да го направите тоа.
Во суштина, ако имав x = 2 ќе речеш
ако (x> 0), да, па печати ја оваа.
Сега дека јас знам дека тоа е> 0 и дека тоа задоволни првиот ако
Јас не сум дури и ќе ја извршите оваа код.
Кодот тече побрзо, всушност, 3 пати побрзо, ако се користи ова.
Ние, исто така дознав и и или.
Јас не одам да одат преку овој, бидејќи Lexi веќе разговаравме за нив.
Тоа е само && и | | оператор.
>> Единствено нешто што јас ќе го кажам е да се биде внимателен кога имате 3 услови.
Користете загради, бидејќи тоа е многу збунувачки кога имате состојба
и уште еден или друг.
Користете загради само за да бидете сигурни дека вашата услови смисла
бидејќи во тој случај, на пример, може да се замисли дека
тоа би можело да биде првиот услов и еден или на друг
или 2 условите комбинираат во една и
или третиот, па само да се биде внимателен.
И, конечно, ние разговаравме за прекинувачи.
Прекинувачот е многу корисно кога имате променлива.
Да речеме дека имате променлива како n
кој може да биде 0, 1 или 2, и за секој од овие случаи
сте ќе треба да се изврши една задача.
Може да се каже вклучите променлива, и тоа покажува дека
вредноста тогаш е како value1 Одам да го направите ова,
и тогаш јас се скрши, што значи јас не одам да се погледне во која било од другите случаи
бидејќи ние веќе убеден дека случајот
а потоа value2 и така натаму, и јас исто така може да има стандардно прекинувач.
Тоа значи дека ако тоа не ги задоволи сите случаи кои ги имав
што јас ќе одам да се направи нешто друго, но тоа е опционално.
Тоа е се за мене. Сега ајде да имаат Томи.
Добро, ова ќе биде Недела 3-носталгичната.
Ова се некои од темите што ќе се покриваат, крипто, обемот, низи, итн.
Само брз збор за криптирање. Ние нема да ги нападне овој дом.
>> Ние го сторивме тоа во pset 2, но за квиз бидете сигурни дека знаете разликата
меѓу Цезар шифра и шифра Vigenère,
како и на оние шифри работа и она што тоа е како да го криптирате
и декриптирање на текст со користење на овие 2 шифри.
Запомнете, Цезар шифра едноставно ротира секој карактер од страна на истиот износ,
правење сигурни дека МО со бројот на букви во азбуката.
И шифра Vigenère, од друга страна, пак, ротира секој карактер
со различен износ, па наместо велејќи
секој лик ротира од 3 Vigenère ќе ротираат секој карактер
од различен износ во зависност од некои клучни зборови
каде секоја буква во збор претставува некои различен износ
за да ја ротирате јасен текст од.
Ајде прво да зборуваме за променлива обем.
Постојат 2 различни видови на променливи.
Имаме локални променливи, и овие се случува да се дефинира
надвор од главниот или надвор било функција или блок,
и овие ќе бидат достапни насекаде во вашата програма.
Ако имате функција и во таа функција е време јамка
големата глобална променлива е достапна насекаде.
А локална променлива, од друга страна, е scoped до местото каде што се дефинирани.
>> Ако имате функцијата тука, на пример, имаме оваа функција g,
и во внатрешноста на г постои променлива тука наречен y,
а тоа значи дека тоа е локална променлива.
Иако оваа променлива се нарекува y
и оваа променлива се нарекува y овие 2 функции
немаат поим што меѓусебно локални променливи се.
Од друга страна, се тука и велиме int x = 5,
и ова е надвор од опсегот на било која функција.
Тоа е надвор од опсегот на главните, така што ова е глобална променлива.
Тоа значи дека во внатрешноста на овие 2 функции кога велам х - или x + +
Јас сум пристапува на ист x при овој y и оваа y се различни променливи.
Тоа е разликата помеѓу глобалната променлива и локална променлива.
Што се однесува до дизајнот е во прашање, понекогаш тоа е веројатно подобра идеја
да се задржи променливи локални кога веројатно може
бидејќи има еден куп на глобални променливи може да се добијат навистина збунувачки.
Ако имате еден куп функции сите менување на истото
можеби ќе заборавам што ако оваа функција случајно модифицира оваа глобална,
и оваа друга функција не знае за тоа,
и тоа не добие прилично збунувачки, како можете да добиете повеќе код.
Чување променливи локални кога веројатно може
е само добар дизајн.
Низи, се сеќавам, се едноставно листи на елементи од ист тип.
Внатрешноста на Ки не можат да имаат листа како 1, 2.0, здраво.
Ние едноставно не може да го направи тоа.
>> Кога ќе прогласи низа во C сите елементи мора да бидат од ист тип.
Еве ги имаат низа на 3 цели броеви.
Тука имам должината на низата, но ако јас сум само тоа прогласување во оваа синтакса
каде што прецизира колкав сите елементи се не технички треба оваа 3.
Компајлерот е доволно паметни да дознаам колку е голема низа треба да биде.
Сега кога сакам да се добие или да поставите вредноста на низа
ова е синтакса да го направите тоа.
Ова всушност ќе се измени вториот елемент на низата, бидејќи, се сеќавам,
Нумерирањето започнува од 0, а не на 1.
Ако сакате да ја прочитате таа вредност можам да кажам нешто како int x = array [1].
Или ако сакам да ја постави таа вредност, како што јас го правам овде,
Можам да кажам низа [1] = 4.
Тоа време пристап до елементите од нивниот индекс
или нивната позиција или каде што тие се во низа,
и дека листата започнува од 0.
Ние, исто така може да имаат низи на низи,
и ова се нарекува мулти-димензионална низа.
Кога имаме мулти-димензионална низа
тоа значи дека можеме да имаме нешто како редови и колони,
и ова е само еден начин на визуелизација на овој или размислување за тоа.
Кога имам мулти-димензионална низа што значи јас ќе одам да почнат потреба
повеќе од 1 индекс, бидејќи ако имам мрежа
само велејќи дека она што ред сте во не ни дава број.
Тоа е навистина само ќе ни даде листа на броеви.
Да речеме дека имам оваа низа тука.
Имам низа наречен мрежа, и сакам да кажам дека тоа е 2 редови и 3 колони,
и така ова е еден начин на визуелизација на тоа.
Кога велам дека сакате да го добиете елемент на [1] [2]
тоа значи дека, бидејќи тие се редови, а потоа колони
Одам да скокне до Row 1 од реков 1.
>> Потоа јас ќе одам да дојди до колона 2, а јас одам да се добие вредност 6.
Смисла?
Мулти-димензионални низи, се сеќавам, се технички само низа од низи.
Ние може да има низи од низи од низи.
Ние можеме да Продолжувам да одам, но навистина еден начин да се размислува за
како тоа се поставени и што се случува е да се визуелизира
во мрежа се допаѓа ова.
Кога ќе помине низа на функции, тие се случува да се однесуваме
малку поинаку отколку кога се поминува редовно променливи функции
како поминува еден int или плови.
Кога ќе помине во int или знак или било кој од овие други типови на податоци
ние едноставно се погледне ако функцијата модифицира
вредноста на таа променлива таа промена нема да се пропагира до
на повик функција.
Со низа, од друга страна, тоа ќе се случи.
Ако поминувам во низа за некоја функција и таа функција го менува некои од елементите,
кога ќе се вратам до функцијата што ја нарече
мојата низа е сега се случува да се биде различен, и речник за тоа
е низи се пренесуваат по референца, како што ќе видиме подоцна.
Ова е поврзано со тоа како покажувачи работа, каде што овие основни типови на податоци,
од друга страна, се пренесуваат од вредност.
>> Можеме да размислуваме за тоа што се прави копија на некои променлива, а потоа поминува во копија.
Не е важно она што го правиме со таа променлива.
Повикувајќи функција не ќе бидат свесни дека тоа беше сменето.
Низите се само малку различни во тој поглед.
На пример, како што само виде, главниот е само функција
што може да се земе во 2 аргументи.
Првиот аргумент на главната функција е argc, или бројот на аргументи,
и вториот аргумент е наречен argv,
и оние кои се вистинските вредности на тие аргументи.
Да речеме дека имам програма наречена this.c,
и велам направи ова, и јас одам да ја извршите оваа во командната линија.
Сега да помине во некои аргументи на мојот програма наречена ова,
Јас може да се каже нешто како. / Ова е cs 50.
Тоа е она што ние замислуваме Дејвид да се направи секој ден во терминал.
Но сега главната функција во внатрешноста на таа програма
има овие вредности, па argc е 4.
Тоа може да биде малку збунувачки, бидејќи навистина ние сме само поминува во е cs 50.
Тоа е само 3.
Но, се сеќавам дека првиот елемент на argv или првиот аргумент
е името на самата функција.
Тоа значи дека имаме 4 работи тука,
и првиот елемент е и ќе биде. / ова.
И ова ќе биде претставен како стринг.
Тогаш останатите елементи се она што ние ја внеле во по името на програмата.
Па само како настрана, како што веројатно гледаат во pset 2,
се сеќавам дека стрингот 50 се ≠ на број 50.
Значи не можеме да кажеме нешто како, "int x = argv 3. '
>> Тоа не е само случува да се направи смисла на зборот, бидејќи ова е стринг, а тоа е цел број.
Значи, ако сакате да го конвертирате помеѓу 2, се сеќавам, ние ќе
имаат оваа магија функција наречена atoi.
Кој ги зема низа и се враќа на целобројна претставен внатрешноста на стрингот.
Па тоа е лесен грешка да се направи на квизот,
само размислување дека ова автоматски ќе биде точниот тип.
Но, само знам дека тие секогаш ќе бидат жици
дури и ако стрингот содржи само цел број или знак или со подвижна запирка.
Па сега ајде да зборуваме за трчање време.
Кога имаме сите овие алгоритми кои го прават сите овие луди работи,
станува навистина корисно да се постави прашањето "Колку долго тие ќе потрае?"
Ние сме тоа со нешто што се нарекува асимптотска нотација.
Па тоа значи дека - добро, ајде да речеме дека ние им дадеме на нашите алгоритам
некои навистина, навистина, навистина голема влез.
Ние сакаме да го поставуваме прашањето: "Колку долго тоа ќе трае?
Колку чекори што ќе ги преземе нашата алгоритам да се кандидира
како функција на големината на влез? "
Така, првиот начин можеме да ја опишеме кандидира време е со голема О
И тоа е нашата најлошото трчање време.
Значи, ако сакаме да го решите низа, а ние им дадеме на нашите алгоритам низа
тоа е во обратен редослед кога тоа треба да биде во растечки редослед,
тоа ќе биде најлошото.
Ова е нашиот горна граница во должина на време нашите алгоритам ќе ги преземе.
Од друга страна, ова Ω се случува да се опише најдобар случај трчање време.
Значи, ако ние им даде на веќе сортирана низа на сортирање алгоритам,
колку долго ќе потрае да го средиме?
И ова, тогаш, ја опишува пониска врзани за трчање време.
Значи тука се само некои зборови кои опишуваат некои вообичаени работи пати.
Овие се во растечки редослед.
Најбрз трчање време имаме се нарекува постојано.
>> Тоа значи дека без разлика колку многу елементи ние им дадеме на нашите алгоритам,
без разлика колку големи нашата низа е, сортирање го ова
или прави она што го правиме на низа секогаш ќе го заземат истиот износ на време.
Значи можеме да претставуваат дека само со 1, која е константа.
Ние, исто така, погледна логаритамска кандидира време.
Значи нешто како бинарна пребарување е логаритамска,
каде што се намали проблемот на половина во секое време
а потоа работи едноставно се добие повисока од таму.
И ако сте некогаш пишување О на било факториел алгоритам,
најверојатно не треба да се разгледа ова како вашиот ден работа.
Кога ќе се споредат трчање пати е важно да се има предвид овие работи.
Значи, ако имам алгоритам што е О (n), и некој друг
има алгоритам на О (2n) овие се всушност асимптоматично еквивалентни.
Значи, ако ние замислуваме n да биде голем број како eleventy милијарди:
па кога ние сме во споредба eleventy милијарди нешто како eleventy милијарди + 3,
одеднаш кои 3 навистина не направи голема разлика повеќе.
Тоа е причината зошто ние се случува да се размислува за овие работи кои треба да бидат еднакви.
Па работи како овие константи тука, има 2 x ова, или додавање на 3,
овие се само константи, и овие се случува да падне до.
Значи тоа е зошто сите 3 од овие работи пати се исти како и велејќи дека тие се O (N).
Слично на тоа, ако имаме 2 други работи времиња, да речеме О (n ³ + 2n ²), можеме да додадете
+ N, + 7, а потоа имаме уште кандидира време тоа е само О (n ³).
повторно, овие се иста работа, бидејќи тие - тие не се исти.
Тоа се истите работи, жалам. Значи овие се исти, бидејќи
овој ³ n се случува да доминира оваа 2n ².
>> Што не е иста работа е ако сме се кандидира времиња како О (n ³) и О (n ²)
бидејќи овој ³ n е многу поголем од овој ² n.
Значи, ако имаме експоненти, одеднаш ова започнува да е важно,
но кога ние сме само се занимаваат со фактори како што се до тука,
тогаш тоа нема да е важно, бидејќи тие се само ќе падне надвор.
Ајде да ги разгледаме во некои од алгоритми видовме досега
и зборуваат за нивните кандидира време.
Првиот начин да барате број во список, што сме го виделе, беше линеарно пребарување.
И спроведувањето на линеарно пребарување е супер лесно.
Ние само имаат листа, и ние ќе треба да се погледне во секој елемент од листата
додека не се најде бројот што го барате.
Тоа значи дека во најлош случај, ова О (n).
И најлош случај тука може да биде ако елементот е
последниот елемент, а потоа со помош линеарно пребарување ние треба да се погледне во секој елемент
додека не стигнете до последниот, со цел да знаат дека тоа всушност бил во листата.
Ние не само да се откажат од половина пат и велат: "Тоа не е веројатно таму."
Со линеарно пребарување ние треба да погледнеме во целата работа.
Најдобар случај трчање време, од друга страна, е постојан
затоа што во најдобар случај елементот што го барате е само првиот во листата.
Па затоа се случува да ни потрае точно 1 чекор, без разлика колку големи листата е
ако ние сме во потрага по првиот елемент во секое време.
>> Па кога ќе пребарување, се сеќавам, тоа не се бара дека нашата листа се подредени.
Затоа што ние сме едноставно ќе се погледне во текот секој елемент, а тоа не е важно
она што цел тие елементи се внатре
А поинтелигентен пребарување алгоритам е нешто како бинарна пребарување.
Запомнете, спроведувањето на бинарни пребарување е кога ќе одиш да
ги бараме во средината на листата.
И бидејќи ние сме во потрага по среден, бараме дека листата е сортирана
или на друго место не знаеме каде средината е, и ние треба да се погледне во текот
целата листа за да го најдете, а потоа во тој момент ние сме само губат време.
Значи, ако имаме подредени листа и ќе најдеме на средина, ние ќе се споредуваат средината
на елементот што го барате.
Ако тоа е премногу висока, тогаш можеме да заборавиме на десната половина
затоа што знаеме дека ако нашите елемент е веќе премногу висока
и сè да се право на овој елемент е дури и повисок,
тогаш ние не треба да се погледне таму веќе.
Каде што од друга страна, ако нашата елемент е премногу ниска,
знаеме што е лево од тој елемент е исто така премногу ниска,
па тоа не е никаква смисла да се погледне таму, или.
На овој начин, со секој чекор и секој пат кога ќе погледнеме во средина на листата,
ние ќе ги намали нашиот проблем на половина бидејќи одеднаш знаеме
еден куп на броеви кои не може да биде оној што го барате.
>> Во pseudocode тоа ќе изгледа нешто како ова,
и затоа што се сечење на листата на половина секој пат,
нашата најлошото кандидира време скокови од линеарни да логаритамска.
Па одеднаш имаме влезете во чекори со цел да се најде на елемент во листата.
Најдобар случај трчање време, сепак, се уште е постојана
затоа што сега, ајде да речеме дека елементот што го барате е
секогаш точно средината на оригиналната листа.
Значи можеме да расте нашата листа толку големи како што сакаме, но ако елементот што го барате е на средината,
тогаш тоа е само ќе не однесе 1 чекор.
Значи тоа е причината зошто ние сме О (log n) и Ω (1) или константа.
Да, всушност се кандидира бинарни пребарување на овој список.
Па да речеме дека ние сме во потрага за елементот 164.
Првото нешто што ние се случува да направите е да најдете средина на оваа листа.
Тоа само така се случува, дека средината се случува да падне помеѓу овие 2 броја,
па ајде само произволно се каже, секој пат средина паѓа помеѓу 2 броја,
ајде да се заокружи.
Ние само треба да бидете сигурни дека ќе го направите ова секој чекор од патот.
Па ние ќе се заокружи и ние ќе кажеме дека 161 е средината на нашата листа.
Значи 161 <164, и секој елемент на лево од 161
е <164, па ние знаеме дека тоа нема да ни помогне на сите
да се започне овде, бидејќи елементот што го барате не може да биде таму.
Значи она што можеме да направиме е ние само може да заборави за што целата левата половина на листата,
а сега само се разгледа од десно на 161 па натаму.
>> Значи, повторно, ова е средина; ајде да се заокружи.
Сега 175 е премногу голема.
Па знаеме дека нема да ни помогне да барате тука или тука,
па ние само може да се фрли што подалеку, и на крајот ќе ја погоди 164.
Било какви прашања во бинарна пребарување?
Ајде да се движи на од пребарувањето преку веќе сортирана листа
да се всушност земање на листата на броеви во било која цел
и правење на таа листа во растечки редослед.
Првиот алгоритам ние погледна беше наречен меур вид.
И ова ќе биде поедноставно од алгоритми видовме.
Меур вид вели дека кога било 2 елементи во внатрешноста на листата се од место,
значи постои поголем број од лево на помал број,
тогаш ние ќе ги трампа, затоа што тоа значи дека на листата ќе биде
"Повеќе сортирани" отколку што беше порано.
И ние сме само ќе продолжи овој процес повторно и повторно и повторно
до крајот на елементи вид на балон на нивната точна локација и ние имаме подредени листа.
>> На кандидира време на овој ќе биде О (n ²). Зошто?
Па, затоа што во најлош случај, ние ќе треба да се земе секој елемент, и
ние ќе се заокружи споредувајќи го со секој друг елемент во листата.
Но, во најдобар случај, имаме веќе сортирана листа, меур вид на
само ќе поминат низ еднаш, да каже "Не бе. Јас не направи свопови, па јас сум се направи."
Па ние имаме најдобар случај трчање време на Ω (л).
Ајде да се кандидира меур вид на листа.
Или прво, ајде да погледнеме некои pseudocode навистина брзо.
Сакаме да кажеме дека сме сакате да ги пратите, во секој повторување на јамка,
ги пратите на тоа дали сме или не сме промениле елементи.
Значи причината за тоа е, ние ќе запре кога не сме заменети било какви елементи.
Значи на почетокот на нашата телефонска линија не сме сменил ништо, па ние ќе се каже дека е лажна.
Сега, ние ќе треба да поминат низ листата и споредете елемент јас да елемент i + 1
и ако тоа е случај дека постои поголем број од лево на помал број,
тогаш ние само ќе ги трампа.
>> А потоа ние ќе да се запамети дека ние заменети елемент.
Тоа значи дека ние треба да одиме низ листата најмалку 1 повеќе време
бидејќи состојбата во која што застанавме е кога целата листа е веќе сортирани,
што значи ние не дадоа никакви свопови.
Значи тоа е зошто нашата состојба овде е 'додека некои елементи биле заменети. "
Па сега ајде да се погледне на овој работи на листата.
Имам листа 5,0,1,6,4.
Меур вид се случува да започне целиот пат на левата страна, а тоа се случува да се споредат
на i елементи, така 0 до i + 1, кој е елемент 1.
Тоа се случува да се каже, и 5> 0, но токму сега 5 е на лево,
па затоа треба да се разменуваат со 5 и 0.
Кога ќе ги разменуваат, одеднаш се добие оваа поинаква листа.
Сега 5> 1, па ние ќе ги трампа.
5 не е> 6, така што не треба да правите ништо тука.
Но, 6> 4, па ние треба да се разменуваат.
Повторно, ние треба да ја извршите преку целата листа за да на крајот откријат
дека тие се на ред, ние ги трампа,
и во овој момент ние треба да ја извршите преку листа 1 повеќе време
да бидете сигурни дека сè е во ред, и во овој момент меур вид заврши.
А различни алгоритам за преземање на некои елементи и сортирање нив е селекција вид.
Идејата зад селекција вид е дека ние ќе се изгради подредени дел од листата
1 елемент во исто време.
>> И начинот на кој ние се случува да се направи тоа е преку градење на левата сегмент на листата.
И во основа, секој - за секој чекор, ние ќе преземе најмалиот елемент имаме лево
што не е сортирана сепак, и ние ќе се движи во таа подредени сегмент.
Тоа значи дека треба постојано да се најдат на минимум несортиран елемент
а потоа се земе дека минимум елемент и разменуваат со што
лево повеќето елемент кој не е сортирана.
Периодот за време на овој ќе биде О (n ²) затоа што во најлош случај
ние треба да се споредуваат секој елемент на секој друг елемент.
Затоа што ние сме велејќи дека ако почнеме од левата половина на листата, ние треба
да поминат низ целиот право сегмент да се најде најмалиот елемент.
А потоа, повторно, ние треба да одиме во текот на целиот право сегмент и
Продолжувам да одам во текот на овој одново и одново и одново.
Тоа ќе биде n ². Ние ќе треба за телефонска линија во внатрешноста на друга за телефонска линија
што укажува n ².
Во најдобар случај мисла, да речеме ние го даде веќе сортирана листа;
ние всушност не го сторат било подобро отколку n ².
Бидејќи изборот вид нема начин на знаејќи дека
минималните елемент е само еден јас се случи да се гледа.
Таа се уште треба да бидете сигурни дека ова е всушност минимум.
>> И единствениот начин да бидете сигурни дека тоа е на минимум, со користење на овој алгоритам,
е да се погледне во секој елемент повторно.
Значи, навистина, ако ви даде тоа - ако ви даде избор вид веќе сортирана листа,
тоа не се случува да се направи било подобро отколку што му дава листа која не е сортирана уште.
Патем, ако тоа се случува да биде случај дека нешто не е О (нешто)
и омега на нешто, ние само може да се каже повеќе посочно дека тоа е θ на нешто.
Значи, ако видите дека излезе насекаде, тоа е она што само значи.
>> Ако нешто не е во тета од n ², тоа е и голема О (n ²) и Ω (n ²).
Значи најдобар случај и најлош случај, тоа не се направи разлика,
алгоритам се случува да го прават истото во секое време.
Значи тоа е она што pseudocode за избор вид може да изгледа вака.
Ние сме во основа ќе каже дека сакам да iterate во текот на листа
од лево кон десно, и на секој повторување на јамка, јас одам да се движат
минималните елемент во оваа решат дел од листата.
И јас еднаш се движи нешто таму, јас никогаш не треба да се погледне во тоа елемент повторно.
Бидејќи штом ќе разменуваат елемент во левиот дел од листата, тоа е сортирана
бидејќи ние сме прави се што е во растечки редослед со користење минимални.
Значи рековме, во ред, ние сме во позиција I, и ние треба да се погледне во сите елементи
на правото на i со цел да се најде на минимум.
Па тоа значи дека ние сакаме да се погледне од i + 1 на крајот на листата.
И сега, ако елемент што ние сме во моментов во потрага по е помалку од нашата минимална досега,
кои, се сеќавам, ние сме отпочнување на минимум надвор да биде само
она елемент ние сме во моментов во, јас ќе се претпостави дека е на минимум.
Ако најдам елемент кој е помал од тоа, тогаш јас ќе одам да се каже, во ред,
добро, сум ги нашол нов минимум.
Одам да се сетам каде што најмалку беше.
>> Па сега, еднаш сум поминала низ тоа право несортиран сегмент,
Можам да кажам јас одам да се разменуваат со минимум елемент со елемент, кој е во позиција i.
Тоа се случува да се изгради мојата листа, мојата подредени дел од листата од лево кон десно,
и ние никогаш не треба да се погледне во елемент уште еднаш, откако таа е во тој дел.
Откако ние сме го сменил.
Значи, да се кандидира за избор вид на оваа листа.
Сино елемент тука се случува да биде јас, и црвено елемент ќе биде минимум елемент.
Па јас започнува по целиот пат од лево од листата, па на 5.
Сега ние треба да се најде на минимум несортиран елемент.
Па велиме 0 <5, па 0 е мојот нов минимум.
>> Но не можам да престане да постои, бидејќи иако може да се препознае дека 0 е најмал,
ние треба да поминува низ секој друг елемент од листата за да бидете сигурни.
Значи 1 е поголем, 6 е поголема, 4 е поголем.
Тоа значи дека по гледањето на сите овие елементи, јас сум определен 0 е најмал.
Па ќе одам да се разменуваат со 5 и 0.
Еднаш се разменуваат тоа, јас ќе одам да добиете нова листа, и знам дека никогаш не треба да се погледне во тоа 0 повторно
затоа што еднаш сум го сменил, сум го решат и ние ќе завршиш.
Сега тоа само така се случува, дека син елемент е повторно на 5,
и ние треба да се погледне на 1, 6 и 4 за да се утврди дека 1
е најмалиот минимум елемент, па ние ќе трампа 1 и 5.
Повторно, ние треба да погледнеме во - споредат 5 до 6 и 4,
и ние ќе трампа на 4 и 5, и, конечно, да ги споредиме
оние 2 броја и swap нив се додека ние го добиваме нашиот подредени листа.
Било какви прашања за избор вид?
Во ред. Ајде да се движи до последната тема тука, а тоа е рекурзија.
>> Рекурзија, се сеќавам, дали е ова навистина мета каде што нешто е функција
постојано се нарекува.
Така во еден момент, додека нашите fuction е постојано себеси се нарекува,
треба да има одреден момент во кој ние престанат да повикуваат себеси.
Бидејќи ако ние не го сторат тоа, тогаш ние само ќе продолжи да го стори оваа засекогаш,
и нашата програма е само нема да се прекине.
Оваа состојба се нарекува база случај.
И на база случај вели, наместо нарекувајќи функција повторно,
Јас сум само ќе се вратат некои вредност.
Значи еднаш сме се врати на вредност, Запревме повикувајќи себеси,
а остатокот на повици што е направен досега, исто така, можат да се вратат.
Спротивно на база случај е рекурзивен случај.
И ова е кога сакаме да се направи уште еден повик на функција, дека ние сме во моментов внатре
А ние веројатно, иако не секогаш, сакаат да користат различни аргументи.
>> Значи, ако имаме функција наречена ѓ, и ѓ само се нарекува земаат 1 аргумент,
а ние само ги повикува ѓ (1), ѓ (1), ѓ (1), и тоа само така се случува, дека
аргументот 1 паѓа во рекурзивен случај, ние никогаш уште ќе престане.
Дури и ако имаме база случај, ние треба да бидете сигурни дека на крајот ние ќе погоди дека базата на случајот.
Ние не само задржи престојуваат во овој рекурзивен случај.
Општо земено, кога ние самите се јавите, ние сме веројатно ќе имаат различни аргумент секој пат.
Тука е навистина едноставен рекурзивен функција.
Па ова ќе се пресмета факториел на број.
До почетокот тука имаме нашата база случај.
Во случај n ≤ 1, ние нема да се јавите факториел повторно.
Ние ќе запре, а ние сме само ќе се вратат некои вредност.
Ако ова не е точно, тогаш ние ќе ја погоди нашата рекурзивен случај.
Забележете тука дека ние не сме само повикување факториел (л), затоа што тоа нема да биде многу корисна.
Ние ќе се јавите факториел на нешто друго.
>> И така може да се види, на крајот ако помине факториел (5) или нешто,
ние ќе се јавите факториел (4) и така натаму, и на крајот ние ќе да ја погоди оваа база случај.
Па ова изгледа добро. Ајде да видиме што се случува кога ние всушност ја извршите оваа.
Ова е оџакот, и да речеме дека главната ќе ја повика оваа функција со аргумент (4).
Значи уште факториел гледа и = 4, факториел ќе се јавам.
Сега, одеднаш, имаме факториел (3).
Па овие функции се случува да расте до крајот ние го погоди нашата база случај.
Во овој момент, повратната вредност на ова е враќање (NX повратната вредност на ова),
повратната вредност на ова е NX повратната вредност на ова.
На крајот ние треба да се погоди некој број.
На врвот тука, ние велиме враќање 1.
Тоа значи дека откако ќе се врати тој број, ние може да pop ова исклучување на магацинот.
Значи ова факториел (1) е направено.
Кога 1 се враќа, овој факториел (1) се враќа, ова враќање на 1.
Повратната вредност на ова, се сеќавам, беше NX повратната вредност на ова.
Значи одеднаш, овој човек знае дека сакам да се врати 2.
>> Значи се сеќавам, се врати вредноста на ова е само NX вратената вредност се тука.
Па сега можеме да кажеме 3 x 2, и, конечно, тука можеме да кажеме
ова е само случува да биде 4 x 3 x 2.
И еднаш ова се враќа, ние се фаќате за еден број во внатрешноста на главниот.
Било какви прашања на рекурзија?
Во ред. Значи има повеќе време за прашањата на крајот,
но сега Џозеф ќе ги покрие останатите теми.
>> [Џозеф Ong] Во ред. Па сега дека ние сме зборуваше за recursions,
ајде да разговараме малку за она што се спојат вид е.
Се спојат вид е всушност уште еден начин на сортирање на листата на броеви.
И како таа работи е, со спојување вид ќе имаш листа, и она што го правиме е
ние велиме, да се подели тоа во 2 дела.
Ние прво ќе се кандидира спојат вид повторно на левата половина,
потоа ќе се кандидира спојат вид на десната половина,
и дека ни дава сега 2 половини кои се подредени, и сега ние ќе се комбинираат тие половини заедно.
Тоа е малку тешко да се види без пример, па ќе одиме преку предлог и да видиме што се случува.
Значи кога ќе почнете со оваа листа, што го подели на 2 дела.
Трчаме спојат вид на левата половина прв план.
Значи тоа е левата половина, а сега ги поминува низ оваа листа повторно
кој добива помина во спојат вид, а потоа гледаме, пак,
на левата страна на оваа листа и трчаме спојат вид на неа.
Сега, ние се фаќате за листа на 2 броја,
и сега на левата половина е само 1 елемент долго, а ние не можеме да
подели на листата што е само 1 елемент во половина, па ние само се каже, еднаш имаме 50,
што е само 1 елемент, тоа е веќе сортирана.
>> Откако ќе завршиш со тоа, можеме да видиме дека можеме да
се движи кон десната половина на оваа листа,
и 3 исто така се подредени, па сега дека двете половини од оваа листа се подредени
можеме да се приклучат на овие броеви назад заедно.
Па ние со нетрпение во 50 и 3, 3 е помал од 50, па тоа оди во прв, а потоа 50 влегува внатре
Сега, тоа е направено, ние одиме назад до таа листа и вид тоа е десната половина.
42 е свој број, па тоа е веќе сортирана.
Па сега ќе се споредат овие 2 и 3 е помал од 42, така што добива стави во прв,
сега 42 добива ставам, и 50 добива стави внатре
Сега, тоа е сортирана, ние одиме сите на патот назад до врвот, 1337 и 15.
Па, ние сега се погледне на левата половина од оваа листа; 1337 е сама по себе па затоа се подредени и истиот со 15.
Па сега ние се комбинираат овие 2 броја да се најде дека оригиналната листа, 15 <1337,
така тоа оди во прв, а потоа 1337 оди внатре
И сега ние подредени двете половини од оригиналната листа до врвот.
И сите ние треба да направите е да се комбинираат овие.
Ние гледаме на првите 2 броја на оваа листа, 3 <15, па оди во вид низа во прв план.
15 <42, па тоа оди внатре Сега, 42 <1337, што оди внатре
50 <1337, па тоа оди внатре и ќе забележите дека ние само се 2 броја исклучување на оваа листа.
Значи ние не сме само наизменични помеѓу 2 листи.
Ние сме само гледајќи во почетокот, и ние сме преземање на елемент
тоа е помала и тогаш стави ја во нашата низа.
Сега сме споени сите половини и ние ќе завршиш.
>> Било какви прашања во врска со спојат вид? Да?
[Студентски] Ако тоа е поделба во различни групи, зошто не тие само го подели еднаш
и имаш 3 и 2 со група? [Остатокот од прашањето неразбирливо]
Причината - Значи, прашањето е, зошто не можеме само да ги спојат во тоа првиот чекор откако ќе ги имаат?
Причината можеме да го направите ова, со почеток во левата повеќето елементи на двете страни,
и тогаш земи помала и го стави во, е дека ние знаеме дека овие
индивидуални листи се подредени наредби.
Значи, ако јас сум во потрага по левата повеќето елементи на двете половини,
Знам дека тие се случува да биде најмалата елементи на тие листи.
Па јас може да ги стави во најмалиот елемент точки на оваа голема листа.
Од друга страна, ако се погледне во оние 2 листи во второто ниво таму,
50, 3, 42, 1337 и 15, и оние кои не се подредени.
Значи, ако јас се погледне во 50 и 1337, јас ќе одам да се стави 50 во мојата листа во прв план.
Но, тоа не навистина има смисла, бидејќи 3 е најмалиот елемент од сите оние.
Значи единствената причина ние да го правиме ова комбинирање чекор е затоа што нашите листи веќе се подредени.
Која е причината зошто ние мора да се фаќате целиот пат до дното
бидејќи кога имаме само еден единствен број, знаеш дека еден број
во и по себе е веќе сортирана листа.
>> Било какви прашања? Не?
Комплексноста? Па, можете да видите дека на секој чекор има крај броеви,
и можеме да ги поделиме на листата на половина најавите n пати,
која е местото каде што ќе го добиеме овој n x најавите n комплексност.
И ќе видите најдобар случај за спојување вид е n најавите n, и тоа само така се случува,
дека најлошото, или Ω таму, исто така е n најавите n.
Нешто да се има предвид.
Преселба на, ајде да одиме на некои супер основните датотека I / O.
Ако сте го гледаше во трка, ќе забележите имавме некој вид на систем
каде што можете да напишете на log датотеката, ако се чита преку код.
Ајде да видиме како може да го направи тоа.
Па, ние сме fprintf, кои можете да замислите како само printf,
но само печатење во датотека наместо тоа, а оттука и ѓ на почетокот.
Овој вид на код се тука, она што го прави тоа е, како што може да се види во трка,
тоа оди преку вашиот 2-димензионална низа печатење ред по што бројките се.
Во овој случај, printf отпечатоци до вашиот терминал или она што ние го нарекуваме стандарден излез на секција.
>> И сега, во овој случај, сите ние треба да направите е да го замени printf со fprintf,
каже дека тоа што датотеката која сакате да се печати, а во овој случај тоа само да го печати до таа датотека
наместо тоа печатење на вашиот терминал.
Па, тогаш што моли на прашањето: Каде да добиеме овој вид на датотека од, нели?
Минавме влезете во овој fprintf fuction но немавме идеја од каде доаѓа.
Па, во почетокот на код, што ја имавме беше овој дел од кодот овде,
која во основа вели дека ја отворам датотеката повици log.txt.
Што правиме после тоа е дека ние треба да бидете сигурни дека датотеката е, всушност, отворена успешно.
Па тоа би можело да пропадне поради повеќе причини, вие немате доволно простор на вашиот компјутер, на пример.
Така, тоа е секогаш важно пред да направите било операции со датотеки
дека ние се провери дали таа датотека беше отворена успешно.
Значи она што, тоа е аргумент за fopen, добро, можеме да отворите датотека во многу начини.
Што можеме да направиме е, можеме да го помине W, што значи замени датотека, ако тоа излегува веќе,
Ние може да помине на кој тие додаваат на крајот на датотеката наместо највисок тоа,
или може да се определи r, што значи, да ја отворам датотеката како само за читање.
Значи, ако на програмата се обидува да направи никакви промени на датотеката,
развикам нив и не нека го направи тоа.
Конечно, откако ќе завршиш со датотека, направено прави операции на неа,
ние треба да бидете сигурни дека ние затвори датотека.
И така на крајот на вашата програма, ви се случува да ги помине повторно
оваа датотека што ќе се отвори, и само да го затворите.
Значи ова е нешто важно што ќе треба да бидете сигурни дека го правите.
Па не заборавајте можете да отворите некоја датотека, тогаш може да се запише во датотеката,
прават операции во датотеката, но тогаш ќе мора да го затвори датотека на крајот.
>> Било какви прашања на основните датотека I / O? Да?
[Студентски збор, неразбирливо]
Токму тука. Прашањето е, каде што овој log.txt датотеката се појавува?
Па, ако сте само да го даде log.txt, тоа создава во истиот директориум како извршна.
Па ако Ти си - >> [Студентски збор, неразбирливо]
Да. Во истата папка, или во истиот директориум, како што го нарекуваат.
Сега меморија, магацинот и грамада.
Па, како е меморија утврдени во компјутер?
Па, можете да си замислите меморија, како вид на овој блок тука.
И во меморијата имаме она што се нарекува грамада заглавени таму, и на магацинот тоа е таму долу.
И грамада расте надолу и магацинот расте нагоре.
Па како Томи споменати - добро де, и ние имаме овие други 4 сегменти кои ќе се дојде до во вториот -
Како Томи реков порано, знаеш колку неговите функции се нарекуваат себеси и се јавите едни со други?
Тие се изгради овој вид на магацинот рамка.
Па, ако главната повици foo, foo добива стави на магацинот.
Foo повици бар, бар да се стави на магацинот, и кој добива се стави на магацинот после.
И како ќе се вратат, секој од нив се соблече на магацинот.
Што секоја од овие локации и меморија се одржи?
Па, на врвот, која е текстот сегмент, содржи самата програма.
Па машина код, тоа е таму, откако ќе ги собере вашата програма.
Потоа, било иницијализира глобални променливи.
>> Па имате глобални променливи во вашата програма, а ти каже како, a = 5,
кој добива се стави во тој сегмент, а веднаш под тоа,
имате било какви деиницијализира глобалната податоци, што е само int a,
но вие не велат дека тоа е еднакво на ништо.
Реализираат овие се глобални променливи, па тие се надвор од главните.
Значи ова значи било глобални променливи кои се објавени, но не се иницијализира.
Значи она што е во грамада? Меморија доделени користење Примерок, која ние ќе дојдеме до во малку.
И, конечно, со магацинот имате било какви локални променливи
и сите функции може да се јавите во било кој од своите параметри.
Последното нешто, ти навистина не треба да знаат што на животната средина променливи се направи,
но секогаш кога ќе ја стартувате програмата, има нешто поврзано, како
ова е корисничкото име на лицето кое го водеше програма.
И тоа ќе биде вид на дното.
Во однос на меморијата адреси, кои се хексадецимално вредности,
вредностите на врвот почетокот на 0, и тие одат по целиот пат до дното.
Во овој случај, ако сте во 32-битен систем,
на адреса на дното ќе биде 0x, проследено со AF, бидејќи тоа е 32 бита,
кој е 8 бајти, и во овој случај 8 бајти одговара на 8 хексадецимални цифри.
Значи тука долу ви се случува да имаат, како, 0xffffff, и таму ви се случува да имаат 0.
Значи она што се покажувачи? Некои од вас може да не се опфатени ова во делот пред.
но ние не одиме над неа во предавањето, па покажувач е само тип на податоци
која продавници, наместо некаква вредност како 50, ги чува адресата на некои локација во меморијата.
Како што меморија [неразбирливо].
Значи во овој случај, она што го имаме е, имаме покажувач на цел број или int *,
и содржи оваа хексадецимален адреса на 0xDEADBEEF.
>> Значи она што го имаме е, сега, овој покажувачот поени во некоја локација во меморијата,
и тоа е само, вредноста 50 е во овој мемориска локација.
На некои 32-битни системи, на сите 32-битни системи, показалки од 32 бита или 4 бајти.
Но, на пример, на 64-битен систем, показалки се 64 бити.
Значи тоа е нешто што ќе сакате да се задржи во умот.
Така, на крајот-битен систем, покажувач е крајот бита долга.
Покажувачи се вид на тешко да се вари без дополнителни работи,
па ајде да одиме преку еден пример на динамичен алокација на меморија.
Што динамична алокација на меморија прави за вас, или она што ние го нарекуваме Примерок,
што ви овозможува да одвои некој вид на податоци надвор од собата.
Па овој податок е вид на потрајно за време на траењето на програмата.
Бидејќи како што знаете, ако пријават x внатрешноста на функција, а таа функција се враќа,
веќе немате пристап до податоците што се чуваат во х.
Што совети нека направите е тие нека чување меморија или продавница вредности
во различни сегмент на меморија, имено грамада.
Сега откако ќе се врати од функцијата, се додека имаме покажувачот
за таа локација во меморијата, тогаш што можеме да направиме е ние само може да се погледне на вредности таму.
Ајде да погледнеме еден пример: Ова е нашата меморија распоред повторно.
И ние имаме оваа функција, главен.
Што го прави тоа е - добро, па едноставно, нели - int x = 5, тоа е само една променлива на магацинот во главниот.
>> Од друга страна, ние сега прогласи покажувач кој повикува функцијата giveMeThreeInts.
И така сега ние одиме во оваа функција и ќе создадеме нова магацинот рамка за тоа.
Меѓутоа, во овој магацинот рамка, изјавуваме int * Temp,
кои во mallocs 3 броеви за нас.
Па големината на int ќе ни даде колку бајти овој int е,
и Примерок ни дава дека многу бајти на просторот на грамада.
Значи во овој случај, ние направивме доволно простор за 3 цели броеви,
и грамада е начин, таму горе, кој е зошто сум го привлече повисоко.
Откако ќе завршиш, ќе се вратиме тука, треба само 3 ints врати,
и го враќа адреса, во овој случај околу тоа каде тоа сеќавање е.
И ние во собата покажувачот = Switch, и таму имаме само уште еден покажувач.
Но, она што таа функција се враќа се наредени тука и исчезнува.
Значи температура исчезнува, но ние се уште ги одржуваат адреса од каде
тие 3 броеви се во внатрешноста на електричната мрежа.
Така што во овој сет, покажувачи се scoped локално за рангирани рамка,
но споменот на кои се однесуваат е во грамада.
>> Дали тоа има смисла?
[Студентски] можете да повторам дека? >> [Џозеф] Да.
Значи, ако јас се вратиме само малку, ќе видите дека Темп распределени
некои меморија за грамада таму.
Значи, кога оваа функција, giveMeThreeInts се враќа, овој магацинот тука ќе исчезне.
А со тоа и било кој од променливи, во овој случај, овој показател дека беше доделена во рангирани рамка.
Што се случува да исчезне, но бидејќи ние се врати temp
и ние во собата покажувачот = Temp, покажувачот е сега се случува да се укаже истата меморија на локација како Temp беше.
Па сега, иако губиме Temp, дека локалните покажувач,
ние уште го чувам на мемориската адреса на она што беше укажува на внатрешноста на таа променлива покажувач.
Прашања? Тоа може да биде еден вид на збунувачки тема ако не се качил над неа во делот.
Можеме, вашиот ТФ дефинитивно ќе одам над неа и се разбира, ние може да одговара на прашања
на крајот на ревијата сесија за ова.
Но, ова е вид на комплексна тема, и имам повеќе примери кои ќе се појавиш
кои ќе ви помогнат појасни она совети всушност се.
>> Во овој случај, показалки се еквивалентни на низи,
па јас само да го користите овој покажувач како истото како int низа.
Па јас сум индексирање во 0, и менување на првиот број на 1,
менување на вториот број на 2 и 3 целобројни до 3.
Па повеќе на покажувачи. Па, да се потсетиме Binky.
Во овој случај ние сме доделени покажувач, или ние прогласи покажувач,
но на почетокот, кога јас само прогласи покажувач, тоа не е укажува на кое било место во меморијата.
Тоа е само ѓубре вредности во него.
Па јас немам идеја каде овој покажувачот е да се покажува.
Таа има адреса која е само исполнет со 0 и 1, каде што беше првично објавени.
Јас не може да направи ништо со тоа, додека јас го нарекувам Примерок на неа
а потоа тоа ми дава малку простор на грамада каде што може да се стави вредности внатре.
Потоа повторно, не знам што е внатре на оваа меморија.
Така првото нешто што треба да направите е да проверите дали системот има доволно меморија
да ми даде назад 1 број на прво место, кој е зошто јас го правам ова се провери.
Ако покажувачот е нула, што значи дека не имаат доволно простор или некоја друга грешка,
па јас треба да излезете надвор од мојата програма.
Но, ако тоа не успее, сега можам да ја користат таа покажувачот
и она * покажувачот не е тоа на следниов начин каде адресата е
каде што вредноста е, и го поставува тоа еднаква на 1.
Значи, овде, ние сме проверка ако меморијата постоел.
>> Откако ќе знаеш дека постои, може да се стави во неа
што вредноста што сакате да се стави во неа, во овој случај 1.
Откако ќе завршиш со тоа, треба да се ослободи дека покажувачот
бидејќи ние треба да се вратиме на систем кој меморија, која ви побара на прво место.
Бидејќи компјутерот не знае кога ќе завршиш со него.
Во овој случај ние експлицитно го кажувам, во ред, ние ќе завршиш со тоа меморијата.
Ако некој друг процес што треба, некоја друга програма што треба, се чувствуваат слободни да оди напред и да ја однесете.
Она што исто така може да направите е ние едноставно може да се добие адресата на локални променливи на собата.
Значи int x е внатре во рангирани рамките на главната.
И кога ние ги користиме оваа симболот, ова и оператор, она што го прави тоа е
е потребно x и x е само некои податоци во меморија, но тоа има адреса.
Тоа се наоѓа некаде. Значи со повик на & X, што тоа не е тоа ни дава адресата на x.
Со тоа, ние сме прави покажувачот точка до каде x е во меморијата.
Сега ние само се нешто како * x, ние ќе добие 5 врати.
Ѕвездата се вика dereferencing неа.
Го следите адреса и да добиете вредноста на тоа чуваат таму.
>> Било какви прашања? Да?
[Студентски] Ако не го сторат 3-истакна нешто, не се уште собира?
Да. Ако не го сторат 3-покажувачот нешто, тоа е уште се случува да ги собере,
но јас ќе ви покаже што се случува во една секунда, и без тоа го прават,
тоа е она што ние го нарекуваме меморија излегуваат во јавноста. Вие не сте давање на системот
врати неговата меморија, па по некое време на програмата ќе се акумулираат
меморија која не е користење и ништо друго да го користите.
Ако некогаш сте виделе Firefox со 1,5 милиони килобајти на вашиот компјутер,
во Task Manager, тоа е она што се случува.
Имаш меморија излегуваат во јавноста во програмата дека тие не се ракување.
Па како не покажувачот аритметички работа?
Па, покажувачот аритметичка е вид на како индексирање во низа.
Во овој случај, имам покажувач, и она што го правам е го направи покажувачот точка за првиот елемент
од оваа низа од 3 броеви што сум распределени.
Па сега што правам, ѕвезда покажувачот само го менува првиот елемент во листата.
Ѕвезда покажувачот 1 точки овде.
Значи покажувачот е над тука, покажувачот 1 е завршена тука, покажувачот 2 е овде.
>> Па само додавање на 1 е истото што се движат по должината на оваа низа.
Што правиме е, кога правиме покажувачот 1 ќе ја добиете адресата овде,
а со цел да се добие вредност во тука, ќе се стави ѕвезда од целиот израз
да го Dereference.
Значи, во овој случај, јас сум поставување на првото место во оваа низа на 1,
втората локација до 2, а трето место на 3.
Тогаш она што го правам во текот тука е Јас сум печатење нашите покажувачот 1,
што само ми дава 2.
Сега сум зголемување, покажувач, па покажувачот е еднаква на покажувачот 1,
која се движи напред.
Па сега ако јас испечатите покажувачот 1, покажувачот 1 е сега 3,
кој во овој случај отпечатоци од 3.
А со цел да се ослободи нешто, на покажувачот што го даде
мора да укажува на почетокот на низата која се вратив од Примерок.
Значи, во овој случај, ако јас се да се јавите 3 токму тука, тоа не би било право,
затоа што тоа е во средината на низата.
Морам да одземе за да се дојде до оригинална локација
почетна првата точка пред да може да ја ослободи.
Значи, тука е повеќе вклучени пример.
Во овој случај, ние сме доделување 7 карактери во карактер низа.
>> И во овој случај она што го правиме е ние сме looping во текот на првите 6 од нив,
и ние сме ги поставување до Ш
Значи, за int i = 0, i> 6, i + +,
Значи, покажувач + Јас само ќе ни даде, во овој случај,
покажувач, покажувач 1, покажувачот 2, покажувач 3, и така натаму и така натаму во јамка.
Што тоа се случува да направите е да станува таа адреса, dereferences тоа да се добие вредност,
и промените кои вредноста на З
Потоа на крајот се сеќава на ова е стринг, нели?
Сите жици мора да заврши со нула раскинувањето карактер.
Значи, она што го правам е во покажувачот 6 ставам null терминаторот карактер внатре
И сега што сум во основа прави овде е спроведување printf за низа, нели?
>> Значи, кога се printf сега кога тоа е до крајот на серијата?
Кога хитови на нула раскинувањето карактер.
Значи, во овој случај, мојот оригинален покажувачот поени до почетокот на оваа низа.
Јас печати првиот карактер надвор. Ми се движи над еден.
Јас печати дека карактерот надвор. Ми се движи над.
И јас го правам тоа додека не стигнат до крајот.
И сега на крајот * покажувачот ќе Dereference ова и ќе добиете нула раскинувањето карактер назад.
И така ми додека јамка работи само кога таа вредност не е нула раскинувањето карактер.
Значи, сега излезете од овој циклус.
И така, ако Јас одземе 6 од овој покажувач,
Се враќам сè до почетокот.
Запомнете, јас го правам тоа, бидејќи морам да одам на почетокот, со цел да се ослободи.
>> Значи, знам дека беше многу. Дали постојат било какви прашања?
Ве молиме, да?
[Студентски збор неразбирливо]
Може да се каже дека погласни? Жал ми е.
[Студентски] На последниот слајд право, пред да ја ослободи покажувач,
Каде бевте всушност менување на вредноста на покажувачот?
[Џозеф] Значи, токму овде. >> [Студентски] О, во ред.
[Џозеф] Значи, имам покажувачот минус минус, десно,
која се движи нешто назад еден, а потоа го ослободи,
бидејќи овој покажувачот треба да се истакне на почетокот на низата.
[Студентски] Но, тоа нема да бидат потребни те запре по таа линија.
[Џозеф] Значи, ако јас го запрел по ова, ова ќе се смета за меморија излегуваат во јавноста,
бидејќи јас не се кандидира на бесплатно.
[Студентски] Јас [неразбирливо] по првите три линии каде што требаше покажувачот 1 [неразбирливо].
[Џозеф] Ух-нели. Значи, она што е прашање таму?
Жал ми е. Не, не. Оди, оди, те молам.
[Студентски] Значи, вие не сте менување на вредноста на покажувачи.
Вие не би морале да ја завршат покажувачот минус минус.
[Џозеф] Да, точно.
Значи, кога правам покажувачот 1 и покажувачот 2,
Јас не го правам покажувачот е еднаква на покажувачот 1.
Така, на покажувачот само останува укажува на почетокот на низата.
Тоа е само кога правам плус плус дека поставува вредноста назад во внатрешноста на покажувачот,
дека тоа всушност се движи ова заедно.
Во ред.
Повеќе прашања?
>> Повторно, ако ова е вид на огромна, ова ќе бидат опфатени во сесија.
Прашајте го вашиот настава колеги за тоа, а ние може да одговори на прашањата на крајот.
И обично не сакаме да го направите ова минус работа.
Ова треба да бараат од мене следење на колку сум поместување во низата.
Значи, во целина, ова е само за да се објасни како покажувачот аритметички дела.
Но, она што ние обично сакале да направите е да сакаме да се создаде копија на покажувачот,
а потоа ние ќе ја користат таа копија кога ние сме се движат наоколу во низа.
Значи, во овие случаи го користите копија за печатење на целата низа,
но ние не треба да се направи како покажувач минус 6 или ги пратите на тоа колку ние се пресели во тоа,
само затоа што знаеме дека нашата изворна точка се уште посочи на почетокот на листата
и сето она што го менува беше оваа копија.
Значи, воопшто, да ја смени копии од вашите оригинални покажувач.
Не се обиде да најде решение за како - don't менуваат оригиналните примероци.
Обидувајќи се да се смени само копии од вашите оригинални.
Значи, ќе забележите кога ќе помине стринг во printf
вие не мора да се стави една ѕвезда пред него како што направивме со сите други dereferences, нели?
Значи, ако испечатите целиот Низата% s очекува е на адреса,
и во овој случај покажувач или во овој случај како низа од карактери.
>> Карактери, char * s и низи се иста работа.
Покажувачот е да карактери и карактер низите се иста работа.
И така, сите ние треба да направите е да помине во покажувач.
Ние не треба да се помине во како * покажувачот или нешто слично.
Значи, низи и покажувачи се иста работа.
Кога правиш нешто како x [Y] овде за низа,
она што таа го прави под хауба е тоа велејќи дека, добро, тоа е лик низа,
па тоа е покажувачот.
И така x се иста работа,
и така тоа што го прави е тоа додава y на x,
која е истото што се движат напред во меморија која многу.
И сега x + y ни дава некој вид на адреса,
и ние Dereference на адресата или следете ги стрелките
каде таа локација во меморијата е и ние да добијат вредност од таа локација во меморијата.
Значи, па овие две се токму истото.
Тоа е само синтактички шеќер.
Тие го прават истото. Тие се само различни syntactics за секоја друга.
>> Значи, она што може да тргне наопаку со покажувачи? Како, многу. Во ред. Значи, лоши работи.
Некои лоши работи што можете да направите да не се проверува дали вашиот Примерок повик се враќа нула, нели?
Во овој случај, јас барам на системот да ми даде - што е тоа број?
Како 2 милијарди пати 4, бидејќи големината на цел број е 4 бајти.
Јас сум го бара како 8 милијарди бајти.
Се разбира мојот компјутер не ќе биде во можност да ми даде дека многу меморија назад.
И ние не провери дали ова е нула, па кога ние се обидуваме да Dereference тоа таму -
следете ги стрелките за тоа каде тоа се случува да - ние не го имаат тоа меморија.
Тоа е она што ние го нарекуваме dereferencing е нулти покажувач.
И ова всушност предизвикува да segfault.
Ова е еден од начините можете да segfault.
Други лоши работи што можете да направите - О, добро.
Тоа беше dereferencing е нулти покажувач. Во ред.
Други лоши нешта - и, за да се утврди дека само стави проверка таму
кој проверува дали покажувачот е null
и да излезете од програмата, ако се случи тоа Примерок враќа null покажувачот.
Тоа е XKCD стрип. Луѓето го разбирам сега. Вид.
>> Значи, меморија. И јас отидов во текот на овој.
Ние сме повикувајќи Примерок во еден циклус, но секој пат кога ние го нарекуваме Примерок
ние сме губење на патеката на која овој покажувачот е да се покажува,
затоа што ние сме го clobbering.
Значи, првичниот повик за Примерок ми дава меморија овде.
Мој покажувачот совети за тоа.
Сега, јас не го ослободи, па сега јас го нарекувам Примерок повторно.
Сега тоа укажува овде. Сега мојата меморија е да се покажува овде.
Посочувајќи овде. Посочувајќи овде.
Но јас сум се губеше на адресите на сите мемориски овде дека јас распределени.
И така сега немам никакво повикување на нив повеќе.
Значи, јас не може да ги ослободи надвор од овој циклус.
И така, со цел да се поправи нешто како ова,
ако сте заборавиле да ослободите меморија и ќе се добие оваа меморија излегуваат во јавноста,
Мора да се ослободи меморија во внатрешноста на овој циклус откако ќе завршиш со него.
Па, ова е она што се случува. Знам дека многу ве мразат тоа.
Но сега - Yay! Ќе добиете како 44.000 килобајти.
Значи, вие се бесплатно на крајот од циклусот,
и дека се случува само ослободи меморија во секое време.
Во суштина, вашата програма не имаат меморија излегуваат во јавноста повеќе.
>> И сега нешто друго можете да направите е бесплатно некои меморија дека сте прашани за двапати.
Во овој случај, можете Примерок нешто, промени својата вредност.
Ќе ја ослободи еднаш, бидејќи ти рече дека се направи со неа.
Но, тогаш ние го ослободи повторно.
Ова е нешто што е прилично лошо.
Тоа нема да првично segfault,
но по некое време тоа што ова не е двојно ослободување ова расипува вашиот грамада структура,
и ќе дознаете малку повеќе за ова, ако одлучите да се земе една класа како CS61.
Но во суштина по некое време на вашиот компјутер ќе се збунети
за она што мемориски локации се таму каде што и каде тоа е се чуваат -
каде што податоците се чуваат во меморијата.
И така ослободувањето покажувач двапати е лоша работа што вие не сакате да го направите.
>> Други работи кои може да тргне наопаку не е користење на sizeof.
Значи, во овој случај Примерок 8 бајти,
и тоа е истото како два цели броја, нели?
Значи, тоа е совршено безбедна, но е тоа?
Па, како Лукас зборуваше за на различни архитектури,
броеви се на различни должини.
Значи, на апаратот кој што го користите, цели броеви се околу 4 бајти,
но за некои други систем тие би можеле да бидат 8 бајти или тие може да биде 16 бајти.
Значи, ако јас само го користите овој број над тука,
оваа програма може да работи на апаратот,
но тоа не се случува да доделам доволно меморија за некои други систем.
Во овој случај, тоа е она што на операторот sizeof се користи за.
Кога ние го нарекуваме sizeof (int), што тоа не е
што ни ја дава големината на цел број на систем што на програмата се извршува.
Значи, во овој случај, sizeof (int) ќе се вратат 4 на нешто како на апаратот,
и сега ова ќе 4 * 2, кој е 8,
што е само износот на просторот потребен за два цели броја.
На друг систем, ако int е како 16 бајти или 8 бајти,
тоа е само случува да се врати доволно бајти за да ја запази таа сума.
>> И, конечно, structs.
Значи, ако си сакал да се складира Судоку одбор во меморија, како да го направите ова?
Можете да мислите на како променлива за прв нешто,
променлива за втората работа, променлива за третата работа,
променлива по четврти работа - лошо, нели?
Значи, подобрување може да се направи на врвот на ова е да се направи 9 x 9 низа.
Тоа е во ред, но што ако си сакал да се дружат други работи со одборот Судоку
како што тешкотијата на одборот е,
или, на пример, она што вашиот резултат е, или колку време е донесена да се реши овој форум систем?
Па, она што можете да направите е да можете да креирате struct.
Она што јас сум во основа велејќи е јас сум дефинирање оваа структура над тука,
и јас сум дефинирање на Судоку одбор кој се состои од одборот што е 9 x 9.
>> И што има тоа има покажувачи за името на ниво.
Исто така, има x и y, кои се координатите на местото каде што сум сега.
Исто така, има време поминато [неразбирливо], а таа има вкупниот број на потези сум внесуваат досега.
И така во овој случај, можам да Група А целиот куп на податоци во само една структура
наместо тоа како летаат наоколу во како различни варијабли
дека јас навистина не може да ги пратите.
И ова ни овозможува да имаат само убаво синтакса за вид на референцирање различни работи во внатрешноста на оваа struct.
Јас само може да го направи board.board, и јас го добиете Судоку одбор назад.
Board.level, да се добие колку е тешко е тоа.
Board.x и board.y ми даде координатите на местото каде што може да биде во одборот.
И така јас сум пристап што ние го нарекуваме полиња во структурата.
Ова дефинира sudokuBoard, која е еден вид што имам.
И сега ние сме тука. Имам променлива наречена "одбор" од типот sudokuBoard.
Па сега можам да влезам сите области кои ја сочинуваат оваа структура овде.
>> Било какви прашања во врска со structs? Да?
[Студентски] За int x, y, можете прогласена и во една линија? >> [Џозеф] Ух-нели.
[Студентски] Значи, може да ви само го направи тоа со сите нив?
Како и во x, y запирка пати дека вкупните?
[Џозеф] Да, дефинитивно може да го направи тоа, но причината ја ставив x и y на иста линија -
и прашање е зошто можеме само го прават тоа на иста линија?
Зошто не можеме само да ги ставите сите овие на истата линија е
x и y се поврзани едни со други,
и ова е само стилски повеќе точни, во некоја смисла,
бидејќи тоа е групирање две работи на иста линија
дека како вид на се однесуваат на иста работа.
И јас само се подели на овие распаѓа. Тоа е само стил нешто.
Функционално не прави никаква разлика она.
Сите други прашања за structs?
Можете да дефинирате Pokédex со структурата.
А Покемон има голем број и има писмо, сопственик, тип.
А потоа ако имате низа на Покемон, можете да направите до Pokédex, нели?
Океј, кул. Значи, прашањата за structs. Оние кои се поврзани со structs.
>> Конечно, gdb. Што значи GDB да го направите? Тоа ви овозможува да debug вашата програма.
И ако не сте го користеле GDB, би препорачува гледање на краток
и само одат над она што GDB е, како да работат со него, како можете да ја користите,
и тестирање на програмата.
И уште па што GDB ви овозможува да направите е тоа што ви овозможува пауза [неразбирливо] до вашата програма
и практичен линија.
На пример, сакам да го паузирате извршување на како алинеја 3 од мојата програма,
и додека јас сум на линија 3 можам да испечатите сите вредности кои се таму.
И така она што го нарекуваме како задржувањето во линија
е што ние го нарекуваме овој ставање на точки на прекин на таа линија
и потоа можеме да печатиме променливи во државата на програмата во тоа време.
>> Ние можеме да потоа од таму чекор преку програмата линија-по-линија.
И потоа можеме да се погледне на состојбата на магацинот во тоа време.
И така, со цел да се користи GDB, она што го правиме е што ние го нарекуваме ѕвекот на датотеката C,
но ние треба да го положат-ggdb знаме.
И откако ќе завршиш со кои ние едноставно се кандидира gdb на добиената излезната датотека.
И така ќе добиете некои како маса на текст, како таков,
но, навистина сите што треба да направите е да напишете команди на почетокот.
Пауза главната става точка на прекин на главните.
Листа на 400 листи на линии на код околу линија 400.
И така во овој случај вие само може да погледне наоколу и да се каже, ох,
Сакам да се постави точка на прекин на линија 397, која е на оваа линија,
а потоа вашата програма работи во тој чекор и тоа се случува да се скрши.
Тоа се случува да пауза таму, и можете да го испечатите, на пример, вредноста на ниска или висока.
И така постојат еден куп команди што треба да знаете,
и ова слајдшоу ќе одат нагоре на веб страната,
па ако само сакате да референца овие или како да ги стави на вашиот измамник листови, се чувствуваат слободни.
>> Кул. Тоа беше квиз Преглед 0, а ние ќе останат околу, ако имате било какви прашања.
Во ред.
>> [Аплауз]
>> [CS50.TV]