>> დავით Malan: ყველა უფლება, მივესალმებით უკან.
ეს არის CS50.
ეს არის დაწყების კვირაში შვიდი.
ასე რომ, ეს იყო მაშინ, როდესაც, ასე მეგონა, ჩვენ მინდა მიიღოს whirlwind ტური, სადაც ჩვენ
შეჩერდით და სადაც ჩვენ ახლა მიმდინარეობს.
>> ასე რომ, ეს ისაა შესაძლოა, გამოიწვია angst დროს გააკეთა.
მაგრამ იმედია, თქვენ იწყებს acclimate, თუ რა ეს ნიშნავს აქ -
ვარსკვლავი წარმოადგენს მაჩვენებელი, რომელიც უბრალოდ, რა, უფრო layman პირობები?
ასე რომ, მისამართი.
>> ასე რომ, ეს მისამართი რაღაც მეხსიერებაში.
და დავიწყეთ კანი უკან ფენების რამდენიმე კვირის წინ, რამ მინდა
GetString და სხვა მსგავსი ფუნქციები მთელი ამ ხნის განმავლობაში დაბრუნების
მისამართები რამ მეხსიერებაში, ისევე როგორც მისამართი პირველი პერსონაჟი
ზოგიერთი თანმიმდევრობით.
>> ასე რომ, ჩვენ ასევე გააცნო valgrind, რომელიც თქვენ დაიწყება გამოყენება ამ პრობლემის
დადგენილი არ არის, განსაკუთრებით მომავალი პრობლემა მითითებული ასევე.
და valgrind აკეთებს იმას, რასაც ჩვენთვის?
ის ამოწმებს მეხსიერების ტბები, და ეს აგრეთვე ამოწმებს ბოროტად მეხსიერება.
>> მას შეუძლია, გარკვეული ალბათობით, აღმოაჩინოს, თუ თქვენი კოდი აპირებს შეეხოთ მეხსიერება
რომ ეს უბრალოდ არ უნდა.
ასე რომ, არ არის აუცილებელი გაჟონვის, მაგრამ თუ გასცდება საზღვრების ზოგიერთი
მასივი, და რეალურად აწარმოებს valgrind და გამოიწვიოს, რომ ქცევის ხოლო
valgrind არის გაშვებული თქვენი პროგრამა არის გაშვებული შიგნით მას, თქვენ შეძლებთ
შეტყობინებები ასე - "ინვალიდი წერენ of ზომა 4 ", რომელიც, გავიხსენოთ რამოდენიმე
კვირის წინ იმას ნიშნავდა, რომ მე მქონდა შემთხვევით მინდა ერთ int შორს
საზღვრებს გარეთ მასივი.
ასე რომ ზომით 4 ნიშნავს აქ ზომა კონკრეტული int.
>> ასე რომ მიიღოს reassurance, რომ valgrind ის გამომუშავება, ფორმატი, რომ,
მხოლოდ ბარბაროსულ.
ეს მართლაც ძნელი ვხედავ მეშვეობით არეულობას საინტერესო ინფორმაცია.
ასე რომ, ის, რაც ჩვენ გავაკეთეთ აქ მხოლოდ ნაწყვეტია ზოგიერთი რამოდენიმე უფრო
საინტერესო ხაზები.
მაგრამ გააცნობიეროს, რომ 80% valgrind ნახვა გამომავალი იქნება ცოტა
განადგურების.
>> უბრალოდ ვეძებთ ნიმუშების ასეთი - ბათილად უფლება, არასწორი წავიკითხე, 40 bytes
და ზოგიერთი რაოდენობის ბლოკის ნამდვილად დაკარგული, საკვანძო სიტყვა იგრძნობა.
და რა თქვენ იმედია ვხედავ რაღაც სახის კვალი რა ფუნქცია
შეცდომა, ფაქტობრივად, სისტემაში
ამ შემთხვევაში აქ, რა ხაზი ჩემი კოდი იყო შეცდომა როგორც ჩანს?
>> 26 ფაილი სახელად memory.c, რომელიც მაგალითად ჩვენ თამაშობს
დროს.
ასე რომ, ეს, ალბათ, არ malloc.
ეს იყო, ალბათ, ჩემს კოდი ნაცვლად.
ასე რომ, ჩვენ დავინახავთ, ეს კიდევ ერთხელ და კიდევ დიდი ხნის განმავლობაში.
>> ასე რომ scanf, ეს გამოვიდა in რამდენიმე ფორმები დღემდე.
ჩვენ ვნახეთ sscanf მოკლედ.
ეს იყო რაღაც რაოდენობის თქვენ საპირისპირო მხარეს ბურთის შევიდა თქვენს
მზადება ვიქტორინა.
და scanf ფაქტიურად რა CS50 ბიბლიოთეკის იყენებს ქვეშ
hood საკმაოდ გარკვეული დრო, რათა მიიღონ შეიტანენ შესახებ.
>> მაგალითად, თუ მე გადაადგილება მეტი CS50 მოწყობილობის აქ, ნება მომეცით გახსნა
მაგალითად დღეს, რომ ე.წ. scanf-0.c და ეს სუპერ მარტივია.
ეს მხოლოდ რამდენიმე ხაზი კოდი.
მაგრამ ეს მეტყველებს იმაზე, მართლა როგორ getInt მუშაობს ყველა ამ დროს.
>> ამ პროგრამაში აქ, ხაზი 16 , ცნობა, რომ ვაცხადებ, int.
ასე რომ არ მითითებას, არაფერი ჯადოსნური იქ, უბრალოდ int.
შემდეგ ხაზი 17, მე შეგახსენებთ მომხმარებლის რიგი, გთხოვთ.
მაშინ გვიან 18, მე scanf აქ.
და მე მითითებული, სახის როგორც printf, რომ მე ველოდებით გაცემა
unquote პროცენტს i.
>> ასე პროცენტს i, რა თქმა უნდა, აღნიშნავს int.
მაგრამ შეამჩნია რა მეორე არგუმენტი scanf არის.
როგორ დაახასიათებდით მეორე არგუმენტი შემდეგ მძიმე?
რა არის ეს?
>> ეს მისამართი x.
ასე რომ, ეს მოსახერხებელია, რადგან უზრუნველყოფით scanf ერთად მისამართი x, რას
რომ მისცეს, რომ ფუნქცია უნდა გავაკეთოთ?
და არა მარტო იქ დადიან, არამედ რა?
>> გააკეთეთ შეცვლის მას.
იმის გამო, რომ თქვენ შეიძლება იქ, ეს ერთგვარი ისევე როგორც რუკაზე ადგილმდებარეობის მეხსიერებაში.
ასე რომ, სანამ თქვენ მიერ მოწოდებული scanf, ან ნებისმიერი ფუნქციის ასეთი რუკა, რომელიც
ფუნქციის წავალთ, და არა მარტო შეხედეთ ღირებულება, მაგრამ ასევე
შეცვლის ღირებულება, რომელიც სასარგებლოა, თუ მიზანი ცხოვრებაში scanf არის
სკანირების შეიტანენ შესახებ, კერძოდ ეხლა კლავიატურაზე.
და ვ აღნიშნავს ფორმატირებული, ისევე, როგორც printf, ვ აღნიშნავს ფორმატირებული
სიმებიანი რომ გსურთ ბეჭდვა.
>> ასე რომ, მოკლედ, ამ ხაზის 18 უბრალოდ ამბობს, ცდილობენ წაიკითხონ int ეხლა მომხმარებლის
კლავიატურის და ჩაწერს მას შიგნით x, ზე რაც არ უნდა მისამართზე x მოხდება ცხოვრობს.
და მაშინ ბოლოს, ხაზის 19 მხოლოდ ამბობს, მადლობა int, ამ შემთხვევაში.
>> ნება მომეცით, წავიდეთ წინ და ეს.
ასე რომ scanf 0.
ნება მომეცით წავიდეთ წინ და მასშტაბის სისტემაში
წავალ და აწარმოებს ამ მიზნით წერტილების სლეში scanf 0.
პუნქტების გთხოვთ?
50.
მადლობა 50.
ასე რომ, ეს საკმაოდ მარტივია.
>> ახლა რა არის ეს არ ვაკეთებთ?
ეს არ აკეთებს მთელი bunch შეცდომის შემოწმება.
მაგალითად, თუ არ ითანამშრომლებენ და მე არ აკრიფოთ ნომერი, მაგრამ
ნაცვლად ვწერ რაღაც "hello," ეს მხოლოდ სახის უცნაურია.
ასე რომ, ერთი რამ CS50 ბიბლიოთეკა აკეთებდა ჩვენთვის გარკვეული
დრო არის, რომ reprompting და reprompting.
>> კვალვ ფრაზა გაწვევას იყო cs50.c, და ეს იმ მიზეზით, რომ getInt in
CS50 ბიბლიოთეკა ფაქტიურად მთელი რამოდენიმე ხაზების ხანგრძლივი აღმოჩნდა, რადგან ჩვენ
შემოწმების სულელური პერსონალი მოსწონს ეს.
ხომ შესახებ არ აძლევს ჩვენთან, ფაქტობრივად, int?
ნუთუ მას მოგვცეს რაღაც ისევე როგორც ანბანურ წერილი?
თუ ეს ასეა, ჩვენ გვინდა, რომ აღმოაჩინოს რომ და დაწეროთ მათ.
>> მაგრამ რამ უფრო საინტერესო ამ მორიგი მაგალითია.
თუ მე scanf-1.c, რა არის ერთი რაც ძირეულად შეიცვალა
ამ მომავალი მაგალითად?
მე გამოყენებით char *, რა თქმა უნდა, ნაცვლად int.
>> ასე რომ, ეს საინტერესოა, ვინაიდან char *, გავიხსენოთ, მართლაც მხოლოდ
იგივე როგორც სიმებიანი.
ასე რომ, ეს იგრძნობა იქნებ ეს სუპერ მარტივი განხორციელება GetString.
მაგრამ მე peeled უკან ფენის საქართველოს CS50 ბიბლიოთეკა, ასე რომ მე ვარ
მოუწოდებდა ამ char * ახლა.
მოდით ვნახოთ, სად, თუ სადმე ჩვენ არასწორია.
>> ხაზი 17 -
კიდევ ერთხელ ვთქვა, გთხოვთ, მომეცი რამე, ამ შემთხვევაში, მხოლოდ.
და მაშინ შემდეგ ხაზზე, მოვუწოდებ scanf, ერთხელ, რაც მას ფორმატში კოდი,
მაგრამ ამ დროს პროცენტს s.
შემდეგ კი ამ დროს, მე ვარ რაც მას ბუფერულ.
>> ახლა შეამჩნია, მე არ იყენებს ampersand.
მაგრამ რატომ არის, რომ ალბათ კარგი აქ?
იმის გამო, რომ ის, რაც ბუფერული უკვე?
უკვე მაჩვენებელი.
უკვე მისამართი.
>> და მოდით ეს სიტყვა "აღრეული," ნება მომეცით მხოლოდ მას s, მაგალითად, for
სიმარტივის.
მაგრამ მე მას ბუფერში რადგან ზოგადად, პროგრამირებაში, თუ თქვენ გაქვთ
ბლოკი მეხსიერება, რომელიც სიმებიანი ნამდვილად უბრალოდ, შეიძლება ეძახით ბუფერულ.
ეს ადგილი ინფორმაციის შესანახად.
>> მსგავსი რამ, როგორიცაა YouTube, როდესაც ისინი buffering, ასე ვთქვათ, რომ
მხოლოდ იმას ნიშნავს რომ ჩამოტვირთვის bits დან ინტერნეტისა და შენახვა მათ
ადგილობრივი მასივი, ადგილობრივი ბლოკი მეხსიერება ისე რომ თქვენ შეგიძლიათ ნახოთ მოგვიანებით გარეშე
ეს skipping ან ჩამოკიდებული თქვენ თამაშის დროს უკან.
>> ასე რომ პრობლემა იმისა, იმიტომ, რომ მე ვეუბნებოდი scanf, ველით
ნახატზე შესახებ.
აი მისამართი ბლოკი მეხსიერება.
დააყენა, რომ სიმებიანი არსებობს.
რატომ არის, რომ ბლოკნოტებს მისცეს ჩვენს უბედურება, თუმცა?
>> რა არის ეს?
მე დაშვებული წვდომის რომ ნაწილი მეხსიერება?
თქვენ იცით, მე არ ვიცი.
იმის გამო, რომ არ ბუფერული იქნა ინიციალიზაცია არაფერი?
ნამდვილად არ.
ასე რომ, ეს არის ის, რაც ჩვენ უკვე მოუწოდებენ ნაგვის ღირებულება, რომელიც
ოფიციალურად არ სიტყვა.
ეს უბრალოდ ნიშნავს, რომ ჩვენ არ ვიცი რა bits შიგნით ოთხი ბაიტი, რომ
მე არ გამოუყო ბუფერულ.
>> მე არ მოუწოდა malloc.
მე ნამდვილად არ მოუწოდა GetString.
ასე რომ, ვინ იცის, რა ხდება რეალურად შიგნით ბუფერული?
და მაინც ეუბნება scanf ბრმად, იქ ჩასვლა და ამით რა შესახებ აკრეფილი.
>> რა არის სავარაუდოდ გამოიწვევს ჩვენს კოდი თუ ჩვენ აწარმოებს იგი?
ალბათ segfault.
შესაძლოა, არა, მაგრამ ალბათ segfault.
და მე ვიტყვი, შესაძლოა, არა იმიტომ, რომ ზოგჯერ თქვენ, ზოგჯერ
თქვენ არ მიიღოს segfault.
ხანდახან უბრალოდ გაუმართლა, მაგრამ ის მაინც იქნება
ხარვეზების ჩვენი პროგრამა.
>> ნება მომეცით, წავიდეთ წინ და შეადგინოს ამ.
მე ვაპირებ ამის გაკეთება ძველი სკოლა გზა.
ასე რომ clang ტირე 0, scanf-1, scanf-1.c, შეიტანეთ.
ვაი, მოძველებულია სკოლა.
ვნახოთ.
სად წავიდე?
Oh, char * ბუფერულ.
Oh, მადლობა -
შენახვა, OK -
ძალიან ძველი სკოლა.
ყველა უფლება, ეს იყო, ხოლო.
>> ასე რომ, მე მხოლოდ შენახული ფაილი შემდეგ მიღების, რომ დროებითი
შეცვლის მომენტში წინ.
ახლა კი არ შედგენილი ეს ხელით Clang.
ახლა კი მე ვაპირებ წავიდეთ წინ და აწარმოებს scanf-1, შეიტანეთ.
სიმებიანი გთხოვთ.
მე აკრიფოთ "hello."
>> ახლა კი, აქ, სადაც, გულახდილად, printf შეიძლება ცოტა შემაშფოთებელი.
ეს რეალურად არ აპირებს segfault ამ შემთხვევაში.
Printf ცოტა სპეციალური რადგან ასე სუპერ გამოიყენება, რომ
არსებითად printf აკეთებს ჩვენს სასარგებლოდ და ხვდებიან,
ეს არ არის სწორი მაჩვენებელი.
ნება მომეცით მიიღოს ეს იმ თავს მხოლოდ ბეჭდვა out ფრჩხილებში null, მაშინაც კი,
თუმცა ეს არ არის აუცილებელი, თუ რა ჩვენ თვითონ მოსალოდნელია.
>> ასე რომ, ჩვენ ვერ ადვილად გამოიწვიოს segfault ერთად, მაგრამ აშკარაა, რომ ეს
არ არის ქცევა მინდოდა.
რა არის მარტივი გამოსავალი?
ასევე, scanf-2, ნება მომეცით ინიციატივით კი, ნაცვლად რეალურად მხოლოდ განაწილების
char *, ნება მომეცით პატარა ჭკვიანია შესახებ ეს, და ნება მომეცით გამოყოფს ბუფერული
როგორც რიგითობა 16 სიმბოლო.
>> ასე, რომ შეიძლება ამის გაკეთება რამდენიმე გზა არსებობს.
მე ვერ აბსოლუტურად გამოიყენოთ malloc.
მაგრამ მე დაბრუნდეს კვირაში ორი როდესაც უბრალოდ საჭიროა მთელი bunch of
სიმბოლო.
ეს მხოლოდ მასივი.
ნება მომეცით, ნაცვლად განისაზღვროს ბუფერული უნდა იყოს მასივი 16 სიმბოლოს.
>> ახლა, როდესაც მე გაივლის ბუფერული in -
და ეს არის ის, რაც ჩვენ არ ვისაუბროთ ამ კვირაში ორი -
მაგრამ შეგიძლიათ მკურნალობა წყობის თუმცა მისამართი.
ტექნიკური თვალსაზრისით, როგორც ჩვენ ვნახეთ, ისინი ცოტა განსხვავებული.
მაგრამ scanf არ იბადება, თუ თქვენ გაიაროს ეს სახელი მასივი, რადგან რა
Clang გავაკეთებთ ჩვენთვის არსებითად მკურნალობა სახელით რომ მასივს როგორც
მისამართი ბლოკი 16 ბაიტს.
>> ასე რომ, ეს უკეთესია.
ეს ნიშნავს, რომ მე არ შემიძლია იმედია გავაკეთოთ შემდეგ.
ნება მომეცით დააშორებს ერთი წუთით და ამის გაკეთება გააკეთოს scanf-2, შედგენილი OK.
ახლა ნება მომეცით არ მივიღე ხაზი scanf-2.
სიმებიანი გთხოვთ. "Hello". და ეს როგორც ჩანს, მუშაობა ამ დროს.
>> მაგრამ ვინმე შესთავაზოს სცენარი რომელშიც ის შეიძლება ჯერ კიდევ მუშაობს?
ჰო?
რაღაც უმეტეს 16 სიმბოლოს.
და ფაქტობრივად, ჩვენ შეიძლება უფრო ზუსტი.
რაღაც აღარ შემდეგ 15 პერსონაჟი, იმიტომ, რომ რეალურად ჩვენ უნდა გვახსოვდეს
რომ ჩვენ გვჭირდება, რომ წარმატებული ნულოვანი ირიბად დასასრულს ტექსტი,
რაც განზე scanf, როგორც წესი ვიზრუნოთ ჩვენთვის.
>> ნება მომეცით, ამის გაკეთება რაღაც -
ზოგჯერ ჩვენ უბრალოდ დატოვონ ეს იგრძნობა.
OK, ასე რომ, ჩვენ ახლა გამოწვეული ჩვენი სეგმენტაცია ბრალი.
რატომ?
იმიტომ, რომ მე აკრეფილი, რომ 15 და მეტი გმირები და ა.შ. ჩვენ, ფაქტობრივად,
შეეხო მეხსიერება, რაც მე რეალურად არ უნდა ჰქონდეს.
>> რა არის რეალურად გადაწყვეტა აქ?
ისე, რა, თუ ჩვენ გვჭირდება აღარ სიმებიანი?
ასევე, ჩვენ, შესაძლოა, რომ მას 32 ბაიტს.
ისე, რა, თუ ეს არ არის საკმაო?
როგორ შესახებ 64 bytes?
რა მოხდება, თუ ეს არ არის საკმაო?
როგორ შესახებ 128 ან 200 bytes?
რა არის გამოსავალი აქ ზოგადი შემთხვევაში, თუ ჩვენ არ ვიცით,
რას შესახებ ხდება შეიტანოთ?
>> უბრალოდ ასეთი დიდი ტკივილი ass, მართალი გითხრათ, რის გამოც
CS50 ბიბლიოთეკას აქვს რამდენიმე ათეული ხაზი კოდი, ერთობლივად განახორციელონ
GetString სიმებიანი ისე, რომ ჩვენ არ უნდა ვიცოდეთ წინასწარ რა
მომხმარებლის აპირებს ტიპის.
კერძოდ, თუ თქვენ ვიხსენებთ cs50.c ორი კვირის წინ, დაინახავთ,
რომ GetString რეალურად აკეთებს არ გამოიყენოთ scanf ამ გზით.
უფრო მეტიც, ნათქვამია მოხსენებაში ერთი ხასიათი დროს.
>> იმის გამო, რომ ერთი ლამაზი რამ კითხულობს ერთი გმირი შეგვიძლია
გარანტიას თავს ყოველთვის აქვს მინიმუმ ერთი char.
მე შემიძლია მხოლოდ განაცხადოს, char, და შემდეგ მიიღოს ეს მართლაც ბავშვი ნაბიჯები მხოლოდ
წავიკითხე ერთ პერსონაჟს ზე დროს კლავიატურაზე.
შემდეგ კი, რაც თქვენ დაინახავთ GetString აკეთებს ყოველ ჯერზე ეს ამოიწურება,
ამბობენ, 16 ბაიტი მეხსიერების, იგი იყენებს malloc, ან დეიდაშვილი მისი, რათა
გამოყოფს მეტი მეხსიერების, გადაწერა წლის მეხსიერება ახალ და შემდეგ მცოცავი
გასწვრივ, მიღების ერთი ხასიათი დროს, და როდესაც ამოიწურება, რომ
ბლოკი მეხსიერება, ისვრის ის დაშორებით, grabs უფრო დიდი ბლოკი მეხსიერება, ასლები წლის
ახალ და იმეორებს.
და ეს მართლაც ტკივილი, რეალურად განახორციელოს რაიმე ისეთი მარტივი, როგორც
მიღების შეიტანენ შესახებ.
>> ასე რომ, შეგიძლიათ გამოიყენოთ scanf.
თქვენ შეგიძლიათ გამოიყენოთ სხვა მსგავსი ფუნქციები.
და ბევრი სახელმძღვანელოები და ონლაინ მაგალითები, მაგრამ ისინი ყველა
დაუცველი პრობლემების მოსწონს ეს.
და საბოლოო ჯამში, არც segfault ერთგვარი შემაშფოთებელი.
ეს არ არის კარგი შესახებ.
>> მაგრამ უკიდურეს შემთხვევაში, რას ეს ფუნდამენტურად თქვენს
კოდი რისკის ქვეშ?
ზოგიერთი სახის თავდასხმა, პოტენციურად.
ჩვენ ვისაუბრეთ ერთი ასეთი თავდასხმის - overflowing დასტის.
მაგრამ ზოგადად, თუ თქვენ უფლება აქვთ overflow ბუფერული, ისე, როგორც
რამდენიმე კვირის წინ, მხოლოდ წერილობით ზე მეტი "Hello" on დასტის, თქვენ
შეიძლება მართლაც აღება, პოტენციურად, კომპიუტერული, ან თუნდაც მიიღოთ მონაცემები,
არ ეკუთვნის თქვენ.
>> ასე რომ, მოკლედ, სწორედ ამიტომ ჩვენ გვაქვს იმ სასწავლო დისკები.
მაგრამ ახლა, ჩვენ ვიწყებთ მათ off, როგორც ჩვენი პროგრამების აღარ,
აუცილებლად, შეიტანენ შესახებ.
მაგრამ იმ შემთხვევაში, თუ პრობლემა მითითებული ექვსი, თქვენი შეტანის მოვა დიდი
ლექსიკონის ფაილი 150 ზოგიერთ უცნაური ათასი სიტყვა.
>> ასე რომ თქვენ არ უნდა ფიქრი მომხმარებლის თვითნებური შეყვანა.
ჩვენ მოგაწვდით რამდენიმე ვარაუდები ამის შესახებ ფაილი.
ნებისმიერი შეკითხვა მითითებას ან scanf ან მომხმარებელი შეტანის ზოგადად?
>> ყველა უფლება, ასე სწრაფი, მაშინ ერთ არასასურველი თემა ორი კვირის წინ.
და ეს იყო ამ ცნება struct.
არა, რომ - ეს ცნება struct, რომელიც რა?
რა struct ჩვენთვის?
>> განსაზღვრა -
ბოდიში?
განსაზღვრა ცვლადი ტიპის.
ასე რომ, ერთგვარი.
ჩვენ, ფაქტობრივად, რომელიც აერთიანებს ორი თემა.
ამრიგად, typedef, გავიხსენოთ, რომ ჩვენ შეგვიძლია ვაცხადებ ტიპის ჩვენი, ისევე როგორც
სინონიმი, ისევე როგორც სიმებიანი for char *.
მაგრამ მისი გამოყენება typedef და struct, ჩვენ შეგვიძლია შექმნა ჭეშმარიტად ჩვენი საკუთარი მონაცემების სტრუქტურებში.
>> მაგალითად, თუ მე ისევ gedit აქ მხოლოდ ერთი წუთით, და მე წავიდეთ წინ
და ამის გაკეთება, რომ მსგავსი რამ, ნება მომეცით გადარჩენა ეს, ასე ვთქვათ, structs.c
დროებით, მე მხოლოდ აპირებს წასვლა წინ და მოიცავს
standardio.h, int მთავარი ბათილად.
შემდეგ კი აქ, ვივარაუდოთ, რომ მინდა დაწერა პროგრამა, რომელიც ინახავს
მრავალჯერადი სტუდენტები სხვადასხვა სახლები, მაგალითად.
ასე რომ, ეს როგორც registrarial მონაცემთა ბაზის რაიმე სახის.
>> ასე რომ, თუ მე უნდა სახელის ერთი სტუდენტი, I შეიძლება გავაკეთოთ, რომ მსგავსი რამ char * სახელი და გვარი,
და გავაკეთებ, რაღაც -
რეალურად, მოდით გამოვიყენოთ CS50 ბიბლიოთეკა მხოლოდ ერთი წუთით, რომ ეს
ცოტა მარტივი, ასე რომ სესხი აიღონ იმ ათობით ხაზი კოდი.
და მოდით უბრალოდ შეინახოს იგი მარტივია.
ჩვენ გავაგრძელებთ ეს ტექსტი, და ახლა GetString.
>> ასე რომ, პრეტენზია, რომ მე შენახული სახელი ზოგიერთი სტუდენტი, და სახლში
ზოგიერთი სტუდენტი, უბრალოდ გამოყენებით ცვლადები ისე, როგორც და კვირაში ერთი.
თუმცა ვივარაუდოთ, მე ახლა მინდა მხარდასაჭერად მრავალჯერადი სტუდენტებს.
ყველა უფლება, ასე რომ ჩემი ინსტინქტები უნდა გააკეთოს სიმებიანი სახელი 2, იღებს GetString, სიმებიანი
house2 იღებს GetString.
შემდეგ კი, მესამე სტუდენტი, მოდით name3 GetString.
>> ყველა უფლება, ასე რომ ეს არის იმედია ნათელი თქვენ, როგორც ასეთი სულელური,
რადგან ეს პროცესი მართლაც არასდროს აპირებს დასრულდება და ეს მხოლოდ აპირებს
რომ ჩემი კოდი გამოიყურება უარესი და უარესი და უარესი.
მაგრამ ჩვენ მოგვარდება ეს ძალიან in კვირაში ორი.
რა იყო ჩვენი შედარებით სუფთა გადაწყვეტა როცა მრავალი ცვლადი
იგივე მონაცემების ტიპის, რომ ყველა დაკავშირებული, მაგრამ ჩვენ არ გვინდოდა ამ ბარბაროსულ არეულობას
საქართველოს მსგავსად დაასახელა ცვლადები?
რა ვაკეთებთ ნაცვლად?
>> ამიტომ ვფიქრობ, მე მოვისმინე რამდენიმე ადგილას.
ჩვენ გვქონდა მასივი.
თუ გსურთ მრავალი ფაქტი რაღაც, რატომ არ გვაქვს გაწმენდა ეს ყველაფერი
მდე და უბრალოდ, ვამბობთ, მომეცი მასივი მოუწოდა სახელები?
>> და ახლა, მოდით მძიმე კოდი 3.
და მაშინ მაძლევს კიდევ ერთი მასივი მოუწოდა სახლები, და მოდით ჩემთან
ახლა მძიმე კოდი 3.
და მე მასიურად დაასუფთავეს არეულობას, რომ უბრალოდ შეიქმნა.
ახლა, მე ამ დრომდე მძიმეა კოდირებული 3, არამედ 3 შეიძლება დინამიურად მოდის
შესახებ, ან argv, ან ანალოგიური.
ასე რომ, ეს უკვე სუფთა.
>> მაგრამ რა არის შემაშფოთებელი ის არის, რომ ახლა, მიუხედავად იმისა, რომ სახელი არის რატომღაც
ფუნდამენტურად უკავშირდება სტუდენტის სახლი -
ეს სტუდენტი, რომ მე ნამდვილად გვინდა წარმოადგენს -
ახლა გვაქვს ორი მასივების, რომლებიც პარალელურად იმ გაგებით, რომ ისინი
იგივე ზომა და სახელები bracket 0 სავარაუდოდ რუკების სახლები bracket 0,
და სახელები bracket 1 რუკები სახლებში bracket 1.
სხვა სიტყვებით, რომ სტუდენტთა ცხოვრობს ეს სახლი, და რომ სხვა სტუდენტურ
სიცოცხლე ამ მეორე სახლი.
მაგრამ ნამდვილად ეს შეიძლება გაკეთდა კიდევ უფრო cleanly.
>> ასევე, ის შეიძლება, ფაქტობრივად.
და ნება მომეცით წავიდეთ წინ და გახსნა up structs.h, და თქვენ
რომ ეს იდეა აქ.
გავითვალისწინოთ რომ მე გამოიყენება typedef, როგორც თქვენ გააკეთა მინიშნება მომენტში წინ გამოაცხადოს ჩვენი
საკუთარი მონაცემების ტიპის.
მაგრამ მე ასევე გამოყენებისას სხვა სიტყვით მოუწოდა struct რომელიც მაძლევს new
მონაცემთა სტრუქტურას.
>> ეს მონაცემთა სტრუქტურის I აცხადებენ, რომ აპირებს აქვს ორი რამ შიგნით
ეს - სიმებიანი მოუწოდა სახელი და სიმებიანი მოუწოდა სახლში.
და სახელი მე ვაპირებ მისცეს მონაცემთა ამ სტრუქტურის აპირებს
ე.წ. სტუდენტი.
მე ვერ ვუწოდებ არაფერი მინდა, მაგრამ ეს სემანტიკურად გააკეთოს
აზრი ჩემს გონებაში.
>> ასე რომ, ახლა, თუ გახსნა უკეთესი მობილური პროგრამის დავიწყე წერა
იქ, ნება მომეცით გადახვევის დასაწყისში.
წინ კიდევ რამდენიმე ხაზი კოდი აქ, მაგრამ ნება მიბოძეთ ყურადღება გავამახვილო იმ
მომენტი ერთ.
მე განაცხადა, მუდმივი წ სტუდენტები და მძიმე კოდირებული 3 ახლა.
მაგრამ ახლა, შეამჩნია როგორ სუფთა ჩემი კოდი იწყება მისაღებად.
>> შესაბამისად 22, ვაცხადებ მასივი სტუდენტებს.
და შეამჩნია, რომ სტუდენტთა აშკარად ახლა მონაცემთა ტიპის.
იმის გამო, რომ ზედა ფაილის შეამჩნია მე მოიცავს თავით ფაილი
რომ მე გამოყვანილია მხოლოდ ერთი წუთით წინ.
და ეს თავით ფაილი უბრალოდ იძულებული ამ განმარტებას სტუდენტი.
>> ასე რომ, ახლა, მე შექმნა საკუთარი საბაჟო მონაცემთა ტიპის, რომ ავტორები C წელი
წინ არ ვფიქრობ წინასწარ.
მაგრამ არ არის პრობლემა.
მე შემიძლია იგი თავს.
ასე რომ, ეს მასივი მოუწოდა სტუდენტები, თითოეული რომლის წევრებიც
არის სტუდენტი სტრუქტურა.
და მე მინდა სამი მათგანი მასივში.
>> ახლა კი, რას დანარჩენი ამ პროგრამის გაკეთება?
მჭირდებოდა რაღაც პატარა თვითნებური.
ასე რომ, ონლაინ 24 შემდგომი, მე iterate 0 დან 3.
მე ვთხოვ შესახებ for სტუდენტის სახელი.
და მაშინ მე GetString, როგორც ადრე.
მერე ითხოვენ სტუდენტის სახლი, და მე GetString, როგორც ადრე.
>> მაგრამ შეამჩნია - ოდნავ new ნაწილი syntax -
მე მაინც ინდექსი, რომლებიც I-th სტუდენტი, მაგრამ როგორ მივიღებ ერთი კონკრეტული მონაცემები
სფეროში შიგნით struct?
ისე, რა როგორც ჩანს ახალი ნაწილი syntax?
უბრალოდ dot ოპერატორი.
>> ჩვენ ნამდვილად არ მინახავს ეს ადრე იყო.
ვნახე ის pset ხუთ თუ თქვენ საპირისპირო მხარეს ბურთის უკვე bitmap ფაილი.
მაგრამ dot მხოლოდ იმას ნიშნავს, შიგნით ამ struct ან მრავალჯერადი სფეროებში, მისცეს dot
სახელი და გვარი, ან მომეცი dot სახლში.
ეს იმას ნიშნავს, წავიდეთ შიგნით struct და მიიღოს იმ კონკრეტულ სფეროებში.
>> რას დანარჩენი ამ პროგრამის გაკეთება?
ეს არ არის ყველა, რომ სექსუალური.
გავითვალისწინოთ, რომ მე iterate 0 დან 3 ერთხელ, და მე უბრალოდ ინგლისური
ფრაზა, როგორიც ასე და ასე არის თუ ისე ასეთი სახლი, გადადის dot სახელი
i-th სტუდენტი და მათი სახლი ასევე.
>> და მაშინ ბოლოს, ახლა დავიწყებთ მისაღებად anal შესახებ, ახლა რომ ჩვენ
იცნობს რა malloc და სხვა ფუნქციების ყოფილიყო
აკეთებს ყველა ამ დროს.
რატომ უნდა გავათავისუფლოთ ორივე სახელი და სახლში, მიუხედავად იმისა, რომ მე
არ გამოიძახა malloc?
>> GetString გააკეთა.
და ეს იყო ბინძური პატარა საიდუმლო რამდენიმე კვირის განმავლობაში, მაგრამ GetString აქვს
უკვე ჩამოდის მეხსიერების მთელი მიიტანეთ ყველა სემესტრში დღემდე.
და valgrand საბოლოოდ გამოავლენს ამ ჩვენთვის.
>> მაგრამ ეს არ არის დიდი გარიგება, რადგან ვიცი, რომ მე შემიძლია უბრალოდ გასათავისუფლებლად სახელი
და სახლში, თუმცა ტექნიკურად, რათა იყოს სუპერ, სუპერ უსაფრთხო, ასეც უნდა იყოს
აკეთებს რაიმე შეცდომა შემოწმების აქ.
როგორია თქვენი ინსტინქტები გეუბნებით?
რა უნდა იყოს შემოწმება სანამ გასათავისუფლებლად, რა არის
სიმებიანი, aka რომელიც char *?
>> მე ნამდვილად უნდა იყოს შემოწმების, თუ სტუდენტები bracket i dot სახელი არ
თანაბარი null.
მაშინ ეს იქნება კარგი, რომ წავიდეთ წინ და თავისუფალი რომ მაჩვენებელი და იმავე ან სხვა
ერთი ასევე.
თუ სტუდენტები bracket i dot სახლში არ არის ტოლია null, ეს ახლა დაიცავს
წინააღმდეგ კუთხეში შემთხვევაში, რომელშიც GetString ბრუნდება რაღაც null.
და დავინახეთ მომენტში წინ, printf იქნება მფარველი აქ მხოლოდ ამბობდა
null, რომელიც აპირებს გამოიყურება უცნაურია.
მაგრამ მაინც ეს არ segfault, როგორც ვნახეთ.
>> ისე, მინდა გავაკეთოთ ერთი რამ აქ. structs-0 ერთგვარი სულელური პროგრამა
იმიტომ, რომ მე შევა ყველა ამ მონაცემთა, შემდეგ კი ეს დაკარგული ერთხელ პროგრამა დასრულდება.
მაგრამ ნება მიბოძეთ წავიდეთ წინ და ამის გაკეთება.
ნება მომეცით მიიღოს ტერმინალში ფანჯარა ცოტა დიდია.
ნება მომეცით მიიღოს structs-1, რომელიც ეს არის ახალი ვერსია ეს.
>> მე გასადიდებლად ცოტა.
ახლა კი ნება მომეცით აწარმოებს dot სლეში structs-1.
სტუდენტური სახელი -
დავით Mather, მოდით Rob KIRKLAND, მოდით ლორენ Leverett.
რა არის საინტერესო ახლა არის შეტყობინება -
და მე მხოლოდ ვიცი, რადგან დავწერე პროგრამა -
არსებობს ფაილი ამიერიდან ჩემი მიმდინარე კატალოგი, სახელწოდებით students.csv.
ზოგიერთ თქვენგანს შეიძლება მინახავს ამ რეალურ ცხოვრებაში.
>> რა არის CSV ფაილი?
Comma-გამოყოფილი ღირებულებებს.
ეს ერთგვარი მოსწონს ღარიბი ადამიანის მობილური Excel ფაილი.
ეს მაგიდასთან რიგები და სვეტები, რომ შეგიძლიათ გაიხსნება პროგრამა, როგორიცაა Excel,
ან ნომრები Mac.
>> და თუ ამ ფაილის გახსნის აქ gedit, გაფრთხილების - და ციფრები არ არის.
ეს მხოლოდ gedit ვეუბნებოდი მე ხაზი ნომრები.
ცნობას პირველი ხაზი ამ ფაილი დავით და Mather.
შემდეგი ხაზი არის Rob მძიმე KIRKLAND.
და მესამე ხაზი ლორენ მძიმე Leverett.
>> მერე რა არ მე შევქმენი?
მე ახლა დაწერილი C პროგრამა, რომელიც ეფექტურად შეიძლება ცხრილები
, რომელიც შეიძლება გაიხსნა პროგრამა, როგორიცაა Excel.
არ არის, რომ დამაჯერებელი მონაცემები ნაკრები, მაგრამ თუ თქვენ გაქვთ გაცილებით მოცულობით
მონაცემები, რომ თქვენ ნამდვილად გინდათ მანიპულირება და მიიღოს გრაფიკის და
მინდა, ეს, ალბათ ერთი გზა შექმნა, რომ მონაცემები.
უფრო მეტიც, CSVs რეალურად სუპერ საერთო მხოლოდ შენახვის მარტივი მონაცემები -
Yahoo Finance, მაგალითად, თუ თქვენ გაქვთ საფონდო ბრჭყალებში მეშვეობით მათი ე.წ.
API, უფასო სერვისი, რომელიც საშუალებას გაძლევთ მიიღონ მიმდინარე თანამედროვე თანამედროვე საფონდო
შესრულების შეთავაზება კომპანიებს, მათ მისცეს მონაცემთა უკან
სუპერ მარტივი CSV ფორმატში.
>> ასე რომ, როგორ მივიღეთ ეს?
კარგად შეამჩნია, ყველაზე მეტად ეს პროგრამა თითქმის იგივე.
მაგრამ შეამჩნია ქვემოთ აქ, ვიდრე ბეჭდვითი სტუდენტები out, ხაზი 35
შემდგომი, მე კი აცხადებენ, რომ მე გადარჩენის სტუდენტები დისკზე, ასე რომ გადარჩენის ფაილი.
>> ასე რომ შეამჩნია მე გამოცხადების ი * -
ახლა, ეს არის ერთგვარი ანომალიაა in C. სხვადსხვა მიზეზის გამო, ფაილი ყველა caps,
რაც არ მოსწონს ყველაზე სხვა მონაცემთა ტიპები in C. მაგრამ ეს ინტეგრირებული
მონაცემთა ტიპის, ი *.
და მე გამოცხადების მომცეთ SVG, არის, თუ როგორ შეიძლება ვიფიქროთ, რომ.
>> fopen ნიშნავს ღია ფაილი.
რა ფაილი გინდათ, გახსნას?
მინდა გახსნა ფაილი, რომელიც მე თვითნებურად მოვუწოდებთ students.csv.
მე ვერ ვუწოდებ, რომ არაფერი მინდა.
>> და მერე ვხვდები.
რას მეორე არგუმენტი to fopen ალბათ ნიშნავს?
მარჯვენა, w for ჩაწერის, შესაძლებელი იქნებოდა იყოს r for წაკითხული.
აქ არის ის დამატება, თუ მინდა დავამატო, რიგები და არა
გადაწერა მთელი რამ.
>> მაგრამ მინდა ამ ფაილის შექმნას ერთხელ, ასე რომ მე გამოიყენოთ გაცემა unquote w.
და ვიცი, რომ მხოლოდ რომელმაც წაიკითხა დოკუმენტაცია, ან კაცი გვერდზე.
თუ ფაილი არ null - სხვა სიტყვებით, თუ არაფერი არ მოხდა ისე იქ -
ნება მომეცით iterate მეტი სტუდენტები 0 დან 3.
>> ახლა კი შეამჩნია რაღაც ოდესმე ისე ოდნავ განსხვავებული
შესახებ ხაზი 41 აქ.
ეს არ არის printf.
ეს fprintf for ფაილი printf.
ასე რომ, ეს ხდება დაწერა შეიტანოს.
რომელი ფაილი?
ერთი, რომლის მაჩვენებელი თქვენს მიერ მითითებული როგორც პირველი არგუმენტი.
>> მაშინ ჩვენ დააკონკრეტა სტრიქონში.
მაშინ ჩვენ დააკონკრეტა, თუ რა სიმებიანი ჩვენ გვინდა plug in პირველად პროცენტს s, და
შემდეგ კი ცვალებად და მეორე პროცენტს s.
მაშინ ჩვენ ახლოს ფაილი fclose.
ვიდრე მე გასათავისუფლებლად მეხსიერება, როგორც ადრე, თუმცა მე უნდა დავუბრუნდეთ და დამატება
ზოგიერთი შეამოწმებს null.
>> და ეს არის ის.
fopen, fprintf, fclose მაძლევს უნარი შექმნას ტექსტი ფაილი.
ახლა, დაინახავთ პრობლემების კომპლექტი ხუთი, რომელიც მოიცავს სურათები, თქვენ გამოიყენებთ
ორობითი ფაილი ნაცვლად.
თუმცა ფუნდამენტურად, იდეა იგივეა, მიუხედავად იმისა, რომ ფუნქციები თქვენ
ვხედავ ცოტა განსხვავებული.
>> ასე რომ, whirlwind ტური, მაგრამ თქვენ მიიღებს ძალიან კარგად იცნობს ფაილი I/O--
შემავალი და გამომავალი - ერთად pset ხუთ.
და რაიმე შეკითხვები საწყის საფუძვლებს აქ?
ჰო?
>> რა მოხდება, თუ თქვენ ცდილობენ გასათავისუფლებლად null მნიშვნელობა?
მე მჯერა, თუ თავისუფალი არ მიღებული ცოტა უფრო მოსახერხებელი, შეგიძლიათ
პოტენციურად segfault.
გამსვლელი ეს null ცუდია რადგან არ გვჯერა, უფასო აწუხებს შესამოწმებლად თქვენ,
რადგან ეს პოტენციურად ნარჩენების დროის ეს უნდა გააკეთოს თავად
ყველას მსოფლიოში.
კარგი კითხვა, თუმცა.
>> ყველა უფლება, ასეთი ტიპის იღებს გვაძლევს საინტერესო თემაზე.
თემა პრობლემა ნაკრები ხუთ არის სასამართლო.
ყოველ შემთხვევაში, რომ ის ნაწილი პრობლემის ნაკრები.
სასამართლო ექსპერტიზის ზოგადად ეხება აღდგენის ინფორმაცია, რომელიც ან
შეიძლება არ წაიშალა შეგნებულად.
ასე რომ მეგონა, მე მინდა გადმოგცეთ სწრაფი გემოს რა ხდება სინამდვილეში ყველა
ამ დროს ქვეშ hood თქვენს კომპიუტერში.
>> მაგალითად, თუ თქვენ გაქვთ შიგნით თქვენი ნოუთბუქი ან თქვენი კომპიუტერი
დისკის, ეს არც მექანიკური მოწყობილობა, რომელიც რეალურად ტრიალებს -
იქ მრგვალი რამ მოუწოდა platters რომ გამოიყურება საკმაოდ მსგავსად, რაც მე
მქონდა up ეკრანზე აქ, თუმცა ეს სულ უფრო და უფრო ძველი სკოლა.
ეს არის სამი და ნახევარი-inch ხისტ დისკზე.
და სამ ნახევარი inches ეხება of ერთად საქართველოს კი ისაა, რომ დააინსტალიროთ
ამ კომპიუტერს.
>> ბევრი ბიჭებს თქვენს ლაპტოპები ახლა აქვს მყარი სახელმწიფო დისკები, ან SSDs,
რომლებმაც არ მოძრავი ნაწილები.
ისინი უფრო ოპერატიული მეხსიერება და ნაკლებად მოსწონს ეს მექანიკური მოწყობილობები.
მაგრამ იდეები რჩება, რა თქმა უნდა, რადგან ისინი ეხება
პრობლემის მითითებული ხუთ.
>> და თუ ფიქრობთ ახლა მყარ დისკზე წარმოადგენს როგორც წრე, რომელიც
მე მიაპყროს მსგავსი აქ.
როდესაც ვქმნით ფაილი თქვენს კომპიუტერში, თუ არა ეს SSD, ან
ამ შემთხვევაში, ძველი სკოლა დისკის, რომ ფაილი მოიცავს მრავალი ბიტი.
ვთქვათ, რომ ეს ამ 0 და 1, მთელი bunch of 0S და 1s.
ასე რომ, ეს მთელი ჩემი მყარ დისკზე.
ეს აშკარად საკმაოდ დიდი ფაილი.
და ეს არის გამოყენებით 0S და 1s იმ ნაწილი ფიზიკური platter.
>> ისე, რა არის, რომ ფიზიკური ნაწილი?
ასევე, ირკვევა, რომ დისკის, სულ მცირე, ამ ტიპის, იქ
ეს პატარა მაგნიტური ნაწილაკების.
ისინი არსებითად აქვს ჩრდილოეთით და სამხრეთ ბოძები მათ, ასე რომ თუ
აქციოს ერთ იმ მაგნიტური ნაწილაკების ამ გზით, შეიძლება ითქვას, რომ ეს
წარმოადგენს 1.
და თუ ეს თავდაყირა სამხრეთით ჩრდილოეთით, შეიძლება ითქვას, რომ ეს
წარმოადგენს 0.
>> ასე რომ რეალურ ფიზიკურ სამყაროში, ეს არის ის, თუ როგორ შეიძლება წარმოადგენს რაღაც
ორობითი მდგომარეობის 0 და 1.
ასე რომ, ყველა ფაილი.
აქ არის მთელი bunch მაგნიტური ნაწილაკების, რომლებიც მათ ამ გზით ან
ამ გზით, ქმნის შაბლონებს საქართველოს 0S და 1s.
>> მაგრამ აღმოჩნდება, როდესაც თქვენ გადარჩენა ფაილი, გარკვეული ინფორმაცია ინახება ცალკე.
ასე რომ, ეს პატარა მაგიდა, დირექტორია, ასე ვთქვათ.
და მე ამას დავარქმევთ სვეტი სახელი და მე მოვუწოდებ ამ სვეტის ადგილას.
>> და მე ვაპირებ ვთქვა, ვარაუდობენ ეს არის ჩემი რეზიუმე.
ჩემი resume.doc ინახება at მდებარეობა, ასე ვთქვათ 123.
მე ყოველთვის წავიდეთ, რომ ნომერი.
მაგრამ საკმარისია ითქვას, რომ ისევე, როგორც in RAM, თქვენ შეუძლია მყარ დისკზე
ეს არის ის, Gigabyte ან 200 გიგაბაიტი ან terabyte, და შეგიძლიათ
ნომერი ყველა bytes.
შეგიძლიათ პუნქტების ყველა მოცულობით 8 ბიტი.
>> ასე რომ, ჩვენ ვთქვა, რომ ეს არის ადგილმდებარეობა 123.
ასე რომ, ამ დირექტორიის შიგნით ჩემს ოპერაციული სისტემის ახსოვს, რომ ჩემი
რეზიუმე ზე ადგილმდებარეობა 123.
მაგრამ ეს ხდება საინტერესო, როდესაც წაშლა ფაილი.
>> ასე მაგალითად -
და საბედნიეროდ, ყველაზე მსოფლიოში დაიჭირეს გადატანა ეს - რა ხდება, როდესაც
თქვენ გადაიტანეთ ფაილი Mac OS Trash ან თქვენი Windows Recycle Bin?
რა მიზნით აკეთებს, რომ?
ეს აშკარად თავი დაეღწია ფაილი, მაგრამ რას აქტი გადმოიყვანა და
მითუმეტეს თქვენს Trash ან თქვენი Recycle Bin აკეთებთ კომპიუტერში?
>> აბსოლუტურად არაფერი, ნამდვილად.
ეს, ისევე, როგორც საქაღალდე.
ეს არის განსაკუთრებული საქაღალდეში, რა თქმა უნდა.
მაგრამ ის რეალურად წაშლის ფაილი?
>> ისე, არა, იმიტომ რომ ზოგი ალბათ უკვე მოსწონს, რა რა, თქვენ არ
ნიშნავს, რომ.
ასე, რომ თქვენ ორჯერ დააწკაპუნეთ Trash ან Recycle Bin.
თქვენ poked გარშემო და თქვენ ამოღებული ფაილი უბრალოდ გადმოიყვანა იგი
გარეთ არსებობს.
ასე ნათლად, რომ ეს არ არის აუცილებელი წაშალა.
>> OK, თქვენ ჭკვიანები, ვიდრე.
თქვენ იცით, რომ უბრალოდ გადმოიყვანა იგი Trash ან Recycle Bin არ ნიშნავს იმას,
თქვენ ცლიან ნაგვის.
ასე, რომ თქვენ ახვიდეთ მენიუს და აცხადებენ, ცარიელი სანაგვე ან ცარიელი Recycle Bin.
მაშინ რა ხდება?
>> ჰო, ასე რომ ამოღებულია მით უმეტეს.
მაგრამ ყველა ეს მოხდება ეს.
კომპიუტერული დაავიწყდება, სადაც resume.doc იყო.
>> მაგრამ რა არ შეცვლილა, როგორც ჩანს, ამ სურათზე?
Bits, 0S და 1s, რომ მე პრეტენზია არის საიტზე რამდენიმე ფიზიკური ასპექტი
აპარატურა.
ისინი ჯერ კიდევ არსებობს.
უბრალოდ კომპიუტერი დავიწყებული რასაც ისინი.
>> ამიტომ არსებითად გაათავისუფლა ფაილი ნახვა ბიტი ისე, რომ ისინი შეიძლება გამოყენებული.
მაგრამ, სანამ თქვენ შექმნით მეტი ფაილი, და მეტი ფაილი და მეტი ფაილი იქნება
probabilistically, იმ 0S და 1s, იმ მაგნიტური ნაწილაკების, მივიღებთ გამოყენებული,
თავდაყირა ან მარჯვენა მხარეს up, for სხვა ფაილი, 0S და 1s.
>> ასე რომ თქვენ გაქვთ ეს ფანჯარა დრო.
და ეს არ არის პროგნოზირებადი სიგრძე, ნამდვილად.
ეს დამოკიდებულია ზომა თქვენი მყარი დისკზე და რამდენი ფაილი გაქვთ და
რამდენად სწრაფად შეგიძლიათ ახალი.
მაგრამ ეს ფანჯარა დროის განმავლობაში რომელსაც ეს ფაილი ჯერ კიდევ კარგად
ანაზღაურებადი.
>> ასე რომ, თუ ოდესმე გამოიყენოთ პროგრამები, როგორიცაა McAfee ან Norton ცდილობენ ფეხზე
მონაცემებით, ყველა ისინი ვაკეთებთ ცდილობს ფეხზე ამ ე.წ. დირექტორია
გაერკვნენ, სადაც თქვენი ფაილი.
და ზოგჯერ Norton და იტყვის, ფაილი 93% ანაზღაურებადი.
ისე, რას ნიშნავს ეს?
ეს მხოლოდ იმას ნიშნავს, რომ სხვა ფაილი ერთსა დასრულდა გამოყენებით, ვთქვათ,
იმ bits თქვენი ორიგინალური ფაილი.
>> ასე რომ, რა ხდება რეალურად ჩართული აღმოფხვრას მონაცემები?
ისე, თუ არ აქვს რაღაც Norton წინასწარ დაყენებული თქვენს კომპიუტერში,
საუკეთესო შეგიძლიათ ზოგჯერ არის გამოიყურება ერთი მთელი მყარი დისკის ეძებს
ნიმუშების ბიტი.
ხოლო ერთი თემებია პრობლემა ნაკრები ხუთ არის, რომ თქვენ ძებნის
ეკვივალენტს დისკის, სასამართლო იმიჯი კომპაქტური ფლეშ ბარათი
ციფრული კამერა, ეძებს 0S და 1s, რომ, როგორც წესი, მაღალი
ალბათობა წარმოადგენს დაწყება JPEG გამოსახულება.
>> და შენ შეიძლება ფეხზე იმ გამოსახულება თუ ვთქვათ, თუ მე ვერ ვხედავ ამ ნიმუში
ბიტი წლის სასამართლო იმიჯი, რომელსაც დიდი ალბათობაა, რომ აღნიშნავს
დაწყების JPEG.
და თუ მე ვერ ვხედავ იგივე ხასიათს ატარებს, კიდევ ერთხელ, ეს, ალბათ აღნიშნავს დაწყების
კიდევ ერთი JPEG, ხოლო მეორე JPEG და მეორე JPEG.
ეს კი, როგორც წესი, თუ როგორ მონაცემების აღდგენა იმუშავებს.
რა არის ლამაზი შესახებ JPEGs არის, მიუხედავად იმისა, ფორმატში თავისთავად გარკვეულწილად
კომპლექსი, დასაწყისიდან ყველა ასეთი ფაილი რეალურად საკმაოდ იდენტიფიცირება
და მარტივი, როგორც ნახავთ, თუ თქვენ არ უკვე.
>> ასე რომ, მოდით უფრო ახლოს ქვეშ hood, თუ ზუსტად რა იყო
მიმდინარეობს და, რაც ამ 0S და 1s არიან, გადმოგცეთ უფრო მეტს
კონტექსტში ამ კონკრეტული გამო.
>> [ვიდეო აღწარმოების]
>> _ სად თქვენი კომპიუტერის ინახავს საუკეთესო მუდმივი მონაცემები.
გავაკეთოთ, რომ მონაცემები მოგზაურობს ეხლა RAM ერთად პროგრამული სიგნალები რომ გითხრათ
მყარი დისკი, თუ როგორ უნდა შეინახოს, რომ მონაცემები.
მყარი დისკის სქემები თარგმნა იმ სიგნალები შევიდა ძაბვის
რყევების.
ეს, თავის მხრივ, აკონტროლებენ მყარ დისკზე ნახვა მოძრავი ნაწილები, ზოგი რამდენიმე
მოძრავი ნაწილები დარჩა თანამედროვე კომპიუტერული.
>> ზოგიერთი სიგნალები აკონტროლებენ საავტომობილო რომელიც ტრიალებს რკინის დაფარული platters.
თქვენი მონაცემები რეალურად შენახული ამ platters.
სხვა სიგნალები გადაადგილება წაკითხვის / ჩაწერის ხელმძღვანელები წაიკითხა ან
წერენ მონაცემებს platters.
ეს მანქანა ისე ზუსტი რომ ადამიანის თმის ვერ გაივლის შორის
ხელმძღვანელები და spinning platters.
თუმცა, ეს ყველაფერი მუშაობს შესანიშნავი სიჩქარით.
>> [END ვიდეო აღწარმოების]
>> დავით Malan: ზომით პატარა ღრმა ახლა რა
რეალურად იმ platters.
>> [ვიდეო აღწარმოების]
>> -მოდით შევხედოთ რაც ჩვენ მხოლოდ ვნახე ნელი მოძრაობით.
როდესაც მოკლე პულსი ელექტროენერგიის გაგზავნილი წაკითხვის / ჩაწერის ხელმძღვანელი, თუ შეიჭრება
მე პატარა ელექტრომაგნიტური for ფრაქცია მეორე.
Magnet ქმნის სფეროში, რომელიც ცვლილებების პოლარობის of პატარა, პატარა
ნაწილი რკინის ნაწილაკების რომელიც ქურთუკი ყოველ platter ზედაპირზე.
>> ნიმუში სერია ეს პატარა, ბრალად-up სფეროებში დისკზე
წარმოადგენს ერთ ცოტა მონაცემების ორობითი რიცხვი
სისტემის მიერ გამოყენებული კომპიუტერები.
ახლა, თუ მიმდინარე იგზავნება ერთი გზა მეშვეობით წაკითხვის / ჩაწერის ხელმძღვანელი, ტერიტორია
არის პოლარიზებული ერთი მიმართულებით.
თუკი მოქმედი იგზავნება საპირისპირო მიმართულებით,
პოლარიზაცია აღდგება.
>> როგორ უნდა გაიტანოთ მონაცემთა off ხისტი?
უბრალოდ გადახედოს პროცესში.
ასე რომ, ეს ნაწილაკების დისკზე რომ მიიღოს მიმდინარე
წაკითხვის / ჩაწერის ხელმძღვანელი მოძრაობს.
ერთად მილიონობით ეს magnetized სეგმენტები, და
თქვენ გაქვთ ფაილი.
>> ახლა, ცალი ერთი ფაილი შეიძლება იყოს მიმოფანტული მთელს დისკზე ნახვა
platters, სახის როგორც არეულობას ფურცლების თქვენს მაგიდასთან.
ასე რომ, სპეციალური დამატებითი ფაილი ინახება საქართველოს, სადაც ყველაფერი.
ხომ არ გისურვებთ ჰქონდა ასე რომ?
>> [END ვიდეო აღწარმოების]
>> დავით Malan: კარგი, ალბათ, არ.
ასე რომ, თუ რამდენი ბიჭები გაიზარდა ეს?
OK, ამიტომ ნაკლები და ნაკლები ხელში ყოველწლიურად.
მაგრამ მოხარული ვარ, რომ თქვენ, სულ ცოტა, ნაცნობი მათთან, რადგან ეს და ჩვენივე
წიგნის დემო, სამწუხაროდ, იხოცებიან ძალიან ნელი სიკვდილი აქ იცნობენ.
>> მაგრამ ეს არის ის, რაც მე, როგორც მინიმუმ, უკან საშუალო სკოლა, გამოიყენება გამოყენების სარეზერვო.
და ეს იყო საოცარი, იმიტომ, რომ თქვენ შეიძლება შესანახად 1.4 მბ წლის
ამ კონკრეტულ დისკზე.
და ეს იყო მაღალი სიხშირის ვერსია, როგორც მიერ მითითებულ HD, რომელსაც აქვს
რაც იმას ნიშნავს, სანამ დღევანდელი HD ვიდეო.
>> სტანდარტული სიმჭიდროვე იყო 800 kilobytes.
მანამდე კი, იყო 400 kilobyte დისკები.
მანამდე კი, იყო 5 და 1/4 inch დისკები, რომლებიც ნამდვილად დისკეტი,
და ცოტა უფრო ფართო და taller ვიდრე ეს ყველაფერი აქ.
მაგრამ შეგიძლიათ რეალურად ვხედავ ე.წ. ფლოპი ასპექტი ამ დისკები.
>> და ფუნქციურად, ისინი რეალურად საკმაოდ მსგავსია დისკები ზე
მინიმუმ ამ ტიპის.
ისევ, SSDs წელს უფრო ახალი კომპიუტერი მუშაობა ცოტა განსხვავებულად.
მაგრამ თუ თქვენ გადატანა, რომ პატარა რკინის tab, შეგიძლიათ რეალურად ვხედავ პატარა ფუნთუშა,
ან platter.
>> ეს არ არის ლითონის მოსწონს ეს.
ეს ერთი, ფაქტობრივად, ზოგიერთი იაფია პლასტიკური მასალა.
და შეგიძლიათ სახის wiggle იგი.
და თქვენ Trully მხოლოდ წაშლილია off ზოგიერთი რაოდენობის ბიტი ან მაგნიტური ნაწილაკების
ამ დისკზე.
>> ასე რომ, საბედნიეროდ, იქ არაფერი იგი.
თუ რამ არის ამ გზით - და მოიცავს შენი თვალები და იმ შენს მეზობელს -
თქვენ შეგიძლიათ სახის გაიყვანოს ამ მთელი sheath off იგრძნობა.
მაგრამ ცოტა გაზაფხულზე, ასე რომ იცის, რომ თქვენი თვალები.
ასე რომ, ახლა თქვენ გაქვთ ჭეშმარიტად მაგნიტური დისკის.
>> და რაც აღსანიშნავია შესახებ ის არის, რომ, როგორც ეს
მცირე წარმომადგენლობა უფრო დიდი დისკის, ეს ყველაფერი არის სუპერ,
სუპერ მარტივია.
თუ თქვენ pinch სიღრმისეული შესწავლა, ახლა რომ რომ რკინის რამ არის, და კანი
მათ გახსნას, ყველა იქ არის ორი ცალი იგრძნო და ე.წ. მაგნიტური დისკის
ნაჭერი ლითონის ქვეყნის შიგნით.
>> და იქ მიდის ნახევარი ჩემი დისკზე-ს შინაარსს.
არსებობს მიდის ნახევარი მათგანი.
მაგრამ ეს ყველაფერი, რაც იყო spinning შიგნით თქვენი კომპიუტერი yesteryear.
>> და ისევ, იმისათვის, რომ ამ გასვლის პერსპექტივა, რამდენად დიდი არის ყველაზე თქვენი
დისკები ამ დღეებში?
500 გიგაბაიტი, terabyte, შესაძლოა კომპიუტერი, 2 terabytes, 3
terabytes, 4 terabytes, არა?
ეს არის ერთ megabyte, მისცეს ან, რომელიც კი არ ჯდება ტიპიური MP3
აღარ ამ დღეებში, ან რაღაც მსგავსი მუსიკა ფაილი.
>> ასე რომ პატარა სუვენირების თქვენთვის დღეს, და ასევე, რათა დაეხმაროს contextualize რა
ჩვენ უნდა აღების მიანიჭა ახლა პრობლემა მითითებული ხუთ.
ასე რომ, ეს არის თქვენი შენარჩუნება.
ნება მომეცით გადასვლა, სადაც იქნება ხარჯვის შემდეგი pset ასევე.
ასე რომ, ჩვენ ახლა მითითებული ამ გვერდზე for - oh, რამდენიმე განცხადებები სწრაფად.
>> ეს პარასკევს, თუ გსურთ შეუერთდება CS50 ლანჩზე, წასვლა ჩვეული ადგილი,
cs50.net/rsvp.
და საბოლოო პროექტის -
ასე თითო სილაბუსის ჩვენ გამოქვეყნდა საბოლოო პროექტის დაზუსტება უკვე.
გააცნობიეროს, რომ ეს არ ნიშნავს, ეს იმის გამო განსაკუთრებით მალე.
ეს გამოქვეყნდა, მართლაც, მხოლოდ მისაღებად თქვენ ბიჭები ფიქრობდა ამის შესახებ.
მართლაც, სუპერ მნიშვნელოვანი პროცენტული თქვენ უნდა ბრძოლა
საბოლოო პროექტების მასალა, რომელიც ჩვენ არც კი შემოსული ამ კლასის,
მაგრამ, როგორც ყოველთვის, ჯერ კიდევ მომავალ კვირას.
>> შენიშვნა, თუმცა, რომ სპეც მოუწოდებს რამდენიმე სხვადასხვა კომპონენტების
საბოლოო პროექტს.
უპირველესად, რამდენიმე კვირის განმავლობაში, არის წინასწარი წინადადება საკმაოდ ჩვეულებრივი ელექტრონული
თქვენი TF ვუთხრა მას ან რა თქვენ ფიქრი თქვენი პროექტი, რომლის
არანაირ ვალდებულებას.
წინადადების იქნება თქვენი კონკრეტული ერთგულება და განაცხადა, რომ აქ, ეს არის ის,
მინდა გააკეთოს ჩემი პროექტი.
როგორ ფიქრობთ?
ძალიან დიდი?
ძალიან მცირე?
არის თუ არა მართვადი?
და ხედავთ სპეც გამოსაყენებლად.
>> რამდენიმე კვირის შემდეგ, რაც მდგომარეობა ანგარიშში, რომელიც ერთნაირად
შემთხვევითი ელ TF ვთქვა, თუ რამდენად ჩამორჩება თქვენ თქვენი საბოლოო
პროექტის განხორციელებას, რასაც მოჰყვება CS50 Hackathon რომლის ყველას
არის მიწვეული, რომელიც იქნება მოვლენა 8:00 საათზე ერთ საღამოს ჩათვლით 7:00
პოსტი დილით.
პიცა, როგორც მე შეიძლება მოხსენიებული კვირაში ნულოვანი, Wil მოემსახურება 9:00 PM,
ჩინეთის საკვები 1:00 სთ.
და თუ თქვენ ჯერ კიდევ მეძინა at 5:00, ჩვენ გადაგიყვანთ IHOP საუზმე.
>> ასე რომ Hackathon არის ერთი უფრო სამახსოვრო გამოცდილება კლასის.
მაშინ განხორციელების გამო და შემდეგ climactic CS50 სამართლიანი.
სხვა დეტალები ყველა ამ ამ კვირის განმავლობაში მოვა.
>> მაგრამ მოდით დავუბრუნდეთ რაღაც ძველი სკოლა -
ერთხელ, მასივი.
ასე მასივი იყო ლამაზი, იმიტომ, რომ ეს წყვეტს საკითხები, როგორიც დავინახეთ მხოლოდ
მომენტში წინ სტუდენტი სტრუქტურები მიღების პატარა კონტროლიდან, თუ ჩვენ
გვინდა სტუდენტი ერთი სტუდენტის ორი, სტუდენტური სამი სტუდენტი dot dot dot,
ზოგიერთი თვითნებური რაოდენობის სტუდენტებს.
>> ასე რომ, მასივები, რამდენიმე კვირის წინ swooped in და მოგვარდება ყველა ჩვენი პრობლემები არ
იცის, წინასწარ რამდენი რამ ზოგიერთი ტიპის ჩვენ დაგვჭირდება.
და ჩვენ ვხედავთ, რომ structs დაგვეხმარება შემდგომი ორგანიზება ჩვენი კოდი და შენარჩუნება
კონცეპტუალურად მსგავსი ცვლადები, ისევე როგორც სახელი და სახლში, ერთად, ისე, რომ ჩვენ
შეიძლება მკურნალობა მათ ერთი პირი, შიგნით რომელიც არსებობს მცირე პიესა.
>> მაგრამ მასივების გარკვეული უარყოფითი მხარეები.
რა უარყოფითი მხარეები ჩვენ შეექმნა
ერთად მასივების დღემდე?
რა არის ეს?
ფიქსირებული ზომა - ასე მიუხედავად იმისა, რომ თქვენ შეიძლება შეძლებს გამოყოფს მეხსიერების
მასივი, კიდევ რამდენი სტუდენტები თქვენ გაქვთ, რამდენი სიმბოლოები აქვს
ეხლა შესახებ, რომ ერთხელ თქვენ გამოყო მასივი, თქვენ სახის მოხატული
თავს შევიდა კუთხეში.
>> იმის გამო, რომ ვერ ჩადეთ ახალი ელემენტების შევიდა შუა მასივი.
თქვენ არ შეგიძლიათ ჩადეთ მეტი ელემენტები დასასრულს მასივი.
მართლაც, თქვენ უნდა მიმართოს ქმნის მთელი ახალ მასივებს, როგორც ჩვენ განვიხილეთ,
გადაწერა ძველი შევიდა ახალი.
ისევ და ისევ, ეს არის თავის ტკივილი, რომელიც GetString ეხება თქვენთვის.
>> თუმცა ისევ და ისევ, თქვენ კი არ ჩადეთ რაღაც შევიდა შუა მასივი
თუ კურსი არ არის მთლიანად სავსე.
მაგალითად, თუ ამ მასივში აქ ზომა ექვსი მხოლოდ ხუთ რამ მას,
ასევე, შეიძლება მხოლოდ Tack რაღაც გადატანა ბოლომდე.
მაგრამ რა, თუ გსურთ ჩადეთ რამე შევიდა შუა
მასივი, მიუხედავად იმისა, რომ შესაძლოა, ხუთ ექვსი რამ არის?
>> ისე, რა მივიღეთ, როდესაც ჩვენ გვქონდა ყველა ჩვენი ადამიანის მოხალისეები სცენაზე in
კვირის წარსულში?
თუ ჩვენ მოინდომა ვინმე აქ, ან ამ ხალხს თუ როგორ უნდა გადავიდეს ამ
სხვათა შორის, თუ ამ ხალხს, თუ როგორ უნდა გადავიდეს ამ სხვათა შორის, და რომელიც გახდა ძვირი.
გადასვლის ადამიანი შიგნით მასივი დასრულდა დასძინა up და რაზეც
ჩვენს დროს, აქედან გამომდინარე, უამრავი ჩვენი n კვადრატში გაშვებული ჯერ მსგავსად ჩანართი დალაგების, ამისთვის
მაგალითად, უარეს შემთხვევაში.
ასე რომ მასივების არის დიდი, მაგრამ უნდა წინასწარ რამდენად დიდი გსურთ მათ.
>> ასე რომ, ბატონო, აქ არის გამოსავალი.
თუ არ ვიცი, წინასწარ რამდენი სტუდენტები შეიძლება ჰქონდეს, და ვიცი, ერთხელ
I გადაწყვეტენ, თუმცა, მე მოხდა, რომ ბევრი სტუდენტი, რატომ არ მე ყოველთვის
გამოყოფს ორჯერ მეტი სივრცე როგორც მე ალბათ ფიქრობთ, მე?
ის არის, რომ არ გონივრული გამოსავალი?
>> რეალურად, მე არ ვფიქრობ, რომ ჩვენ აპირებთ უნდა მეტი 50 slots
ამ მასივი for საშუალო კლასის, მოდით უბრალოდ გარშემო up.
გავაკეთებ 100 slots ჩემს მასივი, უბრალოდ ასე რომ ჩვენ შეგვიძლია ნამდვილად მისაღებად
სტუდენტთა რაოდენობის ველოდო იყოს ზოგიერთ საშუალო კლასის.
რატომ არა მხოლოდ გარშემო up და გამოყოფა მეტი მეხსიერების, როგორც წესი, ამისთვის მასივი
ვიდრე ფიქრობთ შეიძლება გვჭირდება?
რა არის ეს მარტივი pushback რომ იდეა?
>> თქვენ მხოლოდ გაყვანაა მეხსიერება.
ფაქტიურად ყველა პროგრამა წერთ მაშინ არის იქნებ გამოყენებით ორჯერ მეხსიერებაში,
თქვენ რეალურად სჭირდება.
და ეს უბრალოდ არ გრძნობს, როგორც განსაკუთრებით დახვეწილი გადაწყვეტა.
უფრო მეტიც, ეს მხოლოდ ამცირებს ალბათობა პრობლემა.
თუ მოხდება აქვს პოპულარული რა თქმა უნდა ერთი სემესტრის და თქვენ 101
სტუდენტები, თქვენი პროგრამა ჯერ კიდევ ფუნდამენტურად წინაშე დგას იგივე საკითხი.
>> ასე რომ, საბედნიეროდ, არსებობს გამოსავალი განცხადებაზე ყველა ჩვენი პრობლემების ფორმა
მონაცემთა სტრუქტურები, რომლებიც უფრო რთული, ვიდრე
ჩვენ ვნახეთ დღემდე.
ეს, მე პრეტენზია, არის დაკავშირებული სიაში.
ეს არის ჩამონათვალი ნომრები -
9, 17, 22, 26, და 34 -
რომ უკვე გაერთიანებულს გზა თუ რა მე შედგენილი, როგორც ისრებით.
>> სხვა სიტყვებით, თუ მინდოდა წარმოადგენს მასივი, მე ვერ გააკეთებს
მსგავსი რამ.
და მე დააყენა ეს ოვერჰედის რაღაც მომენტში.
მე ვერ გააკეთებს -
hello, ყველა უფლება.
ლოდინის.
ახალი კომპიუტერული აქ, წმინდა -
ყველა უფლება.
>> ასე რომ, თუ მაქვს ეს ნომრები მასივი -
9, 17, 22, 26, 24 -
არ არის აუცილებელი გავაფართოვოთ.
ყველა უფლება, ასე რომ აქ არის ჩემი მასივი -
ღმერთო ჩემო.
ყველა უფლება, ასე რომ აქ არის ჩემი მასივი.
ღმერთო ჩემო.
>> [სიცილი]
>> დავით Malan: პრეტენზია.
ეს არის ძალიან დიდი ძალისხმევა უნდა დაბრუნდეს და დაფიქსირება, რომ, ასე რომ, -
26.
ასე რომ, ჩვენ გვაქვს ეს მასივი 9, 17, 22, 26, და 34.
იმ თქვენ ხედავთ უხერხულ შეცდომის უბრალოდ გააკეთა,
იქ ის არის.
>> ასე რომ, ამტკიცებენ, რომ ეს არის ძალიან ეფექტური გადაწყვეტა.
მე გამოყოფილი, როგორც ბევრი ints როგორც მე უნდა - ერთი, ორი, სამი,
ოთხი, ხუთი, თუ ექვსი -
და მე მაშინ შენახული ნომრები შიგნით ამ მასივი.
თუმცა ვარაუდობენ, მაშინ, მინდა ჩადეთ ღირებულება, როგორიცაა 8?
ისე, სად წავიდეს?
დავუშვათ, მინდა ჩადეთ ნომერი, როგორიც 20.
ისე, სად წავიდეს?
სადღაც იქ ცენტრიდან, ან ნომერი 35 უნდა წავიდეს
სადღაც ბოლოს.
მაგრამ მე ყველა იმ სივრცეში.
>> ასე რომ, ეს არის ფუნდამენტური გამოწვევა მასივი, რომელიც არ არის გამოსავალი.
I მტკიცებით მომენტში წინ, GetString წყვეტს ამ პრობლემას.
თუ გსურთ ჩადეთ მეექვსე ნომერი წინამდებარე მასივი, რა არის მინიმუმ ერთი
გადაწყვეტა შეგიძლიათ დაეცემა უკან დარწმუნებული ვარ, ისევე, როგორც ჩვენ არ უკავშირდება GetString?
რა არის ეს?
>> ისე, რომ მას, მით უფრო ადვილი განაცხადა, ვიდრე გაკეთდეს.
ჩვენ არ შეგვიძლია აუცილებლად მასივი დიდი, მაგრამ რა ვქნათ?
მიიღოს ახალი მასივი, რომ უფრო დიდი, რა ზომის 6, ან იქნებ ზომა 10, თუ გვინდა
მიიღონ უსწრებს რამ და შემდეგ კოპირება ძველი მასივი ახალ, შემდეგ კი
გასათავისუფლებლად წლის მასივი.
>> მაგრამ რა არის ქრონომეტრაჟი ახლა იმ პროცესში?
ეს დიდი ო ო, იმიტომ, რომ გადაწერა აპირებს დაგიჯდებათ რამდენიმე ერთეული
დრო, ასე არც თუ ისე იდეალური, თუ ჩვენ უნდა გამოყოფს ახალ მასივებს, რომელიც აპირებს
მოიხმარენ ორჯერ მეხსიერების დროებით.
ასლი ძველ ახალ -
ვგულისხმობ, უბრალოდ თავის ტკივილი, რომელიც არის, კიდევ ერთხელ, ამიტომ ჩვენ წერს
GetString თქვენთვის.
>> ასე რომ, თუ რა შეიძლება ჩვენ გავაკეთოთ ნაცვლად?
ისე, რა, ჩვენი მონაცემებით სტრუქტურა რეალურად აქვს ხარვეზები იგი?
დავუშვათ, რომ მე დაძაბულია ჩემი მიზანი, რომელსაც მომიჯნავე მოცულობით მეხსიერება, სადაც 9
არის უფლება შემდეგ 17, რომელიც უფლება შემდეგ 22 და ასე შემდეგ.
>> და ვარაუდობენ, რომ 9 შეიძლება მეტი აქ RAM და 17 შეიძლება მეტი აქ RAM,
და 22 შეიძლება მეტი აქ მეხსიერება.
სხვა სიტყვებით, მე არ გვჭირდება კიდევ დაუჭიროს მხარი დაუჭიროს აღარ.
მე უბრალოდ უნდა როგორმე თემა ნემსი მეშვეობით თითოეული ამ ნომრებზე, ან
ამ კვანძების, როგორც ჩვენ ამას დავარქმევთ rectangles როგორც მე შედგენილი მათ,
მახსოვს, თუ როგორ უნდა ბოლო ასეთი კვანძის პირველი.
>> რა არის პროგრამირების მშენებლობა ჩვენ ვნახეთ ცოტა ხნის წინ რომლითაც მე
შეიძლება განახორციელოს, რომ თემა, ან შედგენილი აქ, რომელთანაც შემიძლია
ძალისხმევა ამ ისრები?
ასე რომ, მითითებას, არა?
თუ მე გამოყოფას არა მხოლოდ int, მაგრამ კვანძის - და
კვანძის, უბრალოდ ნიშნავს, კონტეინერი.
და ვიზუალურად, ვგულისხმობ მართკუთხედი.
ასე რომ, კვანძის, როგორც ჩანს, სჭირდება მასში ორი ფასეულობის -
int თავად, შემდეგ კი, როგორც ითვალისწინებს ქვედა ნახევარში მართკუთხედი,
საკმარისი სივრცე int.
>> ასე რომ, მხოლოდ ფიქრი და ანგარიში გახდა აქ, რამდენად დიდია ამ კვანძის, ამ
კონტეინერის კითხვა?
რამდენი ბაიტი for int?
სავარაუდოდ 4, თუ ეს იგივე, როგორც ყოველთვის.
და მაშინ, თუ რამდენი ბაიტი ამისთვის მაჩვენებელი?
4.
ასე რომ, ეს კონტეინერი, ან ამ კვანძის, არის იქნება 8 ბიტიანი სტრუქტურა.
ოჰ, და ეს ბედნიერი დამთხვევა, რომ ჩვენ უბრალოდ დანერგა ეს ცნება
struct ან C სტრუქტურა.
>> ასე, რომ ამბობენ, თითქოს მე მინდა მიიღოს ნაბიჯი მიმართ უფრო დახვეწილი
განხორციელების ჩამონათვალი ნომრები, უკავშირდება ჩამონათვალი ნომრები, მე უნდა გავაკეთოთ
ცოტა მეტი აზროვნების up წინა და ვაცხადებ, არა მხოლოდ int, მაგრამ struct
რომ მე მოვუწოდებ, პირობითად აქ, კვანძის.
ჩვენ ხომ მას არაფერი ჩვენ გვინდა, მაგრამ კვანძის იქნება თემატური ბევრი
რამ ჩვენ ვიწყებთ ეძებს ახლა.
>> შიგნით რომ კვანძის არის int n.
და მაშინ ამ სინტაქსის, პატარა უცნაური ერთი შეხედვით -
struct კვანძის * მომავალი.
ისე pictorially, რა არის ეს?
სწორედ ქვედა ნახევარში მართკუთხედი, რომ დავინახეთ
მხოლოდ ერთი წუთით წინ.
>> მაგრამ რატომ ვარ მე ამბობდა struct კვანძის * განსხვავებით მხოლოდ კვანძის *?
იმის გამო, რომ თუ ეს მაჩვენებელი არის მიუთითებს მორიგ კვანძის, უბრალოდ
მისამართი კვანძის.
ეს არის ის, შეესაბამება თუ რა ჩვენ ისაუბრა მითითებას დღემდე.
მაგრამ რატომ, თუ ადასტურებენ, რომ ამ სტრუქტურის მოუწოდა კვანძის, შემიძლია ვთქვა, struct
კვანძის შიგნით აქ?
>> ზუსტად.
ეს ერთგვარი სულელური რეალობა C. Typedef, ასე ვთქვათ, არა აქვს
მომხდარა.
C არის სუპერ ლიტერატურული.
პროგრამა კითხულობს თქვენი კოდი ყველაზე ბოლოში, მარცხნიდან მარჯვნივ.
და ვიდრე იგი გაიტანა, რომ მძიმით წლის ქვედა ხაზი, ვხვდები რა არა
არსებობს, როგორც მონაცემების ტიპის?
Node, გაცემა unquote კვანძის.
>> მაგრამ იმის გამო, რომ უფრო verbose დეკლარაციის მე პირველ ხაზზე -
typedef struct კვანძის -
იმიტომ, რომ მოვიდა პირველად, სანამ curly აფრთხილებს, რომ სახის მოსწონს
წინასწარი განათლების Clang, რომ თქვენ იცით, რა, მომეცი struct
მოუწოდა struct კვანძის.
გულწრფელად ვამბობ, მე არ მომწონს მოუწოდებენ რამ struct კვანძის, struct კვანძის ყველა
მთელი ჩემი კოდი.
მაგრამ მე მხოლოდ ერთხელ, მხოლოდ შიგნით, ასე, რომ მე შემიძლია ეფექტურად
შექმნა ერთგვარი წრიული მითითება, არ მაჩვენებელი, რომ პირადად თავისთავად, მაგრამ
მომცეთ კიდევ ერთი იდენტური ტიპის.
>> გამოდის, რომ მონაცემთა სტრუქტურის ასე, რომ არსებობს რამდენიმე
ოპერაცია, შესაძლოა, საინტერესოა ჩვენთვის.
ჩვენ დაგვჭირდება ჩადეთ შევიდა სიაში მოსწონს ეს.
ჩვენ დაგვჭირდება წაშლა სიიდან მოსწონს ეს.
ჩვენ დაგვჭირდება ძებნის სიაში ღირებულება, ან უფრო ზოგადად, ტრავერსზე.
ხოლო გვერდის ავლით, უბრალოდ ლამაზი გზა ამბობდა იწყება მარცხენა გადავიდეს ყველა
გზა მარჯვნივ.
>> და შეამჩნია, თუნდაც ამ ოდნავ მეტი დახვეწილი მონაცემთა სტრუქტურის, ნება
მე შესთავაზოს, რომ ჩვენ შეგვიძლია სესხება ზოგიერთი იდეების ბოლო ორი კვირის განმავლობაში და
განახორციელოს ფუნქცია მოუწოდა ძებნის მოსწონს ეს.
ეს დაბრუნებას აპირებს ჭეშმარიტი ან ყალბი, რაც მიუთითებს, დიახ ან
არა, N არის სიაში.
მეორე არგუმენტი მაჩვენებელი სიაში თავად, ასე
მომცეთ კვანძის.
>> ყველა მე ვაპირებ მაშინ არის განაცხადოს დროებითი განსხვავებულია.
ჩვენ ამას ეძახით Ptr მიერ კონვენციის, ამისთვის მაჩვენებელი.
და მე მივანიჭოთ მას ტოლი დასაწყისში სიაში.
>> ახლა კი შეამჩნია, ხოლო ციკლი.
ასე რომ, სანამ მაჩვენებელი არ არის თანაბარი to null, მე ვაპირებ, რათა შეამოწმოს.
არის მაჩვენებელი ისარი n ტოლია ო, რომ იყო მიღებული?
და დაველოდოთ წუთში - new ნაწილი სინტაქსი.
რა არის ისარი უეცრად?
ჰო?
>> ზუსტად.
ასე რომ, ხოლო რამდენიმე წუთის წინ, ჩვენ dot notation წვდომის რაღაც
შიგნით struct, თუ ცვლადი თქვენ არ არ არის struct
თავისთავად, მაგრამ მომცეთ struct, საბედნიეროდ, ნაწილი სინტაქსი, რომ
საბოლოოდ ხდის ინტუიციური გრძნობა.
Arrow ნიშნავს, რომ დაიცვას მაჩვენებელი, როგორც ჩვენი ისრები, როგორც წესი, ნიშნავს
pictorially, და წავიდეთ ზე მონაცემთა სფეროში შიგნით.
ასე რომ arrow არის იგივე როგორც dot, მაგრამ თქვენ გამოიყენოს იგი როდესაც თქვენ მაჩვენებელი.
>> ასე რომ, მხოლოდ იმიტომ, რომ Recap შემდეგ, თუ n სფეროში შიგნით struct მოუწოდა მაჩვენებელი
შეადგენს შეადგენს ო, დაბრუნება ასეა.
წინააღმდეგ შემთხვევაში, ამ ხაზის აქ - მაჩვენებელი შეადგენს მაჩვენებელი მომავალი.
ასე რომ, თუ რას აკეთებს, შეტყობინება, არის თუ მე ამჟამად მიუთითებს struct
შემცველი 9 და 9 არ არის ნომერი ვეძებ - ვივარაუდოთ, მე დიდი იმედით
ამისთვის ო შეადგენს 50 -
მე ვაპირებ: ჩემი დროებითი მაჩვენებელი რომ არ აღვნიშნო, რომ ამ კვანძის
აღარ, მაგრამ მაჩვენებელი ისარი მომავალი, რომელიც გეგმავს ჩემთვის აქ.
>> ახლა მივხვდი, არის whirlwind დანერგვა.
ოთხშაბათს, ჩვენ რეალურად გაკეთება რამდენიმე ადამიანისა და კიდევ რამდენიმე
კოდი ზე ნელა მიმდინარეობს.
მაგრამ გააცნობიეროს, ჩვენ ახლა ჩვენი მონაცემები სტრუქტურები უფრო რთული ისე, რომ ჩვენი
ალგორითმები შეუძლიათ მიიღონ უფრო ეფექტური, რომელიც იქნება საჭირო ამისთვის
pset ექვსი, როდესაც ჩვენ ჩატვირთვა in, კიდევ ერთხელ, იმ 150,000 სიტყვა, მაგრამ უნდა გაკეთება
ეფექტურად, და იდეალურად, შექმნა პროგრამა, რომელიც მუშაობს ჩვენი წევრებს არ
წრფივი და არა n კვადრატში, მაგრამ მუდმივი დროს, იდეალური.
>> ჩვენ დავინახავთ, თქვენ ოთხშაბათს.
>> სპიკერი: მომდევნო CS50, დავით დაავიწყდა მისი ბაზა შემთხვევაში.
>> დავით Malan: და ასე თქვენ ტექსტი შეტყობინებები ერთად C. რა -
>> [სხვადასხვა ტექსტური შეტყობინება საფუძველზე ხმები]