[Powered by Google Translate] [კვირა 4]
[დევიდ ჯ Malan] [ჰარვარდის უნივერსიტეტის]
[ეს არის CS50.] [CS50.TV]
>> ყველა უფლება, ეს არის CS50, და ეს არის დაწყების კვირაში 4,
და ეს არის ერთ ერთი ყველაზე ნელი შესაძლო დახარისხება ალგორითმები.
რომელი იყო ის, რომ ჩვენ უბრალოდ ადევნებდნენ იქ?
ეს იყო ბუშტი დალაგება, რათა დიდი O (N ^ 2) + თანხა,
და მართლაც ჩვენ არ ვართ მხოლოდ ამ მსოფლიოს, როგორც ჩანს, ვიცი
რა ბუშტი დალაგების არის ან მისი ქრონომეტრაჟი.
მართლაც, ეს იყო ინტერვიუში ერიკ შმიდტი Google-
და ყოფილი სენატორი ბარაკ ობამა რამდენიმე წლის წინ.
>> ახლა, სენატორი, თქვენ აქ, Google,
და მე მიყვარს ვფიქრობ თავმჯდომარეობის დროს გასაუბრება.
ახლა, ეს იმისთვის, რომ მიიღოთ სამუშაოს როგორც პრეზიდენტი, და თქვენ აპირებს მეშვეობით rigors არის.
ასევე იმისთვის, რომ მიიღოთ სამსახურიდან, Google.
ჩვენ გვყავს კითხვები და ჩვენ ვთხოვთ ჩვენი კანდიდატების კითხვები,
და ეს ერთი არის Larry შვიმერი.
თქვენ ბიჭები ვფიქრობ მე kidding? ეს უფლება აქ.
რა არის ყველაზე ეფექტური საშუალება დასალაგებლად მილიონი 32-bit რიცხვებით?
[სიცილის]
კარგად
მე უკაცრავად. >> არა, არა, არა, არა.
ვფიქრობ bubble sort იქნება არასწორი გზაა გასავლელი.
>> მოდი შესახებ, რომელმაც განუცხადა, ამ საკითხთან დაკავშირებით?
გასულ კვირას გავიხსენოთ ავიღეთ ჩამოშორდა კოდი, ყოველ შემთხვევაში დღეს,
და დაიწყო ფოკუსირება რამდენიმე უმაღლესი დონის იდეებისა და პრობლემის გადაჭრის უფრო ზოგადად
კონტექსტში ძებნას და დახარისხება,
და ჩვენ გააცნო, რასაც ჩვენ არ Slap ამ სახელით გასულ კვირას,
მაგრამ asymptotic ნოტაცია, დიდი O, დიდი ომეგა,
და ზოგჯერ დიდი Theta ნოტაცია, და ეს იყო უბრალოდ გზები
საქართველოს აღწერს გაშვებული დრო ალგორითმები,
რამდენი დრო სჭირდება ამისთვის ალგორითმი გასაშვებად.
>> თქვენ შეიძლება გავიხსენოთ, რომ თქვენ ისაუბრა ქრონომეტრაჟი თვალსაზრისით ზომა
საქართველოს შეყვანის, რომელიც ჩვენ მოვუწოდებთ ზოგადად N, რასაც პრობლემა არ უნდა იყოს,
სადაც n რაოდენობის ხალხი ოთახი,
გვერდების რაოდენობა სატელეფონო წიგნი, და დავიწყეთ დაწერა ნივთების
მოსწონს O (N ^ 2) ან O (N) ან O (N შესვლა N),
და მაშინაც კი, როცა მათემატიკის არ საკმაოდ შეიმუშაოს ასე შესანიშნავად
და ეს იყო n ² - N / 2 ან რამე მაგდაგვარს
ჩვენ ნაცვლად მხოლოდ გადაყარეთ ზოგიერთი ქვედა წესრიგის თვალსაზრისით,
და მოტივაცია არსებობს, რომ ჩვენ მართლაც გვინდა
სახის ობიექტური გზა შეფასებისას
შესრულების პროგრამების ან შესრულების ალგორითმები
რომ დღის ბოლოს არაფერი აქვს, მაგალითად,
ერთად სიჩქარე თქვენს კომპიუტერში დღეს.
>> მაგალითად, თუ თქვენ განახორციელოს bubble sort,
ან თქვენ განახორციელოს შერწყმა დალაგების ან შერჩევის დალაგების დღევანდელ კომპიუტერი,
2 GHz კომპიუტერი და გაუშვით,
და ეს ხდება გარკვეული რაოდენობის წამში, მომავალ წელს იქ 3 GHz
ან 4 GHz კომპიუტერი, და ალბათ მაშინ ვამბობთ, რომ "Wow, ჩემი ალგორითმი
არის ორჯერ სწრაფად, "როცა რეალურად რომ აშკარად არ შემთხვევაში.
უბრალოდ ტექნიკა არ მიღებული სწრაფად, მაგრამ თქვენს კომპიუტერში
არ, და ამიტომ ჩვენ ნამდვილად გსურთ გადაყარეთ რამ, როგორიცაა
ჯერადი 2 ან ჯერადი 3 როდესაც საქმე აღწერილია
რამდენად სწრაფად ან რამდენად ნელა ალგორითმი არის და რეალურად მხოლოდ ფოკუსირება
on n ან რამდენიმე ფაქტორი მათი
ზოგიერთი ძალა მისი, როგორც იმ შემთხვევაში, თუ სახის გასულ კვირას.
და გავიხსენოთ, რომ დახმარებით შერწყმა დალაგება
ჩვენ შევძელით ამის გაკეთება ბევრად უკეთესია, ვიდრე bubble sort და შერჩევის დალაგება
და კიდევ Insertion ჯიშია.
>> ჩვენ ქვემოთ N შესვლა N, და ისევ,
გავიხსენოთ, რომ შესვლა N ზოგადად ეხება რაღაც რომ იზრდება
უფრო ნელა მაშინ N, ასე n შესვლა N დღემდე იყო კარგი
რადგან ეს იყო ნაკლები n ².
მაგრამ, რათა მივაღწიოთ N შეხვიდეთ N ერთად შერწყმა დალაგება
რა იყო ძირითადი ჩანასახები იდეა, რომ ჩვენ იძულებული გახდა ბერკეტები
რომ ჩვენ ასევე leveraged უკან კვირაში 0?
როგორ ჩვენ დაძლევის დახარისხება პრობლემა cleverly ერთად შერწყმა დალაგება?
რა იყო გასაღები ინსაითი, ალბათ?
არავის საერთოდ.
Okay, მოდით გავიაზროთ მომავალი ნაბიჯები.
აღწერეთ შერწყმა დალაგება თქვენი სიტყვებით.
როგორ მუშაობს იგი?
Okay, ჩვენ ზედიზედ თავში კვირაში 0.
Okay, yeah.
[Inaudible-სტუდენტი]
Okay, კარგი, ამიტომ ჩვენ გაყოფილი მასივი ნომრები შევიდა 2 ცალი.
ჩვენ დახარისხებული თითოეული იმ დარტყმები, და შემდეგ ჩვენ გაერთიანდა მათ,
და ჩვენ ვხედავთ ამ იდეის წინაშე აღების პრობლემა, რომელიც ამ დიდ
და chopping it up შევიდა პრობლემა რომ ამ დიდი თუ ამ დიდი.
>> შეგახსენებთ, სატელეფონო წიგნი მაგალითად.
შეგახსენებთ, თვითმმართველობის დათვლა ალგორითმი საწყისი კვირის წინ
ასე შერწყმა დალაგების იყო შეაჯამა ამ pseudocode აქ.
როდესაც თქვენ მოცემული n ელემენტებს, პირველი ეს იყო საღი აზრის შეამოწმოს.
თუ n <2 მაშინ ნუ არაფერი ყველა
რადგან თუ n <2 მაშინ N აშკარად 0 ან 1,
და ასე თუ ის ან 0 ან 1 არაფერი დასალაგებლად.
თქვენ გაკეთდეს.
თქვენს სიაში უკვე trivially დახარისხებული.
მაგრამ სხვაგვარად, თუ თქვენ მოხვდით 2 ან მეტი ელემენტისაგან წავიდეთ წინ და ყოფს მათ
შევიდა 2 halves, მარცხენა და მარჯვენა.
Sort თითოეული იმ halves, შემდეგ შერწყმა დახარისხებული halves.
მაგრამ პრობლემა აქ ისაა, რომ ერთი შეხედვით ეს იგრძნობა ჩვენ punting.
ეს არის წრიული განმარტება, რომ თუ მე გთხოვეთ დასალაგებლად ამ N ელემენტები
და თქვენ მეუბნებოდა "ყველა უფლება, ჯარიმა, ჩვენ დასალაგებლად იმ N / 2 და იმ N / 2 ელემენტები,"
მაშინ ჩემი შემდეგი კითხვა იქნება "ჯარიმის, როგორ დასალაგებლად N / 2 ელემენტები?"
>> მაგრამ იმის გამო, რომ ამ სტრუქტურის ამ პროგრამის
რადგან ამ ბაზის შემთხვევაში, ასე ვთქვათ,
ამ განსაკუთრებულ შემთხვევაში, რომელიც ამბობს, თუ N არის <ზოგიერთი ფიქსირებული ფასით მოსწონს 2 დაბრუნების დაუყოვნებლივ.
არ უპასუხოს, რომ იგივე წრიული პასუხი.
ეს პროცესი, ამ cyclicity საბოლოოდ დასრულდება.
თუ მე გთხოვთ "დალაგების ამ N ელემენტები," და თქვენ ამბობთ, "ჯარიმის, დასალაგებლად ამ N / 2,"
მაშინ ამბობენ, "ჯარიმის, sort ამ N / 4, n / 8, n/16"
საბოლოოდ თქვენ დაყოფის დიდი საკმარისი რაოდენობის
რომ თქვენ მხოლოდ 1 ელემენტს მარცხენა, სადაც წერტილი შეიძლება ითქვას,
"აქ, აქ არის დახარისხებული ერთჯერადი ელემენტს."
შემდეგ ბრწყინვალების ამ ალგორითმი აქ არის გამომდინარეობს ფაქტი
რომ მას შემდეგ რაც ყველა ეს ინდივიდუალურად დახარისხებული სიები
ყველა რომლებიც ზომა 1, რომელიც, როგორც ჩანს, უსარგებლო,
ერთხელ თქვენ დაიწყება შერწყმის მათ და შერწყმის მათ
თქვენ დაამყარონ საბოლოოდ როგორც რობ გააკეთა ვიდეო საბოლოოდ დახარისხებული სია.
>> მაგრამ ეს იდეა ვრცელდება მიღმა დახარისხება.
არსებობს ამ იდეის ჩართული ამ პროგრამის ცნობილია, როგორც უკან,
იდეა, რომლის დროსაც თქვენ პროგრამა,
და გადაჭრის ზოგიერთი პრობლემა თქვენ დაირქვით,
ან დააყენა კონტექსტში პროგრამირების ენების თქვენ ფუნქცია,
და გადაჭრის მიზნით პრობლემა, თქვენ ფუნქცია დაირქვით
ისევ და ისევ და ისევ, მაგრამ თქვენ ფუნქცია
ვერ ვუწოდებ თავს უსასრულოდ ბევრჯერ.
საბოლოოდ თქვენ უნდა ბოლოში გარეთ, ასე ვთქვათ,
და გარკვეული მყარი კოდირებული ბაზა პირობით, რომ ამბობს
ამ ეტაპზე შეწყვიტოს მოუწოდებენ თავის ისე, რომ მთელი პროცესი
საბოლოოდ ამჯამად ფაქტობრივად შეჩერება.
რას ნიშნავს, რომ recurse?
>> ვნახოთ, თუ შეგვიძლია გავაკეთოთ მარტივი, ტრივიალური მაგალითი, ვთქვათ,
3 ადამიანი ჩემთან ერთად აქ სცენაზე, თუ ვინმე არის კომფორტული.
1, მოდის up, 2 და 3.
თუ თქვენ 3 სურვილი, ჩამოვიდეს აქ.
თუ გსურთ დავდგეთ უფლება ჩემს გვერდით აქ ხაზი, ვივარაუდოთ, რომ პრობლემის მხრივ
ძალიან trivially ითვლიან მათი რაოდენობა, ვინც აქ ვართ.
მაგრამ გულწრფელად, მე დაღლილი ყველა ამ დათვლის მაგალითები.
ეს აპირებს მიიღოს გარკვეული დრო, 1, 2, და dot, dot, dot.
ის აპირებს სამუდამოდ.
მე მირჩევნია უბრალოდ punt ეს პრობლემა საერთოდ დახმარებით-რა გქვია?
Sara. >> Sara, ყველა უფლება.
Kelly. >> კელი და?
>> ვილი. >> ვილი, სარა, კელიმ, და ვილი.
მე ახლავე უკვე კითხვას ვიღაცამ
რამდენი ადამიანი up ამ ეტაპზე, და წარმოდგენა არ მაქვს.
ეს არის მართლაც გრძელი სია და ასე ნაცვლად მე ვაპირებ ამის გაკეთებას შეასრულა.
მე ვაპირებ ვკითხო პირი ჩემს გვერდით არა უმეტეს მუშაობა,
და კიდევ ის კეთდება აკეთებს უმეტესობა სამუშაოს
მე ვაპირებ ამის გაკეთებას მაინც ოდენობით მუშაობა შესაძლებელია და უბრალოდ დაამატოთ 1
to whatever მისი პასუხი, ამიტომ აქ ჩვენ მივდივართ.
მე ვკითხე რამდენი ადამიანი სცენაზე.
რამდენი ადამიანი სცენაზე მარცხნივ თქვენ?
მარცხნივ მე? >> Okay, მაგრამ არ მოატყუო.
ეგ კარგია, რომ ზუსტი, მაგრამ თუ ჩვენ გვინდა, რომ გავაგრძელოთ ამ ლოგიკით
მოდით ვივარაუდოთ, რომ თქვენ ერთნაირად გვინდა punt ეს პრობლემა მარცხნივ შენ,
ამიტომ, ვიდრე პასუხი პირდაპირ წავიდეთ წინ და უბრალოდ გაივლის მამალი.
ოჰ, რამდენი ადამიანი მარცხნივ მე?
რამდენი ადამიანი მარცხნივ?
1.
[სიცილის]
Okay, ასე 0, ასე რომ, ახლა ვილი გააკეთა
არის თქვენ დაბრუნდა თქვენი პასუხი ამ მიმართულებით ამბობდა 0.
ახლა, რა უნდა გავაკეთოთ? >> 1.
Okay, ასე რომ თქვენ 1, ასე რომ თქვენ ამბობენ, "ყველა უფლება, მე ვაპირებ დაამატოთ 1
to whatever Willy ს რაოდენობა იყო ", ასე 1 + 0.
თქვენ ახლა 1 ასე რომ თქვენი პასუხი უფლება არის-
1. >> და ნაღმების იქნებოდა 2.
კარგი, ასე რომ თქვენ აღების წინა პასუხი 1,
დასძინა მინიმალური ოდენობა სამუშაო გსურთ, რომელიც +1.
თქვენ ახლა უკვე 2 და შემდეგ გადასცემს ჩემთვის, რომელიც ღირებულების?
3, ვგულისხმობ, უკაცრავად, 2.
კარგი.
>> ასევე, ჩვენ გვქონდა 0 მარცხნივ.
მაშინ ჩვენ გვქონდა 1 და შემდეგ დავუმატებთ 2,
და ახლა თქვენ გადაცემის ჩემთვის ნომერი 2,
და ა.შ. მე ვამბობ,, okay, +1, 3.
იქ მართლაც 3 ადამიანი იდგა ჩემს გვერდით ამ ეტაპზე,
ამიტომ ჩვენ შეეძლო აშკარად კეთდება ეს ძალიან ხაზოვანი,
ძალიან ბევრი აშკარა მოდის, მაგრამ რა მივიღეთ ნამდვილად?
ჩვენ მივიღეთ პრობლემა ზომა 3 თავდაპირველად.
ჩვენ მაშინ დაარღვია მისი დანგრევა შევიდა პრობლემა ზომა 2,
მაშინ პრობლემა ზომა 1, ხოლო შემდეგ საბოლოოდ ბაზის შემთხვევაში
მართლაც, OH არ არსებობს ერთი,
სადაც წერტილი Willy დაბრუნდა ეფექტურად მყარი კოდირებული პასუხი რამოდენიმე ჯერ,
ხოლო მეორე იყო მაშინ bubbled up, bubbled up, bubbled up,
ხოლო შემდეგ დასძინა ამ ერთ დამატებით 1
ჩვენ განხორციელებული ამ ძირითად იდეას უკან.
>> ახლა კი, ამ შემთხვევაში ეს არ ნამდვილად გადაჭრას პრობლემა
ნებისმიერი უფრო ეფექტურად, მაშინ ჩვენ ვნახეთ დღემდე.
მაგრამ ვიფიქროთ ალგორითმები ჩვენ გავაკეთეთ სცენაზე დღემდე.
ჩვენ გვქონდა 8 ცალი ქაღალდის on chalkboard,
on ვიდეო როცა შონ ეძებდა ნომერი 7, რა უნდოდა მას ნამდვილად?
ისე, მან ეს არ გააკეთა რაიმე სახის გათიშე და დაიპყროთ.
მან ეს არ გააკეთა რაიმე სახის უკან.
პირიქით, მან უბრალოდ ეს ხაზოვანი ალგორითმი.
მაგრამ როდესაც ჩვენ გააცნო იდეა დახარისხებული ნომრები სცენაზე ვცხოვრობთ გასულ კვირას
მაშინ ჩვენ გვქონდა ამ ინსტიქტი აპირებს ახლო,
სადაც წერტილი გვქონდა პატარა ჩამონათვალი ზომა 4 ან სხვა ჩამონათვალი ზომა 4,
და მაშინ ჩვენ გვქონდა ზუსტად იგივე პრობლემა, ამიტომ ჩვენ მეორდება, განმეორებითი, განმეორდეს.
სხვა სიტყვებით, ჩვენ recursed.
დიდი მადლობა ჩვენი 3 მოხალისეები აქ დემონსტრირების უკან ჩვენთან.
>> ვნახოთ, შევძლებთ თუ არა, რომ ეს არის ცოტა უფრო კონკრეტული,
პრობლემის გადაწყვეტის, რომ ერთხელ ჩვენ შეეძლო საკმაოდ ადვილად,
მაგრამ ჩვენ ვიყენებთ მას როგორც სტეპინგზე ქვის შეასრულოს ამ ძირითად იდეას.
თუკი მინდა გამოთვლაც summation საქართველოს bunch of ნომრები,
მაგალითად, თუ თქვენ გაივლის მთელ რიგ 3,
მინდა გადმოგცეთ ღირებულება სიგმა 3,
ასე თანხა 3 + 2 + 1 + 0.
მინდა დავუბრუნდეთ პასუხი 6,
ამიტომ ჩვენ შეასრულოს ეს სიგმა ფუნქცია, ამ summation ფუნქცია
რომ, კვლავ იღებს in შეყვანის და შემდეგ დააბრუნებს summation
ამ რაოდენობის ყველა გზა ქვემოთ 0.
ჩვენ შეგვეძლო ამის გაკეთება საკმაოდ უბრალოდ, არა?
ჩვენ შეგვეძლო ამის გაკეთება რამდენიმე სახის looping სტრუქტურა,
ნება მომეცით, წავიდეთ წინ და ამ დაიწყო.
>> ჩართეთ stdio.h.
ნება მომეცით კიდევ თავს შევიდა ძირითადი მუშაობა აქ.
გადავარჩინოთ ეს როგორც sigma.c.
მაშინ მე ვაპირებ წასვლა აქ და მე ვაპირებ განაცხადოს int n,
და მე ვაპირებ გავაკეთოთ შემდეგი ხოლო მომხმარებლის არ ითანამშრომლებს.
მიუხედავად იმისა, რომ მომხმარებლებს არ მომცა დადებითი ხმების
ნება მომეცით წავიდეთ წინ და შეეკითხება მათ n = GetInt,
და ნება მომეცით მივცეთ ზოგიერთ ინსტრუქციას, თუ რა უნდა გავაკეთოთ,
ასე printf ("დადებითი მთელი რიცხვი გთხოვთ").
უბრალოდ რაღაც შედარებით მარტივი მოსწონს ეს ასე, რომ ახლა ჩვენ მოხვდა ხაზი 14
ჩვენ ახლა აქვს დადებითი მთელი რიცხვი სავარაუდოდ n.
>> ახლა მოდით რაღაც არის.
ნება მომეცით წავიდეთ წინ და გამოთვლაც summation, ასე int თანხა = სიგმა (N).
სიგმა მხოლოდ summation, ამიტომ მე უბრალოდ წერა მას fancier გზა.
ჩვენ უბრალოდ ვუწოდებთ მას სიგმა არსებობს.
სწორედ თანხა, და ახლა მე ვაპირებ ამობეჭდოთ შედეგი,
printf ("თანხა არის% d \ n", თანხა).
და მაშინ მე დაბრუნებას 0 კარგი ღონისძიება.
ჩვენ ყველაფერი გავაკეთეთ, რომ ეს პროგრამა საჭიროებს გარდა საინტერესო ნაწილი,
რაც რეალურად განახორციელოს სიგმა ფუნქცია.
>> ნება მომეცით დაცემას აქ ბოლოში, და ნება მომეცით განაცხადოს ფუნქციის სიგმა.
ეს მივიღე მიიღოს ცვლადი რომ ტიპის რიცხვი,
და რა ტიპის მონაცემის არ მინდა დაბრუნებას სავარაუდოდ საწყისი სიგმა?
Int, რადგან მინდა, რომ ის ემთხვევა ჩემი მოლოდინი on line 15.
აქ ნება მომეცით წავიდეთ წინ და განახორციელოს ამ
წელს საკმაოდ პირდაპირი გზა.
>> მოდით წავიდეთ წინ და ვთქვათ int თანხა = 0,
და ახლა მე ვაპირებ წასვლა აქვს პატარა ამისთვის loop აქ
რომ აპირებს ამბობენ რაღაც მსგავსი,
ამისთვის (int i = 0; I <= ნომერი; i + +) თანხა + = i.
და შემდეგ მე ვაპირებ დაბრუნებას თანხა.
მე ვერ განვახორციელეთ ეს ნებისმიერი რაოდენობის გზები.
შემეძლო არ გამოიყენება, ხოლო loop.
შემეძლო არ გამოტოვებენ გამოყენებით თანხა ცვლადი თუ ნამდვილად უნდოდა,
მაგრამ მოკლედ, ჩვენ უბრალოდ უნდა ფუნქცია რომ თუ არ goof აცხადებს თანხა 0.
მაშინ iterates საწყისი 0 on up მეშვეობით ნომერი,
და თითოეულ iteration იგი დასძენს, რომ მიმდინარე ღირებულების თანხა და შემდეგ დააბრუნებს თანხას.
>> ახლა არის უმნიშვნელო ოპტიმიზაცია აქ.
ეს არის ალბათ შეეწირა ნაბიჯი, მაგრამ ასე იქნება ეს. სწორედ ჯარიმა არის.
ჩვენ მინიმუმ მყოფი ამომწურავი და ვაპირებთ 0 ყველა გზა on up.
არ არის ძალიან რთული და საკმაოდ მარტივია,
მაგრამ აღმოჩნდება, რომ სიგმა ფუნქცია გვაქვს იგივე შესაძლებლობა
როგორც ჩვენ აქ სცენაზე.
სცენაზე ჩვენ უბრალოდ დათვლილი რამდენი ადამიანი იყო ჩემს გვერდით,
მაგრამ ნაცვლად თუ გვინდოდა ითვლიან ნომერი 3 + 2 + 1
on ქვემოთ 0 შეგვეძლო ანალოგიურად punt to ფუნქცია
რომ მე ნაცვლად აღწერს როგორც რეკურსიული.
აქ მოდით სწრაფი საღი აზრის შეამოწმეთ და დარწმუნდით მე არ goof.
>> მე ვიცი, არსებობს მინიმუმ ერთი რამ ამ პროგრამაში, რომ მე გავაკეთებ არასწორია.
როდესაც მე დააჭიროთ მე აპირებს მიიღოს ნებისმიერი სახის yelling at me?
რა ვარ მე უნდა yelled დაახლოებით?
ჰო, დამავიწყდა პროტოტიპი, ამიტომ მე გამოყენებით ფუნქციის მოუწოდა სიგმა on line 15,
მაგრამ ეს არ გამოცხადდა, სანამ ხაზი 22, მე საუკეთესო პროაქტიულად ახვიდეთ აქ
და აცხადებენ, პროტოტიპი, და მე ვთქვა int სიგმა (int ნომერი), და ამით ყველაფერი მთავრდება.
ეს განხორციელდა ბოლოში.
>> ან სხვა გზა მე ვერ გადაჭრის ამ,
შემეძლო გადაადგილება ფუნქცია up there, რაც ცუდი არ არის,
მაგრამ მაინც, როდესაც თქვენი პროგრამების დაიწყოს მიიღოს ხანგრძლივი, გულწრფელად,
ვფიქრობ, რამდენიმე ღირებულების მქონე ყოველთვის მთავარ ზედა
ასე რომ თქვენ მკითხველს შეუძლია გახსნას ფაილი და შემდეგ დაუყოვნებლივ ვხედავ
რა პროგრამა აკეთებს გარეშე ძებნის საშუალება
ეძებს, რომ მთავარი ფუნქცია.
მოდით წავიდეთ ქვემოთ ჩემი ტერმინალის ფანჯარაში აქ, სცადეთ მიღების სიგმა მიიღოს სიგმა,
და მე ბრალია აქაც.
იმპლიციტური დეკლარაციის ფუნქციის GetInt ნიშნავს მე დავიწყებული გავაკეთოთ რა?
[Inaudible-სტუდენტი]
კარგი, ასე აშკარად ჩვეულებრივი შეცდომა, მოდით დააყენა ამ მდე აქ,
cs50.h და ახლა მოდით დავუბრუნდეთ ჩემი ტერმინალის ფანჯარაში.
>> მე გარკვევა ეკრანზე, და მე გამეორება მიიღოს სიგმა.
როგორც ჩანს არ შედგენილი. ნება მიბოძეთ ახლა აწარმოებს სიგმა.
მე აკრიფოთ ნომერი 3, და მე კიდევ 6, ასე არ მკაცრი შემოწმება,
მაგრამ მაინც აშკარად ჩანს, რომ სამუშაო ერთი შეხედვით, მაგრამ ახლა მოდით დააკოპიროთ ის გარდა,
და მოდით რეალურად ბერკეტები იდეა უკან, კიდევ ერთხელ,
ძალიან მარტივია კონტექსტში ისე, რომ რამდენიმე კვირის განმავლობაში დრო
როდესაც ჩვენ ვიწყებთ შეისწავლოს fancier მონაცემები სტრუქტურების ვიდრე კოლექტორები
ჩვენ გვაქვს კიდევ ერთი იარაღია ინსტრუმენტარიუმის, რომლითაც
მანიპულირება ის მონაცემი სტრუქტურების როგორც ვნახავთ.
ეს არის iterative მიდგომა, მარყუჟის დაფუძნებული მიდგომა.
>> ნება მომეცით ნაცვლად ახლა ამის გაკეთება.
ნება მომეცით ნაცვლად ამბობენ, რომ summation საქართველოს ნომერი
on ქვემოთ 0 მართლაც იგივე, როგორც
პუნქტების + სიგმა (ნომერი - 1).
სხვა სიტყვებით, ისევე სცენაზე მე punted თითოეულ ადამიანი ჩემს გვერდით,
და ისინი თავის მხრივ ინახება punting სანამ ჩვენ საბოლოოდ bottomed გამოსვლით ვილი,
ვისაც ჰქონდა დაბრუნების მყარი კოდირებული პასუხი მოსწონს 0.
აქ არის ჩვენ ასეთივე punting to სიგმა
იგივე ფუნქცია, როგორც თავდაპირველად მოუწოდა, მაგრამ გასაღები ინსაითი აქ
ის არის, რომ ჩვენ არ მოუწოდებდა სიგმა იდენტურად.
ჩვენ არ გადადის n.
ჩვენ ნათლად გადადის ნომერი - 1,
ამიტომ ოდნავ პატარა პრობლემა, ოდნავ პატარა პრობლემა.
>> სამწუხაროდ, ეს არ არის საკმაოდ გამოსავალი არ არის, და სანამ ჩვენ დაფიქსირება
რა შეიძლება jumping, როგორც აშკარა რაღაც თქვენგანს
ნება მომეცით წავიდეთ წინ და გამეორება მიიღოს.
როგორც ჩანს შედგენა okay.
ნება მომეცით გამეორება სიგმა ერთად 6.
Whoops, ნება მომეცით გამეორება სიგმა ერთად 6.
ჩვენ ვხედავთ ამ ადრე, თუმცა შემთხვევით ბოლო დროს ისევე.
რატომ მივიღებ ამ cryptic სეგმენტაცია ბრალია? Yeah.
[Inaudible-სტუდენტი]
იქ არ არის ბაზის შემთხვევაში, და უფრო კონკრეტულად, რა ალბათ მოხდა?
ეს არის სიმპტომია რა საქციელი?
ამბობენ, რომ ეს პატარა louder.
[Inaudible-სტუდენტი]
ეს უსასრულო ციკლი ეფექტურად და პრობლემა უსასრულო მარყუჟების
როდესაც მათ ჩართვას უკან ამ შემთხვევაში, ფუნქციის მოუწოდებდა თავად,
რა ხდება ყოველ ჯერზე რეკავთ ფუნქცია?
ისე, ვფიქრობ, თავში თუ როგორ ასახული მეხსიერება კომპიუტერის.
ჩვენ ვთქვით, რომ არსებობს ამ ბლოკი მეხსიერება მოუწოდა დასტის რომ ბოლოში,
და ყოველ ჯერზე რეკავთ ფუნქცია ცოტა მეტი მეხსიერების იღებს დააყენა
ამ ე.წ. დასტის შემცველი რომ ფუნქციის ლოკალური ცვლადების ან პარამეტრების,
ასე რომ, თუ სიგმა მოუწოდებს სიგმა მოუწოდებს სიგმა სიგმა მოუწოდებს
უწოდებს სიგმა სად ეს ამბავი ბოლომდე?
>> ისე, ეს საბოლოოდ overruns სულ თანხა
მეხსიერების რომ თქვენ გაქვთ ხელმისაწვდომი თქვენს კომპიუტერში.
თქვენ overrun სეგმენტი, რომ თქვენ უნდა დარჩენა ფარგლებში,
და თქვენ ამ სეგმენტაცია ბრალია, core dumped,
და რა ძირითადი dumped ნიშნავს, რომ მე უკვე ფაილი სახელად ძირითადი
რაც ფაილის შემცველი zeros და პირობა
რომ რეალურად მომავალში იქნება diagnostically სასარგებლო.
თუ ეს არ ნათელია, სად თქვენი შეცდომა
შეგიძლიათ მართლაც ცოტა სასამართლო ანალიზი, ასე ვთქვათ,
ამ ძირითადი ნაგავსაყრელი ფაილი, რომელიც, კიდევ ერთხელ, მხოლოდ მთელი bunch of zeros და პირობა
რომ არსებითად წარმოადგენს სახელმწიფო თქვენი პროგრამის მეხსიერებაში
მომენტიდან შეეჯახა ამ გზით.
>> სარემონტო აქ არის ის, რომ ჩვენ არ შეგვიძლია უბრალოდ ბრმად დაბრუნების სიგმა,
პუნქტების + სიგმა of ოდნავ პატარა პრობლემა.
ჩვენ გვჭირდება გარკვეული სახის ბაზის შემთხვევაში აქ,
და რა უნდა ბაზის შემთხვევაში ალბათ?
[Inaudible-სტუდენტი]
Okay, ასე სანამ ხმების დადებითია ჩვენ რეალურად უნდა დაუბრუნდნენ ამ,
ან განათავსოთ სხვა გზა, თუ ნომერი, ვთქვათ, <= 0
იცით, რა, მე წავიდეთ წინ და უკან დაბრუნებას 0,
ჰგავს Willy გააკეთა, და სხვას, მე ვაპირებ წავიდეთ წინ
და დაუბრუნოს ამ, ასე რომ არ არის, რომ ბევრად უფრო მოკლეა
ვიდრე iterative ვერსია, რომ ჩვენ whipped მდე პირველი გამოყენებით ამისთვის მარყუჟის,
მაგრამ შევნიშნოთ, რომ ამ სახის ელეგანტურობა მას.
დაბრუნების ნაცვლად რამდენიმე ნომერი და ასრულებენ ყველა ამ math
და დასძინა რამ ერთად ადგილობრივი ცვლადები
თქვენ ნაცვლად რომ "Okay, თუ ეს სუპერ მარტივი პრობლემა,
მოსწონს რიცხვი <0, ნება მომეცით დაუყოვნებლივ დაბრუნებას 0. "
>> ჩვენ არ ვაპირებთ შეწუხება მხარდამჭერი უარყოფითი რიცხვები,
ამიტომ მე ვაპირებ მძიმე კოდი მნიშვნელობა 0.
მაგრამ სხვაგვარად, შეასრულოს ეს იდეა შემაჯამებელი
ყველა ამ ნომრებზე ერთად შეგიძლიათ ეფექტურად მიიღოს პატარა bite
გარეთ პრობლემა, გაცილებით ისე, როგორც აქ სცენაზე,
მაშინ punt დანარჩენ პრობლემას შემდეგი პირი,
მაგრამ ამ შემთხვევაში შემდეგი პირი თავს.
ეს იდენტურად დაასახელა ფუნქცია.
Just გაიაროს ეს პატარა და პატარა და პატარა პრობლემა ყოველ ჯერზე,
და მიუხედავად იმისა, რომ ჩვენ არ საკმაოდ ფორმალიზებული რამ კოდი აქ
ეს არის ზუსტად ის, რაც ხდებოდა კვირაში 0 ერთად სატელეფონო წიგნში.
ეს არის ზუსტად ის, რაც ხდებოდა წარსულში კვირის ერთად შონ
და ჩვენი დემონსტრაციების ეძებს ნომრები.
ის აღების პრობლემა და გამყოფი ეს ისევ და ისევ.
>> სხვა სიტყვებით, არსებობს გზა არის თარგმნა
ამ რეალურ სამყაროში შენება, ამ უმაღლეს დონეზე შენება
საქართველოს გაყოფა და დაპყრობა და თავისსავე ისევ და ისევ
კოდის, ამიტომ ეს არის ის ვნახავთ ერთხელ დროთა განმავლობაში.
ახლა, როგორც განზე, თუ თქვენ ახალი უკან თქვენ მაინც უნდა გვესმოდეს, ახლა
ამიტომ ეს არის სასაცილო.
მე ვაპირებ წასვლა google.com,
და მე ვაპირებ მოძებნოთ რამდენიმე რჩევა და ხრიკები წლის უკან, შეიყვანოთ.
Tell პირის შემდეგ, თუ ისინი არ იცინის ახლა.
ხომ არ იგულისხმეთ უკან?
ხომ არ იგულისხმეთ-ah, იქ წასვლა.
Okay, ახლა რომ დანარჩენ ყველას.
პატარა აღდგომის კვერცხი ჩანერგილი სადღაც იქ Google.
როგორც განზე, ერთი Links ჩვენ ჩაიცვი რა თქმა ნახვა
დღეს მხოლოდ ამ ქსელის სხვადასხვა დახარისხება ალგორითმები,
რომელთაგან ზოგიერთი ჩვენ შევხედეთ გასულ კვირას, მაგრამ რა ლამაზი ამ ვიზუალიზაცია
როგორც თქვენ ცდილობენ გადაიტანოთ თქვენი აზრით გარშემო სხვადასხვა რამ დაკავშირებული ალგორითმები
ვიცი, რომ თქვენ შეგიძლიათ ძალიან მარტივად არის იწყება სხვადასხვა ტიპის საშუალებებით.
საშუალებებით ყველა შეცვალა, საშუალებებით ძირითადად დახარისხებული, საშუალებებით შემთხვევითი და სხვ.
როგორც თქვენ ცდილობენ, კიდევ ერთხელ, გამოირჩეოდნენ ეს ყველაფერი თქვენს გონება
გააცნობიეროს, რომ ეს მისამართი თქმა ნახვა on ლექციები გვერდზე
შესაძლოა დაგეხმაროთ მიზეზი მეშვეობით ზოგიერთი ასეთი.
>> დღეს ჩვენ საბოლოოდ მივიღებთ ამ პრობლემის მოგვარებას საწყისი ხოლო უკან,
რაც იყო, რომ ეს swap ფუნქციის უბრალოდ არ მუშაობდა,
და რა იყო ფუნდამენტური პრობლემა ამ ფუნქციის swap,
რომლის მთავარი მიზანი, კიდევ ერთხელ, გაცვლა ღირებულება აქ და აქ
ისეთი, რომ ეს მოხდება?
ეს არ რეალურად იმუშაოს. რატომ?
Yeah.
[Inaudible-სტუდენტი]
სწორედ ახსნა ამ bugginess
უბრალოდ იყო, რადგან როცა რეკავთ ფუნქციების C
და ამ ფუნქციების მიიღოს არგუმენტები, როგორიცაა და B აქ,
თქვენ გადადის ასლები რასაც ღირებულება თქვენ უზრუნველყოფს, რომ ფუნქცია.
თქვენ არ უზრუნველყოფს ორიგინალური ღირებულებებს თავს,
ასე ჩვენ ვნახეთ ამ კონტექსტში buggyc,
buggy3.c, რომელიც გამოიყურებოდა ცოტა რაღაც მსგავსი.
>> შეგახსენებთ, რომ ჩვენ გვქონდა x და y ინიციალიზაცია რომ 1 და 2, შესაბამისად.
ჩვენ მაშინ ამობეჭდილი რაც იყო.
მე მაშინ აცხადებდა, რომ მე შევცვალე მათ დარეკვით swap of x, y.
მაგრამ პრობლემა ის იყო, რომ შევცვალე მუშაობდა,
თუმცა მხოლოდ ფარგლებს swap ფუნქციონირებას თავად.
როგორც კი მოხვდა ხაზი 40 იმ swapped ღირებულებები
მოხვდნენ მოშორებით, და ასე არაფერი
თავდაპირველ ფუნქციას ძირითად სინამდვილეში შეცვლილა,
ასე რომ, თუ თქვენ ფიქრობთ, მაშინ რაც ამ ჰგავს თვალსაზრისით ჩვენი მეხსიერება
თუ ამ მარცხენა მხარეს გამგეობა წარმოადგენს-
და მე გავაკეთებ ყველასთვის, რომ ეს თუ ამ მარცხენა მხარეს ფორუმში
წარმოადგენს, ვთქვათ, თქვენი RAM და დასტის აპირებს იზრდება up ამ გზით,
და მოვუწოდებთ ფუნქცია, როგორიცაა ძირითადი და უმთავრესი აქვს 2 ადგილობრივი ცვლადები, X და Y,
მოდით აღვწეროთ იმ როგორც x აქ, და მოდით აღვწეროთ ეს როგორც Y აქ,
და მოდით დასვა ღირებულებების 1 და 2, ასე რომ ეს აქ არის მთავარი,
და როდესაც მთავარ მოუწოდებს swap ფუნქციის ოპერაციული სისტემა
აძლევს swap ფუნქციის საკუთარი swath მეხსიერების on დასტის,
საკუთარი ჩარჩო დასტის, ასე ვთქვათ.
იგი ასევე გამოყოფს 32 ბიტი ამ ints.
ეს ხდება მოვუწოდებთ მათ და B, მაგრამ ეს სრულიად უკანონო.
ეს შეეძლო მოუწოდა მათ რაც არ სურს, მაგრამ რა ხდება მაშინ, როდესაც მთავარი
მოუწოდებს swap არის სჭირდება ამ 1, აყენებს ასლი არსებობს, აყენებს ასლი არსებობს.
>> არსებობს 1 სხვა ადგილობრივ ცვლადი in swap, თუმცა, მოუწოდა რა? >> Tmp.
TMP, ნება მომეცით, მისცეს თავს კიდევ 32 ბიტი აქ,
და რა გავაკეთო ამ ფუნქციას?
მე ვუთხარი int tmp იღებს, ასე რომ არის 1, ასე რომ მე ამ როდესაც ჩვენ ბოლო ითამაშა, რომელზეც ეს მაგალითი.
მაშინ იღებს B, ამიტომ B არის 2, ასე რომ ახლა ამ ხდება 2,
და ახლა ბ იღებს temp, ასე Temp არის 1,
ახლა ბ ხდება ამ.
სწორედ დიდი. იგი მუშაობდა.
მაგრამ შემდეგ, როგორც კი ფუნქცია დააბრუნებს
swap ხსოვნას ეფექტურად ქრება ისე, რომ იგი შეიძლება reused
ზოგიერთი სხვა ფუნქცია მომავალში, და ძირითადი აშკარად სრულიად უცვლელი.
ჩვენ გვჭირდება გზა ფუნდამენტურად პრობლემის მოსაგვარებლად,
და დღეს ჩვენ საბოლოოდ აქვს გზა ამით რის
ჩვენ შეგვიძლია წარმოგიდგინოთ რაღაც მოუწოდა მაჩვენებელი.
თურმე ჩვენ შეგვიძლია ამ პრობლემის მოგვარებას
არ გავლით in ასლები x და y
მაგრამ ნაცვლად გავლით რა, ფიქრობთ, რომ swap ფუნქცია?
ჰო, რაც შეეხება მისამართი?
ჩვენ ნამდვილად არ ისაუბრა მისამართები ბევრად დეტალურად
მაგრამ თუ ამ დაფაზე წარმოადგენს ჩემი კომპიუტერის მეხსიერებაში
ჩვენ ნამდვილად დაიწყება ნუმერაციის bytes ჩემი RAM
და ამბობენ, რომ ეს არის byte # 1, ეს არის byte # 2, byte # 3
byte # 4, byte # ... 2 მილიარდი თუ აქვს 2 გიგაბაიტი ოპერატიული მეხსიერება,
ამიტომ ჩვენ ნამდვილად ამუშავება ზოგიერთი თვითნებური ნუმერაციის სქემა
ყველა ინდივიდუალური bytes ჩემი კომპიუტერის მეხსიერებაში.
>> რა მოხდება, თუ ნაცვლად როდესაც მოვუწოდებ swap
ვიდრე კორიდორი ასლები x და y
რატომ არ მე ნაცვლად კორიდორი მისამართი x აქ,
მისამართი Y აქ, არსებითად საფოსტო მისამართი
of x და y რადგან მაშინ სვოპ, თუ იგი ინფორმირებული
მიმართვის ხსოვნისადმი x და y,
მაშინ სვოპ, თუ ჩვენ კარგად გაწვრთნილი მას ცოტა,
მან შესაძლოა გამგზავრება, რომ მისამართი, ასე ვთქვათ,
x, და შეცვალოს ნომერი არსებობს, მაშინ გამგზავრება მისამართი Y,
შეცვლის ნომერი არსებობს, მაშინაც კი, როდესაც რეალურად არ მიღების ასლები იმ ფასეულობებს თავს,
ამიტომ, მიუხედავად იმისა, ჩვენ ვისაუბრეთ ამ როგორც ძირითადი ხსოვნას
და ეს როგორც swap ხსოვნას ძლიერი და სახიფათო ნაწილი C
არის, რომ ნებისმიერი ფუნქცია შეიძლება შეეხოთ მეხსიერების სადმე კომპიუტერში,
და ეს არის მძლავრი, რომ შეგიძლიათ გააკეთოთ ძალიან ლამაზი რამ კომპიუტერული პროგრამების C.
ეს არის საშიში, რადგან შეგიძლიათ ასევე Screw up ძალიან მარტივად.
ფაქტობრივად, ერთი ყველაზე გავრცელებული გზა პროგრამების ამ დღეებში უნდა ექსპლუატაციაში
ჯერ კიდევ არის პროგრამისტი არ გააცნობიეროს
რომ მას მთლიანად ან ნაწილობრივ საშუალებითაც მონაცემები
უნდა ჩაიწეროს საიდან მეხსიერებაში, რომ არ იყო განკუთვნილი.
>> მაგალითად, იგი აცხადებს მასივი ზომა 10
მაგრამ შემდეგ შემთხვევით ცდილობს 11 ბაიტი შევიდა, რომ მასივი მეხსიერება,
და თქვენ დაიწყოს ეხება ნაწილები მეხსიერების, რომლებიც აღარ მოქმედებს.
მხოლოდ შინაარსობრივ ამ ზოგიერთი მოგეხსენებათ, რომ
პროგრამული ხშირად თხოვს თქვენ სერიული ნომრები ან რეგისტრაციის გასაღებები,
Photoshop და Word და პროგრამების მოსწონს ეს.
არსებობს ბზარები, როგორც ზოგიერთი იცით, ონლაინ სადაც შეგიძლიათ აწარმოებს პატარა პროგრამა,
და voila, არა მოთხოვნა სერიული ნომერი.
როგორ ხდება, რომ მუშაობის?
ხშირ შემთხვევაში ეს ყველაფერი უბრალოდ მოძიებას კომპიუტერები
ტექსტი სეგმენტებად კომპიუტერის ფაქტობრივი zeros და პირობა
აქ არის ის, რომ ფუნქცია სადაც სერიული ნომერი ითხოვს,
და თქვენ გადავაწერო, რომ სივრცე, ან მაშინ, როდესაც პროგრამა გაშვებულია
შეგიძლიათ გაერკვნენ, სადაც გასაღები ფაქტობრივად ინახება
გამოყენებით რაღაც მოუწოდა debugger, და თქვენ შეგიძლიათ ბზარი პროგრამული უზრუნველყოფა, რომ გზა.
ეს არ არის იმის თქმა, რომ ეს არის ჩვენი ამოცანა მომდევნო დღეებში,
მაგრამ მას აქვს ძალიან რეალურ სამყაროში ramifications.
რომ ერთი ხდება ჩართვა ქურდობა პროგრამული უზრუნველყოფა,
მაგრამ არსებობს ასევე კომპრომისის მთელი მანქანები.
>> სინამდვილეში, როდესაც საიტებზე ამ დღეებში შედის ექსპლუატაციაში
და კომპრომეტირებული და მონაცემები გაჟონა და პაროლები მოიპარეს
ეს ძალიან ხშირად ეხება ცუდი მართვა ერთი მეხსიერება,
ან, იმ შემთხვევაში, მონაცემთა ბაზა, წარუმატებლობა გავუსწრო
შეჯიბრებითობის შეყვანის, ასე უფრო, რომ კვირის მოსვლა,
მაგრამ ახლა მხოლოდ Sneak ესკიზი სახის ზარალი, რომელიც შეგიძლიათ გააკეთოთ,
არა საკმაოდ გასაგებად როგორ რამ მუშაობა ქვეშ hood.
მოდით წავიდეთ შესახებ გაგება რატომ გატყდა
ერთად ინსტრუმენტი, რომელიც სულ უფრო და უფრო სასარგებლო
როგორც ჩვენი პროგრამების კიდევ უფრო რთული.
ჯერჯერობით, როცა მქონდა bug თქვენს პროგრამაში
როგორ არ ხარ წასული შესახებ გამართვის ეს?
რა თქვენი ტექნიკის ყოფილა ჯერჯერობით თუ არა ასწავლიან თქვენი TF
ან უბრალოდ თვითნასწავლი?
[სტუდენტური] Printf.
Printf, ასე printf სავარაუდოდ თქვენი მეგობარი, რომ თუ გინდათ, ნახოთ
რა ხდება შიგნით თქვენი პროგრამა
უბრალოდ დააყენა printf აქ, printf აქ, printf აქ.
მაშინ თქვენ გაუშვით, და თქვენ მიიღებთ მთელი bunch პერსონალის ეკრანზე
რომ თქვენ შეგიძლიათ გამოიყენოთ შემდეგ დავასკვნათ რა არის რეალურად აპირებს არასწორი თქვენს პროგრამას.
>> Printf tends უნდა იყოს ძალიან ძლიერი რამ,
მაგრამ ძალიან მანუალურ პროცესს.
თქვენ უნდა დააყენოს printf აქ, printf აქ,
და თუ ამას შიგნით loop შესაძლოა 100 ხაზები
გამომავალი რომ თქვენ მაშინ უნდა Sift მეშვეობით.
ეს არ არის ძალიან მოსახერხებელი ან ინტერაქტიული მექანიზმს გამართვის პროგრამების,
მაგრამ საბედნიეროდ არსებობს ალტერნატივა.
არსებობს პროგრამა, მაგალითად, სახელად GDB, GNU Debugger,
რომელიც ცოტა arcane წელს თუ როგორ გამოიყენოს იგი.
ეს პატარა კომპლექსი, მაგრამ გულწრფელად ვამბობ,
ეს არის ერთ იმ რამ, სადაც თუ თქვენ დააყენა ამ კვირაში და შემდეგი
დამატებითი საათობრივად გვესმოდეს, რაღაც GDB
ეს დაგიზოგავთ თქვენ ალბათ ათობით საათი გრძელვადიან პერსპექტივაში,
ასე რომ, ნება მომეცით მოგცემთ teaser, თუ როგორ ეს რამ მუშაობს.
>> მე ჩემი ტერმინალის ფანჯარაში.
ნება მომეცით წავიდეთ წინ და შეადგინონ ამ პროგრამის buggy3.
ეს უკვე დღემდე.
ნება მომეცით აწარმოებს უბრალოდ ისე, როგორც მაშინ, როდესაც უკან, და მართლაც, ეს გატეხილი.
მაგრამ რატომ არის ეს? იქნებ მე ბრალია swap ფუნქცია.
შეიძლება უფრო და ბ. მე არ საკმაოდ მოძრავი მათ გარშემო სწორად.
ნება მომეცით წავიდეთ წინ და ამის გაკეთება.
იმის ნაცვლად, რომ უბრალოდ აწარმოებს buggy3 ნება მომეცით ნაცვლად აწარმოებს ამ პროგრამის GDB,
და მე ვაპირებ ვამბობ, რომ აწარმოებს buggy3,
და მე ვაპირებ მოიცავს command line არგუმენტი,-TUI,
და ჩვენ დააყენა ამ მომავალში პრობლემების სპეც შევახსენო.
და ახლა ამ შავი და თეთრი ინტერფეისი popped, რომ, ერთხელ,
არის პატარა აბსოლუტური თავდაპირველად რადგან იქ ყველა ამ
გარანტია ინფორმაცია ქვემოთ, მაგრამ მაინც არსებობს რაღაც ნაცნობი.
In ზევით ფანჯარა არის ჩემი ფაქტობრივი კოდი,
და თუ გადახვევა აქ ნება მომეცით გადახვევა რომ ძალიან ზევით ჩემი ფაილი,
და მართლაც, იქ buggy3.c და გაფრთხილების ბოლოში ფანჯრის
მაქვს ამ GDB ზოლზე.
>> ეს არ არის იგივე, რაც ჩემი ნორმალური ჯონ ჰარვარდის ზოლზე.
ეს არის სწრაფი, რომ აპირებს, ნება მიბოძეთ გააკონტროლოს GDB.
GDB არის debugger.
Debugger არის პროგრამა, რომელიც საშუალებას გაძლევთ გავლა
აღსრულების თქვენი პროგრამის ხაზის მიერ ხაზს,
გზაზე აკეთებს არაფერი გსურთ პროგრამა,
კი მოუწოდებდა ფუნქციებს, ან ეძებს, რაც მთავარია,
სხვადასხვა ცვლადი ღირებულებებს.
მოდით წავიდეთ წინ და ამის გაკეთება.
მე ვაპირებ წავიდეთ წინ და აკრიფოთ გარბოდა GDB ს სწრაფი,
ასე შეამჩნია ბოლოში მარცხნივ ეკრანზე მე აკრეფილი აწარმოებს,
და მე 'Enter, რა უნდოდა, რომ გავაკეთო?
ეს სიტყვასიტყვით გაიქცა ჩემი პროგრამით, მაგრამ მე არ რეალურად ბევრი წავიდეთ აქ
იმიტომ, რომ მე არ რეალურად განუცხადა debugger
პაუზის დროს განსაკუთრებული მომენტი დრო.
უბრალოდ აკრეფით პერსპექტივაში ეშვება პროგრამა.
მე არ რეალურად ვხედავ რაიმე. მე ვერ მის მართვას.
>> ამის ნაცვლად ნება მომეცით ამის გაკეთება.
ამ GDB სწრაფი ნება მომეცით ნაცვლად აკრიფოთ შესვენების შევა.
ეს არ არის ის, რაც მე ნიშნავდა ტიპის.
მოდით ნაცვლად აკრიფოთ შესვენების ძირითადი.
სხვა სიტყვებით, მინდა შექმნას რაღაც მოუწოდა breakpoint,
რომელიც aptly დაასახელა, რადგან ეს იქნება შესვენების ან პაუზის
აღსრულების თქვენი პროგრამის იმ კონკრეტულ ადგილას.
მთავარი არის სახელი ჩემი ფუნქცია.
გაითვალისწინეთ, რომ GDB საკმაოდ ჭკვიანი.
ეს figured, რომ მთავარი ხდება დაიწყოს უხეშად დროს ხაზი 18
საქართველოს buggy3.c და შემდეგ შეამჩნევთ აქ ზედა მარცხენა
B + არის სწორი შემდეგ ხაზი 18.
რომ ახსენებს, რომ შევქმენი breakpoint დროს ხაზი 18.
ეს დრო, როდესაც მე აკრიფოთ პერსპექტივაში, მე ვაპირებ აწარმოებს ჩემი პროგრამა
up სანამ გაიტანა რომ breakpoint,
ასე პროგრამა პაუზის ჩემთვის ხაზი 18.
აქ ჩვენ გადასვლა, აწარმოებს.
არაფერი ჩანს, მოხდა, მაგრამ გაფრთხილების ქვედა დაუტოვებიათ
დაწყებული პროგრამის, buggy3, breakpoint 1 მთავარ საათზე buggy3.c ხაზი 18.
როგორ მოვიქცე ახლა?
>> გაითვალისწინეთ შემიძლია დაიწყება აკრეფით რამ, როგორიცაა ბეჭდური,
არ printf, ბეჭდვითი x, და ახლა რომ უცნაურია.
$ 1 მხოლოდ ცნობისმოყვარეობა, როგორც ვნახავთ
ყოველ დროს, თქვენ ბეჭდვა რაღაც თქვენ ახალი $ ღირებულება.
სწორედ ასე რომ თქვენ შეგიძლიათ ეხება თავში წინა ღირებულებების მხოლოდ იმ შემთხვევაში,
მაგრამ ახლა რა არის ბეჭდვის მეუბნებოდა ის არის, რომ ღირებულება x ამ დროისთვის ამბავი
აშკარად 134514032.
რა? სად, რომ თუნდაც მოდის?
[Inaudible-სტუდენტი]
მართლაც, ეს არის ის, რაც ჩვენ მოვუწოდებთ ნაგვის ღირებულება, და ჩვენ არ ისაუბრა ამ გაუკეთებია,
მაგრამ მიზეზი, რომელიც ინიციალიზაცია ცვლადები
აშკარად ისე, რომ მათ აქვთ გარკვეული მნიშვნელობა, რომ გსურთ მათი აქვს.
მაგრამ დაჭერა არის გავიხსენოთ, რომ შეგიძლიათ განაცხადოს ცვლადები
მოსწონს მე მომენტში წინ ჩემი სიგმა მაგალითად
გარეშე რეალურად მათთვის მნიშვნელობა.
გავიხსენოთ, თუ როგორი მე მეტი აქ სიგმა.
მე განაცხადა N, მაგრამ რა ღირებულება არც მე ვაძლევ მას?
არა, რადგან ვიცოდი, რომ უახლოეს ხაზები
GetInt იზრუნებს პრობლემა აყენებს ღირებულება შიგნით n.
>> მაგრამ ამ დროისთვის ამბავი ხაზი 11
და ხაზი 12 და ხაზის 13 და ხაზი 14
მთელ იმ რამდენიმე ხაზები რა არის ღირებულება N?
In C უბრალოდ არ ვიცი.
ეს ზოგადად ზოგიერთი ნაგვის ღირებულება, ზოგიერთი სრულიად შემთხვევითი რიცხვების
რომ დარჩენილი ძირითადად ზოგიერთი წინა ფუნქცია
რომელსაც აწარმოებს, ამიტომ, როგორც თქვენი პროგრამა ეშვება
გავიხსენოთ, რომ ფუნქცია იღებს ფუნქცია, ფუნქციის, ფუნქცია.
ყველა ამ ფარგლებში მისაღებად ჩაიცვი მეხსიერების და შემდეგ ამ ფუნქციების დაბრუნების,
და ისევე, როგორც მე შესთავაზა ერთად Eraser მათი მეხსიერების საბოლოოდ reused.
ისე, ეს მხოლოდ ასე ხდება, რომ ეს ცვლადი x ამ პროგრამაში
როგორც ჩანს, არ შეიცავდა ზოგიერთ ნაგვის ღირებულება მოსწონს 134514032
ზოგიერთი წინა ფუნქცია, არ არის ერთი, რომ დავწერე.
ეს შეიძლება იყოს რაღაც რომ მოდის ეფექტურად ოპერაციული სისტემა,
ზოგიერთი ფუნქციის ქვეშ hood.
>> Okay, რომ ჯარიმა, მაგრამ მოდით ახლა წინასწარ შემდეგი ხაზი.
თუ I ტიპის "შემდეგი" ჩემს GDB სწრაფი და მე 'Enter,
შეამჩნევთ, რომ შეფერადება მოძრაობს ქვემოთ ხაზის 19,
მაგრამ ლოგიკური გავლენა არის, რომ ხაზი 18
ახლა დასრულდა შესრულებაში, ასე რომ, თუ ისევ აკრიფოთ "ბეჭდვის x"
მე ახლა უნდა ნახოთ 1, და მართლაც, მე.
ერთხელ, $ პერსონალი არის გზა GDB ახსენებს თქვენ
რა ისტორიაში ანაბეჭდები ვართ, რომ თქვენ გავაკეთეთ.
ახლა ნება მომეცით წავიდეთ წინ და ამობეჭდოთ Y, და მართლაც, Y არის ზოგიერთი გიჟები ღირებულება, ისევე,
მაგრამ არა დიდი გარიგება, რადგან ხაზი 19 ჩვენ შესახებ დაავალოს ეს
ღირებულება 2, ნება მომეცით, აკრიფოთ "შემდეგი" კიდევ ერთხელ.
და ახლა ჩვენ შესახებ printf ხაზი.
ნება მომეცით გავაკეთოთ ბეჭდვითი x.
ნება მომეცით გავაკეთოთ ბეჭდვითი წ. სიმართლე, მე მიღების ცოტა დაღლილი დაბეჭდვის ამ.
ნება მომეცით ნაცვლად აკრიფოთ "ჩვენების x" და "ჩვენების Y"
და ახლა ყოველ ჯერზე მე აკრიფოთ ბრძანება მომავალში
მე იქნება შეახსენა, რა X და Y, რა X და Y, რა x და y.
>> შემიძლია ასევე, როგორც განზე ტიპის "ინფორმაცია ადგილობრივები."
ინფორმაცია არის სპეციალური ბრძანება.
ადგილობრივები ნიშნავს, რომ იგი გვიჩვენებს ჩემთვის ადგილობრივი ცვლადები.
Just შემთხვევაში მე დაგვავიწყდეს ან ეს გიჟები, რთული ფუნქცია
რომ მე ან ვინმე წერდა ინფორმაცია ადგილობრივები გეტყვით
რისთვის არის ყველა ადგილობრივი ცვლადები შიგნით ამ ადგილობრივი ფუნქცია
რომ თქვენ შეიძლება აინტერესებს, თუ გსურთ poke გარშემო.
ახლა, printf დაახლოებით შეასრულოს, ნება მომეცით, წავიდეთ წინ და მხოლოდ ტიპის "შემდეგი".
იმის გამო, რომ ჩვენ ამ გარემოში ჩვენ რეალურად არ ხედავს იგი
შეასრულოს ქვემოთ აქ, მაგრამ შეამჩნია ის მიღების პატარა mangled აქ.
მაგრამ შენიშნავს უმთავრესი ეკრანზე იქ,
ამიტომ არ სრულყოფილი პროგრამა აქ, მაგრამ ეს okay, რადგან მე ყოველთვის შეგიძლიათ poke გარშემო
გამოყენებით ბეჭდვითი თუ მინდა.
>> ნება მომეცით აკრიფოთ შემდეგი ერთხელ და ახლა აქ საინტერესო ნაწილი.
ამ დროისთვის ამბავი Y არის 2, და x არის 1,
როგორც შესთავაზა აქ, და კიდევ ერთხელ,
მიზეზი ეს ავტომატურად ჩვენებისას ახლა არის იმიტომ, რომ მე გამოიყენება ბრძანება
ჩვენების x და y ჩვენების, ამიტომ მომენტში მე აკრიფოთ შემდეგი
თეორიულად x და y უნდა გახდეს swapped.
ახლა ჩვენ უკვე ვიცით, რომ არ იქნება იმ შემთხვევაში,
მაგრამ ჩვენ ვხედავთ მომენტში როგორ შეგვიძლია ჩაყვინთვის უფრო ღრმა უნდა გაერკვნენ, თუ რატომ, რომ მართალია.
შემდეგი, სამწუხაროდ, Y კვლავ 2 და x კვლავ 1, და შემიძლია დავადასტურო იმდენი.
ბეჭდვის x, ბეჭდვითი წ.
მართლაც, არ შევცვალე უკვე მოხდა სინამდვილეში, ასე რომ დავიწყოთ ამ დასრულდა.
ცხადია swap-ის ბრალია.
მოდით ნაცვლად აკრიფოთ "Run" კიდევ ერთხელ.
ნება მომეცით აღვნიშნო დიახ, მინდა გადატვირთეთ იგი თავიდანვე, შეიყვანოთ.
>> ახლა დავბრუნდი up at ხაზი 18.
ახლა შეამჩნია x და y არიან ნაგვის ღირებულებების ერთხელ.
შემდეგი, შემდეგი, შემდეგი, მომდევნო.
თუ მე მოგწყინდება შემიძლია ასევე უნდა აკრიფოთ N მომავალი.
შეგიძლიათ abbreviate მას უმოკლეს თანმიმდევრობა სიმბოლო.
სვოპი არის გატეხილი.
მოდით Dive in, ასე ნაცვლად აკრეფის შემდეგი,
ახლა მე ვაპირებ აკრიფოთ ნაბიჯი ისე, რომ მე სტეპინგზე შიგნით ამ ფუნქციის
ასე რომ შემიძლია გავლა, ასე რომ მე მოხვდა ნაბიჯი და მხოლოდ შემდეგ შეიყვანოთ.
გაითვალისწინეთ, რომ შეფერადება jumps ქვემოთ ქვედა ჩემი პროგრამის ხაზი 36.
ახლა რა ადგილობრივი ცვლადები?
ინფორმაცია ადგილობრივები.
არაფერი უბრალოდ არავის გაუკეთებია რადგან ჩვენ არ შემოსული, რომ ხაზი,
მოდით წავიდეთ წინ და ვთქვათ "შემდეგი".
ახლა ჩვენ, როგორც ჩანს, აქვს tmp, ბეჭდვითი tmp.
Garbage ღირებულება, არა? ვფიქრობ ასე.
როგორ შესახებ ბეჭდვა, ბეჭდვითი ბ, 1 და 2?
In მომენტში, როგორც კი აკრიფოთ შემდეგი ერთხელ
tmp აპირებს მიიღოს ღირებულება 1, იმედია,
რადგან tmp აპირებს ენიჭება ღირებულების.
>> ახლა მოდით ბეჭდვა, ბეჭდვითი ბ,
მაგრამ ახლა ბეჭდვა tmp, და ეს მართლაც 1.
ნება მომეცით გავაკეთოთ შემდეგი. ნება მომეცით გავაკეთოთ შემდეგი.
მე დავამთავრე swap ფუნქცია.
მე ჯერ კიდევ შიგნით ეს ხაზი 40, ნება მომეცით, ბეჭდვა,
ბეჭდვითი B, და არ მაინტერესებს რა tmp არის.
როგორც ჩანს swap არის სწორი, როდესაც საქმე შევცვალე და ბ.
მაგრამ თუ მე ახლა აკრიფოთ შემდეგი, მე ხტომა თავში ხაზი 25,
და რა თქმა უნდა, თუ ტიპის x და ბეჭდვითი Y
ისინი კვლავ უცვლელია, ამიტომ ჩვენ არ დაფიქსირდა პრობლემა.
მაგრამ diagnostically ახლა ალბათ ამ GDB პროგრამა
ჩვენ მინიმუმ მიღებული ერთი ნაბიჯით მიუახლოვდება გაგება
რა ხდება არასწორი გარეშე litter ჩვენი კოდი გამოსული printf აქ,
printf აქ, printf აქ და შემდეგ გაშვება ვერ ისევ და ისევ
ცდილობს გაერკვნენ რა ხდება არასწორი.
>> მე ვაპირებ წავიდეთ წინ და დატოვა ამ საერთოდ ერთად დატოვა.
იგი აპირებს, მაშინ ამბობენ, "Quit მაინც?" დიახ.
ახლა დავბრუნდი, ჩემი ჩვეულებრივი სწრაფი და მე გაკეთდეს გამოყენებით GDB.
როგორც განზე, თქვენ არ უნდა გამოვიყენოთ ამ-TUI დროშა.
ფაქტობრივად, თუ გამომრჩეს ეს თქვენ არსებითად ქვედა ნახევარში ეკრანზე.
თუ მე აკრიფეთ შესვენების ძირითადი და შემდეგ აწარმოებს
შემიძლია კვლავ აწარმოებს ჩემი პროგრამით, მაგრამ თუ რას გავაკეთებ უფრო textually
უბრალოდ ეჩვენებინა მიმდინარე ხაზს ერთ დროს.
-TUI, ტექსტური ინტერფეისი,
მხოლოდ გიჩვენებთ მეტი პროგრამის ერთდროულად, რომელიც ალბათ ცოტა კონცეპტუალურად ადვილია.
მაგრამ მართლაც, მე შემიძლია უბრალოდ შემდეგი, შემდეგი, მომდევნო,
და მე ვაპირებ ვხედავ ერთ ხაზს იმ დროს, და თუ ნამდვილად გვინდა, რომ რა ხდება
შემიძლია ტიპების სიას და ვნახოთ მთელი bunch of მეზობელ ხაზები.
>> იქ ვიდეო რომ ჩვენ ვთხოვეთ, რომ თქვენ უყუროთ პრობლემის ადგენს 3
რომელშიც Nate მოიცავს ზოგიერთი intricacies of GDB,
და ეს არის ერთ ერთი იმ რამ, პატიოსნად, სადაც რამდენიმე არასამთავრობო ტრივიალური პროცენტული თქვენ
არასდროს შეეხოთ GDB, და რომ იქნება ცუდი რამ
რადგან სიტყვასიტყვით თქვენ დასრულდება მდე ხარჯავს მეტი ხნის შემდეგ ამ სემესტრში
მისდევდნენ ქვემოთ შეცდომები მაშინ იქნებოდა თუ თქვენც არ დაიშურებთ, რომ ნახევარ საათში / საათობრივად
ამ კვირაში და შემდეგი სწავლის მისაღებად კომფორტულად GDB.
Printf იყო თქვენი მეგობარი.
GDB უნდა იყოს თქვენი მეგობარი.
>> ნებისმიერი შეკითხვა GDB?
და აქ სწრაფი სიაში ზოგიერთი ყველაზე ძლიერი და სასარგებლო ბრძანებები.
Yeah. >> შეგიძლიათ ბეჭდვა სტრიქონი?
შეგიძლიათ ბეჭდვა სტრიქონი? აბსოლუტურად.
იგი არ უნდა იყოს მხოლოდ რიცხვებით.
თუ ცვლადი s არის სიმებიანი მხოლოდ ჩაწერეთ ბეჭდვითი s.
იგი გაჩვენებთ რა რომ string ცვლადის.
[Inaudible-სტუდენტი]
ეს მოგცემთ მისამართს და სიმებიანი თავად.
იგი გაჩვენებთ ორივე.
და ერთი რამ ბოლო, მხოლოდ იმიტომ, რომ ეს არის კარგი იცოდეს ძალიან.
Backtrace და ჩარჩო, ნება მომეცით ჩაყვინთვის შევიდა ამ ერთი ბოლო დროს,
იმავე ზუსტი პროგრამა GDB.
ნება მომეცით წავიდეთ წინ და აწარმოებს ტექსტური ინტერფეისი ვერსია,
შესვენება ძირითადი.
ნება მომეცით წავიდეთ წინ და აწარმოებს ერთხელ. აქ ვარ.
ახლა ნება მომეცით წასვლა შემდეგი, შემდეგი, შემდეგი, შემდეგი, მომდევნო, ნაბიჯი, შეიყვანოთ.
>> და ახლა ვარაუდობენ, მე ახლა swap განზრახ, მაგრამ მე როგორც "Damn, რა იყო ღირებულების x?"
მე ვერ გავაკეთებ x უქმნით.
მე ვერ გავაკეთო Y რადგან ისინი არ ფარგლებს.
ისინი არ კონტექსტში, მაგრამ პრობლემა არ არის.
შემიძლია აკრიფოთ backtrace.
რომელიც აჩვენებს ჩემთან ყველა ფუნქცია, რაც არ დასაჯეს მდე ამ მომენტში.
გაითვალისწინეთ, რომ ერთი წლის ბოლოში, მთავარ, ხაზები up ძირითადი
მყოფი ბოლოში ჩვენი სურათს აქ.
ის ფაქტი, რომ swap მაღლა დგას ეს ხაზები ერთად swap მყოფი ზემოთ ის მეხსიერების აქ,
და თუ მინდა დავუბრუნდეთ მთავარ დროებით შემიძლია ვთქვა "ფარგლებში."
რა ნომერი? მთავარი არის ჩარჩო # 1.
მე ვაპირებ წავიდეთ წინ და ვთქვათ "ჩარჩოში 1."
>> ახლა დავბრუნდი მთავარ და შემიძლია ბეჭდვა x, და შემიძლია ბეჭდვა Y,
მაგრამ მე ვერ ბეჭდვა ან ბ.
მაგრამ მე შემიძლია, თუ ვიტყვი, "Okay, დაველოდოთ წუთში. სად იყო swap?"
ნება მომეცით წავიდეთ წინ და ვთქვათ "ჩარჩო 0."
ახლა დავბრუნდი, სადაც მე მინდა იყოს, და როგორც განზე,
არსებობს სხვა ბრძანებები ძალიან, მოსწონს თუ თქვენ ნამდვილად მისაღებად შეწუხებული აკრეფით შემდეგი, შემდეგი, შემდეგი, მომდევნო,
შეგიძლიათ ზოგადად ამბობენ რამ, როგორიცაა "შემდეგი 10," და რომ იქნება დაიხევს მეშვეობით მომდევნო 10 ხაზები.
თქვენ ასევე შეგიძლიათ წერენ "გააგრძელებს", როდესაც თქვენ ნამდვილად მისაღებად გადაღალა სტეპინგზე საშუალება.
გაგრძელება იქნება აწარმოებს თქვენი პროგრამის შეუწყვეტლად სანამ გაიტანა კიდევ ერთი breakpoint,
თუ მარყუჟი ან შეამცირონ ქვემოთ თქვენს პროგრამას.
>> ამ შემთხვევაში ჩვენ გააგრძელა ბოლომდე, და პროგრამის დასრულების ნორმალურად.
ეს არის ლამაზი გზა, inferior პროცესში.
უბრალოდ თქვენი პროგრამის დასრულების ნორმალურად.
უფრო, რომ ვიდეო და გამართვის სხდომები მოვა.
ეს იყო ბევრი.
ავიღოთ ჩვენი 5 წუთიანი შესვენება აქ, და ჩვენ დაბრუნების structs და ფაილები.
>> თუ თქვენ არ dived შევიდა ამ კვირის pset უკვე
თქვენ იცით, რომ ჩვენ გამოიყენონ განაწილების კოდი,
კოდის რომ ჩვენ უზრუნველყოფს თქვენ, როგორც ამოსავალი წერტილი, ახალი ტექნიკით.
კერძოდ, ჩვენ გააცნო ამ ახალი სიტყვით მოუწოდა struct, სტრუქტურული,
ასე, რომ ჩვენ შეგვიძლია შევქმნათ ადრინდელს ცვლადი ჯიშები.
ჩვენ ასევე გააცნო ცნება ფაილის I / O, ფაილის და ჩასათვლელი,
და ეს იმდენად, რომ ჩვენ შეგვიძლია გადარჩენა სახელმწიფო
თქვენი Scramble საბჭოს ფაილი დისკი
ისე, რომ სწავლების პრაქტიკის და მე მესმის
რა ხდება შიგნით თქვენი პროგრამის გარეშე ხელით ითამაშებს
ათობით games of Scramble.
ჩვენ შეგვიძლია ამის გაკეთება უფრო automatedly.
>> ეს იდეა struct წყვეტს საკმაოდ მყარი პრობლემა.
დავუშვათ, რომ ჩვენ გვინდა განვახორციელოთ ზოგიერთი პროგრამა
რომ როგორღაც ინახება ინფორმაციას სტუდენტები,
და სტუდენტები შესაძლოა, მაგალითად, პირადობის მოწმობა, სახელი
და სახლის ადგილი, როგორიცაა ჰარვარდი, ამიტომ ეს 3 ცალი ინფორმაცია
ჩვენ გვინდა შევინარჩუნოთ გარშემო, ნება მომეცით, წავიდეთ წინ და დავიწყოთ წერა პატარა პროგრამა აქ,
მოიცავს stdio.h.
ნება მომეცით გავაკეთოთ მოიცავს cs50.h.
და შემდეგ ჩემი მთავარი ფუნქცია.
მე არ შეწუხება ნებისმიერი ბრძანება ხაზი არგუმენტები,
და აქ მინდა სტუდენტი, ამიტომ მე ვაპირებ ვთქვა
სტუდენტმა სახელი, ამიტომ მე ვაპირებ ვთქვა "სიმებიანი სახელი."
მაშინ მე ვაპირებ ვთქვა სტუდენტი ასევე აქვს პირადობის მოწმობა, ისე int id,
და სტუდენტმა სახლში, ასე რომ მე ასევე აპირებს ამბობენ "სიმებიანი სახლი."
მაშინ მე შეუკვეთოთ ამ ცოტა მეტი cleanly მოსწონს ეს.
Okay, ახლა მაქვს 3 ცვლადები რომელთანაც წარმოადგინოს სტუდენტი, ისე "სტუდენტი."
>> და ახლა მინდა populate ამ ფასეულობების, ნება მომეცით, წავიდეთ წინ და ვთქვათ რაღაც
"Id = 123."
სახელი აპირებს მიიღოს დავით.
ვთქვათ სახლში აპირებს მიიღოს Mather,
და შემდეგ მე ვაპირებ რაღაც თვითნებურად მოსწონს printf ("% s,
რომლის ID არის% d, ცხოვრობს% s.
და ახლა, რას მინდა შეაერთედ აქ, ერთი შემდეგ სხვა?
სახელი, პირადობის მოწმობა, სახლში დაბრუნების 0.
Okay, თუ მე ბრალია სადღაც აქ
მე ვფიქრობ, ჩვენ გვაქვს საკმაოდ კარგი პროგრამა, რომელიც ინახავს ერთი სტუდენტი.
რა თქმა უნდა, ეს არ არის ყველა, რომ საინტერესო. რა მოხდება, თუ მინდა 2 სტუდენტი?
რომ არ დიდი გარიგება. შემიძლია მხარდასაჭერად 2 ადამიანი.
ნება მომეცით წავიდეთ წინ და ითვალისწინებდეს ამ და ქვევით აქ,
და შემიძლია ვთქვა, "id = 456" ვინმეს მოსწონს რობ რომელიც ცხოვრობს KIRKLAND.
>> Okay, დაველოდოთ, მაგრამ მე ვერ ვუწოდებ ამ იგივე,
და როგორც ჩანს მე ვაპირებ აქვს გადააკოპირეთ ეს,
ნება მომეცით ვთქვა, რომ ეს იქნება დავითის ცვლადები,
და ნება მომეცით კიდევ რამდენიმე ეგზემპლარი ამ ამისთვის რობ.
ჩვენ მოვუწოდებთ ამ Rob-ს მაგრამ ეს არ არის იმუშავებს არის
იმიტომ, რომ მე არ-დაველოდოთ, მოდით შეცვლის ჩემთვის ID1, name1 და house1.
რობ იქნება 2, 2.
მაქვს, რომ შეიცვალოს ეს აქ, აქ, აქ, აქ, აქ, აქ.
დაველოდოთ, რა Tommy? მოდით ეს კიდევ ერთხელ გავაკეთოთ.
ცხადია, თუ თქვენ ჯერ კიდევ ფიქრობს, რომ ეს არის კარგი გზა ამით, ეს არ,
ასე კოპირება / პასტა ცუდი.
მაგრამ ჩვენ მოგვარდება ამ ერთი კვირის წინ.
>> რა იყო ჩვენი გამოსავალი, როცა გვინდოდა რამდენიმე ფაქტი იგივე მონაცემები ტიპის?
[სტუდენტთა] მასივი.
Array, ნება მომეცით, ცდილობენ გაწმენდა ამ მდე.
ნება მომეცით გარკვეული ოთახი თვითონ ზედა, და ნება მომეცით ნაცვლად ამის გაკეთება აქ.
ჩვენ მოვუწოდებთ ამ ხალხს, და ნაცვლად მე ვაპირებ ვთქვა "int პირადობის,"
და მე ვაპირებ, რომ მხარი დაუჭირონ 3 ჩვენგანი ახლა.
მე ვაპირებ ვთქვა "სიმებიანი სახელები," და მე მხარს დავუჭერთ 3 ჩვენგანი,
და შემდეგ მე ვაპირებ ვთქვა "სიმებიანი სახლები," და მე ვაპირებ, რომ მხარი დაუჭირონ 3 ჩვენგანისთვის.
ახლა აქ ნაცვლად დავით მიღების საკუთარი ლოკალური ცვლადები
ჩვენ შეგვიძლია თავი დავაღწიოთ იმ.
რომ თავს კარგად გრძნობს, რომ ჩვენ ამ გაწმენდა up.
მე შემიძლია ვთქვა, მაშინ დავით იქნება [0] და names [0]
სახლები [0].
და შემდეგ Rob შეგვიძლია ანალოგიურად გადარჩენა ამ.
მოდით დააყენა ამ ქვევით აქ, ამიტომ იგი აპირებს თვითნებურად იყოს პირადობის მოწმობა [1].
ის იქნება სახელები [1],
და მერე ბოლოს, სახლები [1].
>> ჯერ კიდევ ცოტა რუტინული, და ახლა მე უნდა გაერკვნენ ამ გარეთ,
ასე ვთქვათ "names [0], id [0], სახლები [0],
და მოდით pluralize ამ.
პირადობის, პირადობის, პირადობის მოწმობები.
და ისევ, მე ამის გაკეთება, ამიტომ ისევ, მე უკვე resorting კოპირება / პასტა ერთხელ,
ასე შანსი არსებობს სხვა გამოსავალი აქ.
შემიძლია ალბათ გაწმენდა ამ up შემდგომი ერთად მარყუჟი ან რამე მაგდაგვარს,
ასე მოკლედ, ეს პატარა უკეთესი, მაგრამ მაინც იგრძნობა
მე resorting კოპირება / პასტა, მაგრამ ეს, მე აცხადებენ,
არ არის ფუნდამენტურად უფლება გადაწყვეტა, რადგან
რა, თუ ოდესმე ჩვენ გადაწყვიტოს იცით, რა?
ჩვენ ნამდვილად უნდა შენახვის ელფოსტა დავით და რობ
და ყველას ამ პროგრამაში.
ჩვენ ასევე უნდა შესანახად ტელეფონის ნომრები.
ჩვენ ასევე უნდა შესანახად საგანგებო საკონტაქტო ნომრები.
ჩვენ გვყავს ყველა ამ ცალი მონაცემები, რომ ჩვენ გვინდა შეინახოს,
ასე როგორ დადიხართ შესახებ აკეთებს, რომ?
>> თქვენ გამოაცხადოს მეორე მასივი ზედა, და მერე ხელით დაამატოთ
ელექტრონულ მისამართზე [0], ელექტრონული ფოსტის მისამართი [1]
დავით და რობ და სხვ.
მაგრამ ნამდვილად მხოლოდ ვარაუდი უდევს ამ დიზაინის
რომ მე გამოყენებით პატივი სისტემის ვიცით, რომ
[I] თითოეულ რამდენიმე კოლექტორები
უბრალოდ ასე ხდება მიმართოს იგივე პირი,
ასე [0] წელს პირადობის მოწმობები არის ნომერი 123,
და მე ვაპირებ ვივარაუდოთ, რომ names [0]
არის იგივე პირის სახელი და სახლები [0]
არის იგივე პირი სახლში და ა.შ. ყველა სხვადასხვა მასივები, რომ შევქმნა.
მაგრამ რომ არ არსებობს ფუნდამენტური კავშირი
მათ შორის 3 ცალი ინფორმაციით, პირადობის მოწმობა, სახელის და სახლი,
მიუხედავად იმისა, რომ პირი ვცდილობთ მოდელის ამ პროგრამაში არ არის მასივები.
მასივები მხოლოდ ამ პროგრამული გზას აკეთებენ.
რაც ჩვენ ნამდვილად გსურთ მოდელის ჩვენი პროგრამა არის პირი
მოსწონს დავით, პირი მოსწონს რობ შიგნით, რომლის
ან encapsulating არის სახელი და ID და სახლი.
>> შეგვიძლია რაღაცნაირად გამოხატონ ამ იდეას encapsulation
რომლითაც ადამიანს აქვს პირადობის მოწმობა, სახელის და სახლი
და არ მიმართავს მართლაც ამ hack რომლითაც ჩვენ უბრალოდ
ენდობა, რომ bracket რაღაც
ეხება იგივე ადამიანის პირის თითოეულ ამ განსხვავებული კოლექტორები?
ჩვენ შეგვიძლია რეალურად ამის გაკეთება.
ნება მომეცით წასვლა ზემოთ მთავარ ახლა, და ნება მომეცით შექმნას საკუთარი მონაცემები ტიპის
ამისთვის ნამდვილად პირველად.
ჩვენ გამოიყენება ამ ტექნიკის წელს Scramble,
მაგრამ აქ მე ვაპირებ წავიდეთ წინ და შექმნას მონაცემთა ტიპის,
და იცით, რა, მე ვაპირებ მოვუწოდო მას სტუდენტი ან პირი,
და მე ვაპირებ გამოვიყენო typedef ამისთვის განსაზღვროს ტიპის.
მე ვაპირებ ვთქვა, რომ ეს არის სტრუქტურა,
და მაშინ ეს სტრუქტურა იქნება ტიპის სტუდენტი, ჩვენ ვთქვათ,
მიუხედავად იმისა, რომ ეს პატარა დათარიღებული არის ჩემთვის.
ჩვენ ვთქვათ "int id."
ჩვენ ვიტყვით, "სიმებიანი სახელი."
მაშინ ჩვენ ვიტყვით, "სიმებიანი სახლი"
ახლა ბოლოსთვის ამ რამდენიმე ხაზი კოდი
მე ახლახან ისწავლება clang, რომ არსებობს
მონაცემები ტიპის გარდა ints, გარდა სიმები, გარდა ორადგილიანი, გარდა მოძრავი.
>> როგორც ამ მომენტში დროში ხაზი 11, იქ არის ახალი ტიპის მონაცემის მოუწოდა სტუდენტებს,
და ახლა შემიძლია განვაცხადო სტუდენტი ცვლადი სადმე მინდა,
ნება მომეცით, გადახვევა ქვემოთ აქ ხალხს.
ახლა შემიძლია დავაღწიოთ ამ და შემიძლია დაბრუნდეს ქვემოთ დავით აქ,
და დავით შემიძლია რეალურად აცხადებენ, რომ დავით,
ჩვენ შეგვიძლია სიტყვასიტყვით ასახელებს ცვლადი შემდეგ თავს,
იქნება ტიპის სტუდენტი.
ეს შეიძლება ცოტა უცნაური, მაგრამ ეს არ არის ყველა, რომ სხვადასხვა
საწყისი გამოცხადების რაღაც როგორც int ან string ან float.
უბრალოდ ასე ხდება ე.წ. სტუდენტი ახლა,
და თუ მინდა დააყენა რაღაც შიგნით ამ სტრუქტურის
მე ახლა უნდა გამოვიყენოთ ახალი ნაჭერი სინტაქსი, მაგრამ ეს საკმაოდ მარტივია,
david.id = 123, david.name = "დავითი" დედაქალაქში D,
და david.house = "Mather,"
და ახლა შემიძლია დავაღწიოთ ამ პერსონალის აქ.
Notice ჩვენ ახლა დიზაინი ჩვენი პროგრამა მართლაც ბევრად უკეთესი გზა
in, რომ ახლა ჩვენი პროგრამა ასახავს რეალურ სამყაროში.
>> არსებობს რეალურ სამყაროში ცნება პირი ან სტუდენტი.
აქ არის C ვერსია პირის ან უფრო კონკრეტულად სტუდენტი.
შიგნით რომ პირი არის ამ შესაბამის მახასიათებლებს,
ID, სახელი და სახლი, ასე რობ არსებითად ხდება იგივე ქვემოთ აქ,
ასე სტუდენტი ძარცვა, და ახლა rob.id = 456,
rob.name = "რობ".
ის ფაქტი, რომ ცვლადი ეწოდება რობ არის ერთგვარი უაზრო.
ჩვენ შეგვეძლო უწოდა x ან y ან z.
ჩვენ მხოლოდ დასახელებული ეს რობ იყოს semantically თანმიმდევრული,
მაგრამ ნამდვილად სახელია შიგნით ამ სფეროში თავად,
ახლა მე ამ.
ეს ძალიან არ იგრძნონ საუკეთესო დიზაინის, რომ მე მძიმე კოდირებული დავით.
მე მძიმე კოდირებული რობ.
და კიდევ მაქვს მიმართავს ზოგიერთი და ჩასვით ყოველ ჯერზე მინდა ახალი ცვლადები.
უფრო მეტიც, მე უნდა სავარაუდოდ მისცეს თითოეულ ამ ცვლადის სახელი,
მიუხედავად იმისა, რომ მე გაცილებით მეტად აღწერს ამ ცვლადების
მეტი generically როგორც სტუდენტებს.
>> ახლა ჩვენ შეგვიძლია შერწყმა იდეების რომ არ მუშაობს კარგად ჩვენთვის
და ნაცვლად ამბობენ, "თქვენ იცით, რა, მომეცი ცვლადში სტუდენტები,
და მოდით არ ეს იყოს ზომა 3, "ამიტომაც შემიძლია დახვეწა ამ შემდგომი,
დავაღწიოთ ხელით განაცხადა დავით,
და შემიძლია ვთქვა, ნაცვლად რაღაც სტუდენტებს [0] აქ.
მე შემიძლია ვთქვა, მაშინ სტუდენტები [0] აქ,
სტუდენტებს [0] აქ, და ა.შ., და შემიძლია წასვლა გარშემო
და გაწმენდა რომ up for რობ.
მე შეიძლება წავიდეს შესახებ არის იქნებ დასძინა loop
და გამოყენებით GetString და GetInt რეალურად მიიღოთ ამ ფასეულობათა მომხმარებლის.
შემეძლო წასვლა დაახლოებით დასძინა მუდმივი რადგან ეს ზოგადად ცუდი პრაქტიკა
მძიმე კოდი ზოგიერთი თვითნებური ხმების მოსწონს 3 უფლება აქ
და მაშინ უბრალოდ გვახსოვდეს, რომ თქვენ უნდა დააყენოს არა უმეტეს 3 სტუდენტი იყო.
ეს, ალბათ, უმჯობესია გამოვიყენოთ # განსაზღვრავს ზედა ჩემი ფაილი
და ფაქტორი, რომ, ასე ნამდვილად, მინდა წავიდეთ წინ და განზოგადება ამ.
>> ნება მომეცით გახსენით მაგალითად რომ შორის დღევანდელი
მაგალითები წინასწარ, structs1.
ეს არის უფრო სრულყოფილი პროგრამა, რომელიც იყენებს # განსაზღვროს აქ
და ამბობს, ჩვენ ვაპირებთ აქვს 3 სტუდენტი იყოს.
აქ მე გამოცხადების კლასის ღირებულების სტუდენტები,
ასე საკლასო სტუდენტთა და ახლა მე გამოყენებით loop
უბრალოდ, რათა კოდი უფრო ელეგანტური, populate კლასის
ერთად მომხმარებლის input, ასე iterate საწყისი i = 0 on მდე სტუდენტი, რომელიც 3.
და მერე შეეკითხება მომხმარებელს ამ ვერსია
რა სტუდენტის პირადობის მოწმობა, და მივიღო იგი GetInt.
რა არის სტუდენტის სახელი და შემდეგ მივიღებ იგი GetString.
რა არის სტუდენტის სახლში? მივიღებ იგი GetString.
და მერე ბოლოში აქ უბრალოდ შეცვლა გადაწყვიტა
როგორ მე დაბეჭდვის ამ გარეთ და რეალურად გამოიყენოს მარყუჟის,
და ვინ ვარ მე დაბეჭდვის?
თანახმად კომენტარი მე დაბეჭდვის არავის Mather,
და ეს ასე რობ და ტომი და სხვ-რეალურად Tommy წელს Mather.
ტომი და დავით იქნება დაბეჭდილი ამ შემთხვევაში, მაგრამ რამდენად არის ეს სამუშაო?
ჩვენ არ გვინახავს ამ ფუნქციის ადრე, მაგრამ მიიღოს ამოიცნობთ, თუ რა ეს იმას.
ადარებს სტრიქონები.
>> ეს პატარა არასამთავრობო აშკარა როგორ ადარებს სიმები რადგან თურმე
თუ ის დააბრუნებს 0, რაც იმას ნიშნავს სტრიქონები ტოლია.
თუ ის დააბრუნებს -1 ეს ნიშნავს, რომ ერთი მოდის ალფავიტის ადრე სხვა,
და თუ ის დააბრუნებს +1 ეს იმას ნიშნავს სხვა სიტყვა მოდის ალფავიტის
ადრე სხვა, და თქვენ შეგიძლიათ გამოიყურებოდეს ონლაინ ან მამაკაცის გვერდზე
რომ ნახოთ ზუსტად რომელიც გზა, რომელიც, მაგრამ ეს ყველაფერი არის ჩანაფიქრია ის ამბობდა
თუ [i]. სახლი უდრის "Mather"
მაშინ წავიდეთ წინ და ამობეჭდოთ ასე და ასე არის Mather.
მაგრამ აქ რაღაც ჩვენ არ მინახავს ადრე, და ჩვენ დავბრუნდებით ამ.
მე არ გავიხსენოთ ოდესმე მქონე ამის გაკეთება ნებისმიერ ჩემი პროგრამები.
უფასო აშკარად გულისხმობდა მეხსიერება, გამონთავისუფლების მეხსიერება,
მაგრამ რა მეხსიერების ვარ აშკარად ათავისუფლებს ამ loop ბოლოში ეს პროგრამა?
როგორც ჩანს მე ათავისუფლებს პირის სახელი
და პირის სახლში, მაგრამ რატომ არის, რომ?
>> თურმე ყველა ამ კვირის რომ თქვენ უკვე გამოყენებით GetString
ჩვენ სახის იქნა შემოღების bug შევიდა ყველა ერთი თქვენი პროგრამები.
GetString მიერ დიზაინი გამოყოფს მეხსიერება ასე რომ შეგიძლიათ დაბრუნდნენ თქვენ ტექსტი,
მოსწონს დავით, ან რობ, და თქვენ შეგიძლიათ მაშინ ნუ რაც გაგიხარდებათ
რომ სიმებიანი თქვენს პროგრამაში, რადგან ჩვენ დაცულია მეხსიერების თქვენთვის.
პრობლემა ის არის, მთელი ამ ხნის ყოველ ჯერზე რეკავთ GetString
ჩვენ, ავტორებს GetString, უკვე სვამს ოპერაციული სისტემა
უნდა მოგვცეს ცოტა RAM ამ სიმებიანი.
მოგვცეს ცოტა RAM ამ შემდეგი სიმებიანი.
გვაწვდიან მეტი RAM ამ შემდეგი სიმებიანი.
რა, პროგრამისტი, არასდროს აკეთებს
გვაძლევს, რომ მეხსიერების უკან,
ისე ამ რამდენიმე კვირის ყველა პროგრამების თქვენ წერილობითი
არ ჰქონდა რასაც მეხსიერების ნახტომი, რომლის დროსაც ისინი გამოყენებით
უფრო და უფრო მეტი მეხსიერების ყოველ ჯერზე რეკავთ GetString, და ეს ჯარიმა.
ჩვენ შეგნებულად გააკეთოს, რომ პირველი კვირის განმავლობაში, რადგან ეს არ არის, რომ საინტერესო
ჰქონდეს ფიქრი სადაც სიმებიანი მოდის.
ყველა გსურთ არის სიტყვის Rob უკან დაბრუნდნენ, როდესაც მომხმარებლის ტიპის ის სისტემაში
>> მაგრამ წინსვლის ჩვენ ახლა უნდა დავიწყოთ სულ უფრო დახვეწილი შესახებ.
ნებისმიერ დროს ჩვენ გამოყოს მეხსიერება ჩვენ უკეთესი საბოლოოდ გადასცემს მას უკან.
წინააღმდეგ შემთხვევაში რეალურ ცხოვრებაში თქვენს Mac ან PC თქვენ ალბათ ზოგჯერ გამოცდილი
სიმპტომები სადაც თქვენი კომპიუტერი grinding შეჩერდა საბოლოოდ
ან სულელური დაწნული Beach ball მხოლოდ საოკუპაციო კომპიუტერის
მთელი ყურადღება და ვერ გავაკეთებ რამ.
რომ აიხსნება ნებისმიერი რაოდენობის შეცდომები, მაგრამ იმ შესაძლო შეცდომები
მათ რამ მოუწოდა მეხსიერების გაჟონვის რომლის ვინც წერს, რომ ნაჭერი პროგრამული უზრუნველყოფა
თქვენ იყენებთ არ ახსოვს თავისუფალი მეხსიერება
რომ მას სთხოვა მოქმედი სისტემა,
არ იყენებს GetString, რადგან ისინი CS50 რამ, მაგრამ მისი გამოყენება ანალოგიური ფუნქციების
რომ ვთხოვო ოპერაციული სისტემის მეხსიერების.
თუ თქვენ ან ისინი Screw მდე და არასოდეს რეალურად დაბრუნებას, რომ მეხსიერების
სიმპტომია, რომ შეიძლება იყოს ის, რომ პროგრამა slows და slows და ანელებს
თუ არ გახსოვთ, რომ მოვუწოდო უფასო.
>> ჩვენ დავბრუნდებით და როდის, რატომ, რომ დარეკოთ თავისუფალი,
მაგრამ მოდით წავიდეთ წინ მხოლოდ კარგი ღონისძიება და ცდილობენ გაშვებული ამ კონკრეტულ პროგრამას.
ეს ეწოდა structs1, შეიყვანოთ.
ნება მომეცით წავიდეთ წინ და აწარმოებს structs1, 123, დავით Mather,
456, რობ KIRKLAND, 789,
Tommy Mather, და ჩვენ ვხედავთ დავითის წელს Mather, Tommy წელს Mather.
ეს არის მხოლოდ პატარა საღი აზრის გამშვები რომ პროგრამა მუშაობს.
ახლა, სამწუხაროდ, ამ პროგრამის პატარა იმედგაცრუებაა, რომ
მე ყველა, რომ მუშაობა, მე აკრეფილი 9 სხვადასხვა სტრინგი, დააჭირეთ,
მითხრეს რომელიც Mather, მაგრამ აშკარად ვიცოდი, ვინ იყო Mather უკვე იმიტომ, რომ მე აკრეფილი იგი.
კარგი იქნება, მინიმუმ, თუ ამ პროგრამის უფრო ბაზაში
და ეს ფაქტიურად ახსოვს რა აკრეფილი
ასე რომ მე აღარასოდეს უნდა შეყვანის ამ სტუდენტი ჩანაწერი.
შეიძლება უფრო მოსწონს registrarial სისტემა.
>> ჩვენ შეგვიძლია ამის გაკეთება გამოყენებისას ტექნიკა ცნობილია როგორც ფაილის I / O, ფაილის და ჩასათვლელი,
ძალიან generic გზას ვამბობ, ნებისმიერ დროს გსურთ წაიკითხა ფაილების ან ფაილების ჩაწერა
ამისათვის გარკვეული კომპლექტი ფუნქციები.
ნება მომეცით წავიდეთ წინ და გახსნა ამ მაგალითში structs2.c,
რომელიც თითქმის იდენტურია, მაგრამ ვნახოთ, თუ რას აკეთებს ახლა.
ზედა ფაილის ვაცხადებ კლასი სტუდენტებს.
მე მაშინ populate კლასის მომხმარებლის input,
ამიტომ იმ ხაზები კოდი ზუსტად ისევე, როგორც ადრე.
მაშინ თუ გადახვევა ქვემოთ აქ ბეჭდვა ყველას, ვინც არის Mather თვითნებურად მინდა ადრე,
მაგრამ ეს არის საინტერესო ახალი ფუნქცია.
ეს ხაზი კოდი არის ახალი, და მათ გააცნოს რამე,
ფაილი, ყველა caps, და მას * აქ ასევე.
ნება მომეცით გადავიდეს ამ მეზობელი, * აქ ასევე.
>> ეს ფუნქცია ჩვენ არ მინახავს ადრე, fopen,
მაგრამ ეს ნიშნავს, ფაილის ღია, მოდით skim მეშვეობით ამ,
და ეს არის რაღაც ჩვენ დაბრუნდება მომავალში psets,
მაგრამ ეს ხაზი აქ არსებითად ხსნის ფაილი სახელად მონაცემთა ბაზა,
და ეს სპეციალურად ხსნის მას ისე, რომ მას შეუძლია გააკეთოს ის, რაც მას?
[Inaudible-სტუდენტი]
მარჯვენა, ისე "W" მხოლოდ იმას ნიშნავს, რომ ის ეუბნება ოპერაციული სისტემა
ამ ფაილის გახსნის ისე, რომ მე შეგიძლიათ დაწეროთ იგი.
მე არ მინდა, რომ მისი წაკითხვა. მე არ მინდა, უბრალოდ შეხედეთ მას.
მინდა შეცვლის და დაამატოთ პერსონალი პოტენციურად კი
და ფაილის აპირებს ეწოდოს მონაცემთა ბაზაში.
ეს შეიძლება ეწოდოს არაფერი.
ეს შეიძლება იყოს database.txt. ეს შეიძლება იყოს. დეციბელი.
ეს შეიძლება იყოს: სიტყვა მოსწონს foo, მაგრამ თვითნებურად აირჩია ასახელებს ფაილი მონაცემთა ბაზაში.
ეს არის პატარა საღი აზრის გამშვები რომ ჩვენ დაბრუნებას დიდი დეტალურად დროთა განმავლობაში,
თუ FP, ამისთვის ფაილის მაჩვენებელი, არ თანაბარი NULL, რაც იმას ნიშნავს ყველა კარგად არის.
>> დიდხანს ამბავი მოკლედ, ფუნქციები, როგორიცაა fopen ზოგჯერ ვერ.
იქნებ ფაილი არ არსებობს. იქნებ თქვენ გარეთ დისკი სივრცეში.
იქნებ არ გაქვთ, რომ საქაღალდეში,
ასე რომ, თუ fopen ბრუნდება null რაღაც ცუდი მოხდა.
პირიქით, თუ fopen არ დააბრუნებს null ყველა კარგად
და მე შემიძლია წერა ამ ფაილზე.
აქ ახალი შეასრულა.
ეს არის განკუთვნილი loop რომ iterating აღემატება თითოეული ჩემი სტუდენტები,
და ეს გამოიყურება ასე მსგავსია იმისა, რაც ჩვენ გავაკეთეთ ადრე,
მაგრამ ამ ფუნქციის დეიდაშვილი printf მოუწოდა fprintf ფაილების printf,
და შენიშნავს, რომ ის განსხვავებულია მხოლოდ 2 გზა.
ერთი, ეს იწყება F ნაცვლად P,
მაგრამ მაშინ მისი პირველი არგუმენტი აშკარად რა?
[სტუდენტთა] ფაილი. >> ეს ფაილი.
ეს რამ მოუწოდა FP, რომელიც ჩვენ საბოლოოდ აჯავრებენ გარდა რა ფაილის კურსორი არის,
მაგრამ ახლა FP უბრალოდ წარმოადგენს ფაილი, რომელიც მე არ გახსნა,
ასე fprintf აქ ამბობს ბეჭდვა ამ მომხმარებლის პირადობის ფაილი, არ ეკრანზე.
ამობეჭდვა მომხმარებლის სახელზე ფაილი, არ ეკრანზე,
სახლი ფაილი, არ ეკრანზე, ხოლო შემდეგ ქვემოთ აქ, ცხადია,
დახურვა ფაილი, ხოლო შემდეგ ქვემოთ აქ თავისუფალი მეხსიერება.
>> მხოლოდ განსხვავება ამ 2 ვერსია და ვერსია 1
არის დანერგვა fopen და ამ ფაილის *
და ეს ცნება fprintf, მოდით ვნახოთ, რა საბოლოო ჯამში.
ნება მომეცით წასვლას ჩემი ტერმინალის ფანჯარაში.
ნება მომეცით აწარმოებს structs2, შეიყვანოთ.
როგორც ჩანს, ყველა კარგად არის. მოდით გამეორება structs2.
123, დავით Mather, 456, რობ KIRKLAND,
789, ტომი Mather, შეიყვანოთ.
როგორც ჩანს, იგი მოიქცა იგივე, მაგრამ თუ ახლა ls
შეამჩნია რა ფაილი არის აქ შორის ჩემი კოდი, მონაცემთა ბაზა,
მოდით გავხსნათ, რომ gedit მონაცემთა ბაზის და შევხედოთ, რომ.
ეს არ არის ყველაზე სექსუალური ფაილის ფორმატებში.
ეს მართლაც ერთი ნაჭერი მონაცემები ხაზი თითო ხაზზე თითო ხაზზე,
მაგრამ იმ თქვენ, რომლებიც იყენებენ Excel ან CSV ფაილი მძიმით გამოყოფილი მნიშვნელობები,
მე ნამდვილად არ გამოიყენება fprintf, რომ ამის სანაცვლოდ ალბათ რაღაც მსგავსი
ასე რომ მე ვერ რეალურად შექმნა ეკვივალენტს Excel ფაილი
მიერ ჰყოფს რამ ერთად მძიმეები, არა მხოლოდ ახალი ხაზები.
>> ამ შემთხვევაში მე რომ ნაცვლად გამოიყენება მძიმეები ნაცვლად ახალი ხაზები
მე ვერ სიტყვასიტყვით გახსნა ამ მონაცემთა ბაზაში ფაილის Excel თუ ნაცვლად გახადა ასე გამოიყურება.
მოკლედ, ახლა რომ ჩვენ გვაქვს ძალა ვწერ ფაილები
ჩვენ შეგვიძლია ახლა დავიწყოთ არსებული მონაცემები, შენახვა ირგვლივ on დისკი
ასე, რომ ჩვენ შეგვიძლია შევინარჩუნოთ ინფორმაციის ირგვლივ ისევ და ისევ.
გაითვალისწინეთ რამდენიმე სხვა რამ, რაც ახლა უფრო მეტი ნაცნობი.
ზედა ამ C ფაილის გვაქვს typedef
რადგან გვინდოდა შექმნათ მონაცემთა ტიპის, რომელიც წარმოადგენს ერთი სიტყვით,
ამიტომ ამ ტიპის ეწოდება სიტყვა, და შიგნით ამ სტრუქტურის
ეს პატარა fancier არის.
რატომ არის სიტყვა შედგება სავარაუდოდ მასივი?
რა არის სიტყვა უბრალოდ ინტუიციურად?
>> ეს მასივი სიმბოლო.
ეს თანმიმდევრობა გმირები თავში დაბრუნება უკან.
ასო ყველა caps ხდება იყოს ჩვენ თვითნებურად ამბობენ მაქსიმალური სიგრძე
ნებისმიერი სიტყვა ლექსიკონი, რომ ჩვენ იყენებს Scramble.
რატომაა აქვს +1?
Null ხასიათი.
შეგახსენებთ, როდესაც ჩვენ გავაკეთეთ Bananagrams მაგალითად გვჭირდებოდა მასივები
დასასრულს სიტყვა რათა ტრეკზე
სადაც სიტყვა ფაქტობრივად დასრულდა, და როგორც პრობლემა კომპლექტი სპეციფიკაცია ამბობს
აქ ჩვენ ასოცირების ერთად მოცემული სიტყვა ლოგიკური ღირებულება,
დროშა, ასე ვთქვათ, ნამდვილი ან ყალბი.
არ თქვენ ი ამ სიტყვის უკვე, რადგან ვაცნობიერებთ
ჩვენ ნამდვილად გვჭირდება გზა დამახსოვრების არა მარტო რა სიტყვა არის Scramble
მაგრამ თუ არა თქვენ, ადამიანური, იპოვეს ეს
ასე რომ თუ იპოვოს სიტყვა "" ვერ უნდა აკრიფოთ, მიუთითოთ,, შევა, შეიყვანეთ
და კიდევ 3 ქულა, 3 ქულა, 3 ქულა, 3 ქულა.
ჩვენ გვინდა, რომ შეძლებს შავი სია რომ სიტყვა მიიღწევა bool
ჭეშმარიტი თუ თქვენ უკვე ნაპოვნი, და ასე ამიტომ ჩვენ
encapsulated იგი ამ სტრუქტურაში.
>> ახლა ქვევით აქ Scramble არსებობს ამ სხვა struct მოუწოდა ლექსიკონი.
Absent აქ არის სიტყვა typedef რადგან ამ შემთხვევაში
ჩვენ საჭირო encapsulate იდეა ლექსიკონი,
და ლექსიკონი შეიცავს მთელი bunch of სიტყვა,
როგორც გულისხმობდა ამ მასივი, და რამდენი იმ სიტყვა არსებობს?
ისე, რასაც ამ ცვლადში ზომა ამბობს.
მაგრამ ჩვენ უბრალოდ უნდა ერთი ლექსიკონი.
ჩვენ არ გვჭირდება მონაცემები ტიპის მოუწოდა ლექსიკონი.
ჩვენ უბრალოდ უნდა ერთი მათგანი, გამოდის, დო
რომ თუ თქვენ არ ვამბობ typedef, უბრალოდ ამბობენ struct, მაშინ შიგნით Curly braces
თქვენ განათავსოთ თქვენი ცვლადები, მაშინ დააყენა სახელი.
ეს არის გამოცხადების ერთ ცვლადში ლექსიკონი
რომ ასე გამოიყურება.
პირიქით, ამ ხაზების ვქმნით reusable მონაცემები სტრუქტურა მოუწოდა სიტყვა
რომ თქვენ შეგიძლიათ შექმნათ სხვადასხვა ასლები, ისევე, როგორც ჩვენ შევქმენით
მრავალჯერადი ასლები სტუდენტები.
>> რას საბოლოოდ მოგვცემს გავაკეთოთ?
ნება მომეცით დაბრუნდეს შევიდა, ასე ვთქვათ, უფრო მარტივი მაგალითი მარტივი ჯერ,
და ნება მომეცით ქმნის, ვთქვათ, compare1.c.
პრობლემა აქ ხელთ არის რეალურად კანი უკან
ფენის სიმებიანი და დაიწყოს მოიხსნას ამ სასწავლო თვლები
რადგან აღმოჩნდება, რომ სიმებიანი მთელი ამ ხნის
არის როგორც დაგპირდით წელს კვირაში 1 ნამდვილად მხოლოდ მეტსახელად
სინონიმი საწყისი CS50 ბიბლიოთეკა რაღაც რომ გამოიყურება ცოტა მეტი cryptic,
char * და ჩვენ ვხედავთ ამ ვარსკვლავი წინაშე.
ჩვენ ვნახეთ ის კონტექსტში ფაილი.
>> მოდით ახლა, თუ რატომ ჩვენ იმალებოდა ამ დეტალურად ზოგიერთი ახლა.
აქ არის ფაილი სახელად compare1.c,
და ეს აშკარად სთხოვს მომხმარებლის 2 სიმები, და T,
და მაშინ იგი ცდილობს შეადაროს იმ სიმები თანასწორობის სტრიქონში 26,
და თუ ისინი თანაბარი იგი ამბობს: "თქვენ აკრეფილი იგივე"
და თუ ისინი არ თანაბარი იგი ამბობს: "თქვენ აკრეფილი სხვადასხვა რამ."
ნება მომეცით წავიდეთ წინ და აწარმოებს ამ პროგრამის.
ნება მომეცით წასვლას ჩემი წყაროს დირექტორია, მიიღოს compare1. იგი შედგენილია okay.
ნება მომეცით აწარმოებს compare1.
მე დიდი ზომით, შეიყვანოთ.
ამბობენ რაღაც. Hello.
მე ამბობენ რაიმეს. Hello.
მე ნამდვილად არ აკრიფოთ სხვადასხვა რამ.
>> ნება მომეცით ცდილობენ ამ ერთხელ. Bye Bye.
ნამდვილად არა სხვადასხვა, ისე რა ხდება აქ?
ისე, რა არის მართლაც მიმდინარეობს შედარებით შეესაბამება 26?
[Inaudible-სტუდენტი]
დიახ, ასე გამოდის, რომ ტექსტი, მონაცემები ტიპის, არის ერთგვარი თეთრი სიცრუეა.
სიმებიანი არის char *, მაგრამ რა არის char *?
Char *, როგორც ამბობენ, არის მაჩვენებელი,
და კურსორი არის ეფექტურად მისამართი,
თანხა საიდან მეხსიერებაში და თუ ემართება არ აკრეფილი სიტყვა მოსწონს Hello,
გავიხსენოთ წარსულის განხილვა სტრიქონები
ეს მოსწონს სიტყვა Hello.
გახსოვდეთ, რომ სიტყვა, როგორიცაა HELLO შეიძლება წარმოდგენილია
როგორც მასივი გმირები მოსწონს
შემდეგ კი სპეციალური ხასიათის დასასრულს მოუწოდა null ხასიათი,
როგორც \ აღნიშნავს.
რა არის რეალურად სიმებიანი?
გაითვალისწინეთ, რომ ეს არის მრავალჯერადი მოცულობით მეხსიერება,
და რეალურად, ბოლოს იგი მხოლოდ ცნობილია ერთხელ გადავხედავთ მთელ string
ეძებს სპეციალური null ხასიათი.
მაგრამ თუ ეს არის ბლოკი მეხსიერება ჩემი კომპიუტერის მეხსიერებაში,
მოდით თვითნებურად ამბობენ, რომ ეს კონტექსტი უბრალოდ მიიღო გაუმართლა,
და მას განთავსებულია თავიდანვე ჩემი კომპიუტერის RAM.
ეს არის byte 0, 1, 2, 3, 4, 5, 6 ...
>> როდესაც ვამბობ რაღაც GetString და გავაკეთე string s = GetString
რა ნამდვილად მიმდინარეობს დაბრუნდა?
ამ ბოლო რამდენიმე კვირის განმავლობაში, თუ რა ნამდვილად მიმდინარეობს ინახება s
არ არის ეს კონტექსტი თავისთავად, მაგრამ ამ შემთხვევაში რა ხდება ინახება არის
ნომერი 0, რადგან რა GetString რეალურად აკეთებს
არის ეს არ ფიზიკურად დაბრუნების სიმებიანი.
რომ არც კი ნამდვილად მიიღოს კონცეპტუალური გაგებით.
რა ეს იმას დაბრუნების არის ნომერი.
რომ ნომერი არის მისამართი HELLO მეხსიერებაში,
და სიმებიანი s მაშინ, თუ ჩვენ კანი უკან ამ ფენას, string ნამდვილად არ არსებობს.
ეს მხოლოდ გამარტივების წელს CS50 ბიბლიოთეკაში.
>> ეს ნამდვილად არის რაღაც მოუწოდა char *.
ჩარ აზრი რადგან რა სიტყვაა, ისევე როგორც პირველი?
ისე, ეს სერია სიმბოლო, სერია გმირები.
ჩარ * ნიშნავს მისამართი ხასიათი,
ასე რას ნიშნავს დაბრუნებას სიმებიანი?
ლამაზი, მარტივი გზა დაბრუნების სიმებიანი
არის ვიდრე ცდილობენ გაერკვნენ, თუ როგორ მე დაბრუნდება 5 ან 6 სხვადასხვა ბაიტი
დავუბრუნდები მისამართი რომელიც byte?
პირველი.
სხვა სიტყვებით, მინდა გადმოგცეთ მისამართი ხასიათი მეხსიერებაში.
რაც char * წარმოადგენს, მისამართი ერთი ხასიათი მეხსიერებაში.
ზარის რომ ცვლადი s.
მაღაზიის წინ, რომ კონკრეტული მისამართი, რომელსაც მე თვითნებურად განაცხადა არის 0,
უბრალოდ შენარჩუნება რამ მარტივი, მაგრამ სინამდვილეში ეს არის ზოგადად უფრო დიდი რაოდენობის.
>> დაელოდეთ წუთი.
თუ თქვენ მხოლოდ მაძლევს მისამართი პირველი ხასიათი, როგორ მე ვიცი, თუ რა მისამართი
მეორე გმირი, მესამე, მეოთხე და მეხუთე?
[Inaudible-სტუდენტი]
თქვენ მხოლოდ ვიცი, სად ბოლომდე სტრიქონს გზით ამ მოსახერხებელი შეასრულა,
ასე რომ, როდესაც თქვენ იყენებთ რაღაც printf, რა printf სიტყვასიტყვით იღებს როგორც მისი არგუმენტი,
გავიხსენოთ, რომ ჩვენ ვიყენებთ ამ% s placeholder, და მაშინ კორიდორი
ცვლადი რომ შენახვის სიმებიანი.
თქვენ მას ნამდვილად ავლით არის მისამართი პირველი ხასიათი რომ სიმებიანი.
Printf მაშინ იყენებს ამისთვის მარყუჟი ან ხოლო loop მიღების, რომ მისამართი,
მაგალითად, 0, ნება მომეცით, ეს ახლა,
printf ("% s \ n" s);
როდესაც მოვუწოდებ printf ("% s \ n" s); რა მე ნამდვილად უზრუნველყოფს printf ერთად
არის მისამართი პირველი პერსონაჟი s, რომელიც ამ თვითნებური საქმე H.
>> როგორ ამჯამად printf ვიცი რა ზუსტად არ არიან ეკრანზე?
პირი, რომელიც განხორციელდა printf განხორციელებული ხოლო მარყუჟი ან ამისთვის loop
რომელიც ამბობს, ამჯამად ეს პერსონაჟი გაუტოლდება სპეციალური null ხასიათი?
თუ არა, დაბეჭდეთ. როგორ ამ ერთი?
თუ არ დაბეჭდეთ, დაბეჭდეთ, დაბეჭდეთ, დაბეჭდეთ.
ოჰ, ეს არის სპეციალური. Stop ბეჭდვა და დაბრუნდეს მომხმარებლის.
და ეს სიტყვასიტყვით ყველა რომ ხდებოდა ქვეშ hood,
და ეს ბევრი დაიჯესტს პირველ დღეს კლასის,
მაგრამ ახლა ეს მართლაც შენობა მრავალბინიანი გაგება ყველაფერი
რომ უკვე მიმდინარეობს შიგნით ჩვენი კომპიუტერის მეხსიერებაში,
და საბოლოოდ ჩვენ აჯავრებენ ამ გარდა ერთად პატარა დახმარება
ერთი ჩვენი მეგობარი სტენფორდის.
>> პროფესორი ნიკ Parlante სტენფორდის გააკეთა ეს მშვენიერი ვიდეო თანმიმდევრობა
ყველა სახის სხვადასხვა ენებზე, რომ გააცნო
ამ პატარა Claymation ხასიათი Binky.
ხმა თქვენ შესახებ მოვისმინოთ რამდენიმე მეორე Sneak გადახედვისას
ის არის, რომ საქართველოში სტენფორდის პროფესორი, და თქვენ მისაღებად
მხოლოდ 5 ან 6 წამი ამ წუთას,
მაგრამ ეს შენიშვნა, რომელიც ჩვენ დავასკვნათ დღეს
და დაიწყება ოთხშაბათს.
მე გაძლევთ Pointer გართობა ერთად Binky, ესკიზი.
[♪ ♪ Music] [პროფესორი Parlante] Hey, Binky.
ვიღვიძებ. დროა მაჩვენებელი გართობა.
[Binky] რა არის რომ? ბუნებაში პოინტერები?
ოჰ, GOODY!
>> ჩვენ ვხედავთ თქვენ ოთხშაბათს.
[CS50.TV]