>> [მუსიკის დაკვრა]
DAVID Malan ყველა უფლება.
ეს არის CS50, და ეს არის ბოლომდე კვირაში 2.
მე ასე წუხს, მე არ შეიძლება იქ თქვენ ყველა დღეს,
მაგრამ თქვენ ძალიან კარგ ხელშია.
ნება მიბოძეთ წარმოგიდგინოთ CS50 საკუთარი Rob Bowden.
რობ Bowden: და რა თქმა უნდა, მაშინ ჩვენ მასხრად იმისა,
რომ მან გამოგვიგზავნა ვერტიკალური ვიდეო და აჩვენებს, ამ.
>> [ვიდეო აღწარმოების]
>> [მუსიკის დაკვრა]
>> [კვალდაკვალ]
>> -ეს ვიდეო არ უნდა ვეძებოთ ამ გზით.
ეს შეიძლება ხელი შეუშალა.
უთხარი არა ვერტიკალური videos.
>> -Vertical ვიდეო მოხდეს, როდესაც თქვენ გამართავს თქვენი კამერა არასწორი გზა.
შენი ვიდეო დასრულდება მდე ეძებს მოსწონს crap.
>> - [GRUNT]
>> -არის უფრო და უფრო მეტი ადამიანი ნარკომანი მიღების ვერტიკალური ვიდეო ყოველდღე.
ეს არ გაიბზარება ან არაფერი, მაგრამ მაინც ძალიან ცუდია.
არსებობს ორი სხვადასხვა სახის ადამიანები, რომლებიც დაზარალებულ ერთად VVS.
პირველი ჯგუფი ეპყრობა ვიდეო ისინი დახვრიტეს, როგორიცაა სურათები.
მათ არ ნიშნავს რაიმე ზიანი.
ისინი უბრალოდ არ ესმით, რომ ხოლო თქვენ შეიძლება იქცეს სურათი,
თქვენ ნამდვილად არ გახდეს ვიდეო.
>> [CRASH]
>> - [MONKEY ხმები]
>> -The სხვა ჯგუფის ადამიანი ვინც არ მისცეს [Bleep].
>> -Vertical ვიდეო სინდრომი სახიფათოა.
Motion სურათები აქვს ყოველთვის ჰორიზონტალური.
ტელევიზორები არის ჰორიზონტალური.
კომპიუტერის ეკრანები ჰორიზონტალური.
სახალხო თვალები ჰორიზონტალური.
ჩვენ არ აგებული უყუროთ ვერტიკალური videos.
>> მე მიყვარს ვერტიკალური videos.
>> -Nobody ზრუნავს თქვენზე.
>> იმ შემთხვევაში თუ ეს პრობლემა ის არ დადგენილიყო, თქვენც
დაიწყება გვიჩვენებს ოთხი ვიდეო ერთდროულად მხოლოდ გადარჩენა სიჩქარეს.
>> -Letterboxed ვერტიკალური ვიდეოები გვინდა იყოს ზომა საფოსტო მარკების.
>> და თუკი ეს იქნება ყველგან.
ფილმის ეკრანებზე აქვს ყოველთვის ჰორიზონტალური.
თუ ვერტიკალური ვიდეოები გახდეს მისაღები, კინოთეატრებში
უნდა იყოს მაღალი და გამხდარი.
>> თუკი ყველა კინოთეატრებში გვინდა უნდა მიიღოს დანგრევა და აღადგინეს.
და ახლა ისინი აღადგინეს, Mila Kunis იქნება ძველი და მახინჯი.
>> -Birds ავარიული შევიდა მათ და იღუპება.
>> -We'll ყველა მისაღებად ძლიერი კისრის ეძებს up.
>> თუკი არავინ იჯდეს წინა რიგის ოდესმე ისევ.
>> გიორგი Lucas ხელახლა გათავისუფლებას Star Wars ერთხელ საცურაო გამოცემა.
>> მე არასოდეს ნამდვილად შეუძლია გითხრათ, ამბავი, რომელიც მე მინდა გითხრათ.
ეს იყო დიდი შანსი ჩემთვის ექსპერიმენტი ახალი ტექნოლოგია.
>> -You're Jerk.
>> -Every დროს მობილური მოწყობილობა გამოიყენება ვიდეო ჩანაწერი, ცდუნება არის.
უბრალოდ ვთქვათ.
უთხარი არა ჯორჯ ლუკასი.
უთხარი არა ძველი Mila Kunis.
უთხარი არა ვერტიკალური videos.
>> ისე, თავად თუ ხედავთ ვინმე აკეთებს, ვთქვათ, "თქვენ არ დაარტყა, რომ უფლება რაღაც!"
>> [მუსიკის დაკვრა]
>> [END აღწარმოების]
>> [ტაში]
>> [აუდიო]
რობ Bowden: --simple ფორმა კრიპტოგრაფიის,
რომელიც ძირითადად დაშიფვრის და დეშიფრაციის საიდუმლო შეტყობინებები.
ასე რომ, აქ ჩვენ გვაქვს ძალიან მარტივი სათამაშო.
და იდეა არის გარე ბეჭედი ბრუნავს გარშემო შიდა ბეჭედი.
და თქვენ შეგიძლიათ ნახოთ, იქნებ თუ ზომით წელს, that-- ძნელია ვხედავ.
მაგრამ, როგორც, რაოდენობის 1-- ისე, რომ გადავიდა.
>> ნომერი 1 რუკები წერილი X, ნომერი 2 რუკების წერილი
J. წარმოუდგენლად რთული არ გამოტოვოთ წინ.
Letter 2 რუკები J. ხმების 3 რუკები დ ასე
ამ ბეჭედი შეგიძლიათ მისცეს ვინმე გაგზავნა 1, 2, 3.
რატომღაც თქვენ მინდა ვუთხრა მათ, XJD.
მაგრამ თქვენ შეგიძლიათ მივცეთ ზოგიერთი გაგზავნა ნომრები,
და რადგან მათ აქვთ ეს ბეჭედი, ისინი შეიძლება გაშიფვრა თუ რას ცდილობს ვთქვა.
>> ასე, რომ თქვენ შეიძლება არ ჩანს ეს კონკრეტული მაგალითი კრიპტოგრაფიის
ადრე თუ გარშემო საშობაო სეზონი თქვენ უყურებს საშობაო ამბავი.
თუ თქვენ არასოდეს მინახავს ეს ადრე, მაშინ მხოლოდ
ჩართოთ TBS სიტყვასიტყვით ნებისმიერ დროს შობის ღამეს,
იმიტომ, რომ ისინი მხოლოდ აჩვენებს მას თავში დაბრუნება თავში დაბრუნება უკან მთელი დღის განმავლობაში.
და შესაბამისი ვიდეო არის ამ.
[ვიდეო აღწარმოების]
-იქნება ეს ცნობილია ყველასთვის და განსხვავებული რომ რალფ პარკერი არის აქვე
დაინიშნა წევრი Little Orphan Annie საიდუმლო წრე
და მას უფლება აქვს ყველა პატივით და სარგებელი ხდება მასთან.
ხელმოწერილია პატარა ობოლი Annie.
კონტრასიგნაციას Pierre Andre მელნის!
პატივით და სარგებელს უკვე ასაკში ცხრა!
>> [ყვირილი რადიო]
-მოდი შესახებ.
მოდით კიდევ იგი.
მე არ გვჭირდება ყველა რომ ჯაზის შესახებ კონტრაბანდისტები და მეკობრეები.
-მოუსმინეთ ხვალ ღამე შემაჯამებელ სათავგადასავლო
შავი Pirate Ship.
ახლა, დროა Annie საიდუმლო გაგზავნა
თქვენთვის წევრები საიდუმლო წრე.
დამახსოვრება ბავშვები, მხოლოდ წევრების Annie საიდუმლო წრე
შეიძლება decode Annie საიდუმლო გაგზავნა.
გახსოვდეთ, Annie დამოკიდებულია თქვენ.
უცნობია თქვენი ქინძისთავები B2.
აქ არის გზავნილი.
12.
11.
2.
მე ვარ ჩემი პირველი საიდუმლო შეხვედრა.
>> -25.
14.
11.
18.
16.
>> -Oh, პიერ დიდი ხმა შეძლებენ.
მე ვერ გეტყვით, რომ ამაღამ გზავნილი იყო მართლაც მნიშვნელოვანია.
-3.
25.
სწორედ შეტყობინება Annie თავად.
გახსოვდეთ, არ ვუთხრა ვინმეს.
>> -Five წამში, მე მხოლოდ სახლში ოთახი, სადაც ბიჭი ცხრა
შეიძლება იჯდეს კონფიდენციალურობა და decode.
Aha!
B!
მივედი შემდეგ.
ე პირველი სიტყვა არის "იყოს."
S. ეს მოდიოდა ადვილი არის.
U. 25.
ეს არის ის, რ
-მოდი შესახებ, Ralphie!
მე gotta წავიდეთ!
-I'll უფლება ქვემოთ, Ma!
Gee პროგრამირებაში.
თ ო "რა თქმა უნდა", - რა თქმა უნდა, თუ რა?
რა იყო პატარა ობოლი Annie ცდილობს ამბობენ?
რა თქმა უნდა, თუ რა?
>> -Randy აქვს წავიდეთ!
გთხოვთ, გამოვა?
>> -ყველა უფლება, დედა!
მე ვიქნები უფლება out!
მე უახლოვდება არის.
დაძაბულობა იყო საშინელი.
რა იყო ეს?
ბედი პლანეტა შეიძლება სასწორზე დევს!
>> -Ralphie, რენდი ის მიიღო წავიდეთ!
>> -I'll უფლება, ამისთვის ღაღადებდეს ხმამაღლა!
თითქმის არ არსებობს!
ჩემი თითების გაფრინდა.
ჩემი გონება იყო ფოლადის ხაფანგში.
ყველა ფორე vibrated.
ეს იყო თითქმის ნათელია!
დიახ.
რა თქმა უნდა დალევა თქვენი Ovaltine.
Ovaltine?
Crummy კომერციული?
ძაღლიშვილია.
>> [END აღწარმოების]
>> რობ Bowden: ასე რომ, თუ როგორ Ovaltine ეხება კრიპტოგრაფიის.
ძირითადად CS50 მხოლოდ რეკლამირება Ovaltine, ასე რომ ჩვენ შეგვიძლია
იყოს crummy კომერციული Ovaltine.
ყველა უფლება.
ასე რომ, ახლა ფაქტობრივი კომპიუტერულ მეცნიერებაში.
დამახსოვრება ორშაბათს ჩვენ შეჩერდით diving სიღრმეში სიმები.
ასე რომ, ჩვენ საქმე სტრიქონი "Zamyla."
ჩვენ აღიარებდა ის ფაქტი, რომ ჩვენ შეიძლება მკურნალობა
"Zamyla" როგორც თანმიმდევრობა სიმბოლო.
და მახსოვს, რომ ჩვენ ვისწავლეთ კონსოლი ნოტაცია.
ასე რომ, თუ ეს იყო შენახული სიმებიანი "s", მაშინ
თუ ჩვენ ვთქვით, s bracket 0, რომ მიუთითოს წერილი კაპიტალის ზ
და თუ ჩვენ განაცხადა s bracket 1, რომელიც მიუთითებს იმაზე, პირველი ამას,
და ა.შ. მდე s bracket 5, რაც მიუთითებს იმაზე, რომ ბოლო ა.
>> ახლა გვახსოვდეს, რომ სიგრძით ეს კონტექსტი 6,
მაგრამ მაჩვენებლების შევიდა სიმებიანი 0 მეშვეობით 5, Z მეშვეობით, რომელიც გაგრძელდება.
ასე რომ, ეს ახლა ჯდება უფრო დიდი სურათი თქვენი კომპიუტერის მეხსიერებაში, თქვენი RAM.
ასე რომ სადღაც პროგრამა, რომელიც თქვენ გაშვებული თქვენს კომპიუტერში
უნდა გვახსოვდეს, Zamyla სადღაც მეხსიერებაში.
ასე რომ, შეიძლება მე მაქვს მოხალისე?
დიახ, გთხოვთ.
და რა არის თქვენი სახელი?
>> DEAN: დეკანი.
>> რობ Bowden: Dean?
კარგია თქვენთან შეხვედრა, დეკანი.
ასე რომ მოვა აქ და ჩვენ ვაპირებთ, რომ თქვენ მიაპყროს
ჩვენს ლამაზი nifty განლაგება მეხსიერება.
ახლა მე მიყვარს ფიქრი მეხსიერება როგორც ერთ-ერთი გრძელი ზოლები ბაიტი,
მაგრამ მხოლოდ ჩვენებისთვის ჩვენ გამოგიგზავნით უბრალოდ, მარცხნიდან მარჯვნივ, ზემოდან.
OK?
>> ამიტომ, მე ვაპირებ, რომ ნახოთ პროგრამაში Getstrings.c.
ასე რომ, ყველა ამ პროგრამის აკეთებს ითხოვს ოთხი სიმები
საწყისი მომხმარებელი GetString და შემდეგ ბეჭდვა
რასაც პირველი სიმებიანი შევიდა იყო.
ჩვენ იგნორირება ორი ოთხი.
OK.
ასე რომ, აქ, ახლა, როდესაც მე პირველი მოთხოვნა s1.
ასე რომ, თქვენ კომპიუტერი.
თქვენ ვახორციელებთ GetString.
ასე, რომ თქვენ მოითხოვოს სტრინგი მე, და იტყვით, დეკანი.
მიეცით string "დეკანი".
>> ასე რომ, სადღაც მეხსიერებაში თქვენ უნდა გვახსოვდეს, "დეკანი".
ასე წერენ ის მეხსიერება სადღაც.
სრულყოფილი.
OK.
ასე რომ, ახლა ჩვენ S2.
და s2 იქნება თხოვნით, GetString.
ამიტომ, მე ვაპირებ შესვლის სიმებიანი.
მე ვაპირებ შესვლას "Hannah".
ასე რომ შევა "Hannah" სადღაც მეხსიერებაში.
ჰო.
A-H.
>> OK, ასე რომ, ახლა s3.
და ეს იქნება კიდევ ერთი მოითხოვოს GetString.
ასე რომ, ახლა შევა "მარია".
ყველა უფლება.
და მერე იქ ერთი ბოლო თხოვნით GetString, s4.
ასე რომ, მე არ ვიცი.
როგორ შესახებ ჩვენ წავიდეთ ერთად antidisestablishmentarianism.
ასე რომ შევა, რომ მეხსიერებაში.
ჰო.
ასე რომ, მხოლოდ ამის "Rob".
>> OK.
ასე რომ, ახლა ახსნას რატომ არ თქვენ დატოვონ ეს ფართები?
რატომ გაქვთ ეს ცარიელი სივრცე აქ, აქ და აქ?
დიახ.
ასე რომ შეამჩნია, როდესაც მე წასვლა ბეჭდვა s1-- ასე რომ, თუ ჩვენ
ჰქონდა "Hannah" გაშვებული უფლება შემდეგ "დეკანი"
როგორ ვიცით, როდის სიმებიანი "დეკანი" დამთავრდა?
ასე რომ დაბეჭდვის სიმებიანი s1 შეიძლება ჰქონდეს მხოლოდ დაბეჭდილი "DeanHannahMariaRob"
იმ შემთხვევაში, თუ მას არ აქვს რაიმე ნახავ როდესაც "დეკანი" ფაქტიურად მთავრდება.
>> ყველა უფლება.
ასე რომ მეხსიერება გზას, ჩვენ რეალურად წარმოადგენს ამ ბოლოს სიმებიანი
არის წარმატებული ნულოვანი.
ასე რომ, ამ სივრცეში არის ზუსტად ის, რაც გვინდოდა.
ეს უნდა იყოს წარმატებული ნულოვანი.
ეს იქნება წარმატებული ნულოვანი, და ეს იქნება წარმატებული ნულოვანი.
და თქვენ შეგიძლიათ აქვს ზღაპრული პრიზი იმისთვის, რომ სრულყოფილი მოხალისე.
მიიღეთ სტრესი ბურთი!
>> OK.
ასე რომ, ეს ხასიათი წარმატებული ნულოვანი არის როგორ ჩვენ მიუთითოს ბოლოს სიმებიანი.
ეს როგორ, როდესაც ნებისმიერ პროგრამა სურს ბეჭდვა სიმებიანი,
ეს how-- მახსოვს გავიგეთ, გამოყენება strlen ფუნქცია გასულ კვირას?
სიმებიანი ხანგრძლივობა?
ეს როგორ სიმებიანი სიგრძე შეუძლია განსაზღვრავს, თუ როგორ ხანგრძლივი string არის.
უბრალოდ ინახავს iterating მეტი პერსონაჟი
სანამ ის პოულობს წარმატებული ნულოვანი ხასიათი.
ასე რომ, მთავარია, რომ გააცნობიეროს, შესახებ წარმატებული ნულოვანი ხასიათი
არის ის წარმოდგენილია ყველა zeros ბიტი.
ასე რომ ეს არის მკაფიო ნულოვანი ხასიათი.
ასე რომ, ნულოვანი ხასიათი, თუ გახსოვთ მაგალითად, რომ მან ბოლოს
ლექცია, სადაც გმირები რუკაზე რომელთა მიზანია, როგორც დედაქალაქში რუკები 65.
მხედრულ რუკები 97.
ამას ბ იქნება 98.
ასე რომ ნომერი 0 რუკები, რომელთა მიზანია: მე არ ვიცი, off ზევით ჩემი უფროსი.
44 და 45.
სადღაც, რომ რეგიონში.
>> ასე რომ, ხასიათი 0 ფაქტობრივი ნომერი.
მაგრამ წარმატებული ნულოვანი რუკები ყველა ნულოვანი ბიტი.
ასე რომ, აქ არის განსხვავება შორის წარმატებული ნულოვანი,
რომელიც ჩვენ მოვუწოდებთ null terminator.
აქ არის განსხვავება წარმატებული ნულოვანი და ხასიათი ნულოვანი.
>> ყველა უფლება.
ასე რომ, საუბარი ცოტა მეტი სიმები.
ასე რომ, ჩვენ ვხედავთ, რომ აქ ეს არის, თუ როგორ ეს იქნება ასახული მეხსიერება.
ასე რომ, ეს იდეა strings როგორც თანმიმდევრობა პერსონაჟი ასე ოფიციალურ კომპიუტერული
sciency ვადა თანმიმდევრობით მასივი.
ასე რომ, ჩვენ მოვუწოდებთ სიმებიანი მასივი სიმბოლო.
და არსებობს სხვა მონაცემები სახის, რომ ჩვენ შეგვიძლია კოლექტორები გარეთ.
>> ასე რომ, მოტივაცია ამ, შევხედოთ მაგალითს.
ჩვენ მოვუწოდებთ მას ages0.c მე დააკოპირეთ და ჩასვით ჩვენი template.
OK.
ასე რომ ამ პროგრამის ის, რაც ჩვენ გსურთ არის დაიბრუნოს ასაკი
სამი სტუდენტის, რა თქმა უნდა.
ასე რომ, ჩვენ ვიცით, Int ასაკი და ახლა მე ვაპირებ ვთქვა 0.
ასე, რომ თქვენ ალბათ მინდა ვთქვა, age1, მაგრამ მიზნებისათვის, ჩვენ დავინახავთ, ძალიან მოკლედ,
მე ვთქვა int age0 შეადგენს GetInt.
ასე რომ, იგივე მოწოდება GetInt რომ ჩვენ უკვე გამოყენებით მე
არ მოხდეს რითაც ამბობდა, "მომეცი ასაკში."
მაგრამ მხოლოდ ითხოვს.
>> და age1 შეადგენს GetInt.
და int age2 შეადგენს GetInt.
ასე რომ, კიდევ ერთხელ, სამი სტუდენტი, მაგრამ საბოლოოდ ცვლადი მაჩვენებლების
არიან age0 მეშვეობით age2.
OK.
ასე რომ ამ პროგრამის გააკეთებს, რასაც ჩვენ გვინდა age0, age1 და age2,
მაგრამ ამ პროგრამის საბოლოოდ მუშაობს სამი სტუდენტებს.
>> OK.
ასე რომ, ახლა რა, თუ მინდა, ოთხი სტუდენტი?
ისე, მე ვაპირებ უნდა დაბრუნდეს ჩემს კოდი, შეცვალოს კომენტარი,
და ახლა ჩვენ გვაქვს int age3 შეადგენს GetInt.
OK.
ასე რომ, ვინც ხედავს პრობლემა აქ?
რა არის პრობლემა ამ სახის კონფიგურაცია?
ჰო.
ასე რომ, ჩვენ შექმნა ცვლადი თითოეული სტუდენტი.
ახლა, რომ მუშაობს, მაგრამ საბოლოოდ რა თუ მე ახლა
ამბობენ, "მინდა დაიბრუნოს ასაკის რვა სტუდენტი და 16 მოსწავლე
ან თუმცა ბევრი სტუდენტი ასობით სტუდენტების CS50
ან ათასობით სტუდენტებს კამპუსში ან მილიარდობით ადამიანი მსოფლიოში?
ასე რომ, საბოლოო ჯამში, ეს არ არის მდგრადი.
ნებისმიერ დროს ხედავთ საკუთარ თავს გადაწერა და pasting კოდის მსგავსად,
თქვენ უნდა ზოგადად გრძნობენ რომ არ არსებობს უკეთესი გზა.
>> ასე რომ, ეს არის, სადაც ჩვენ გააცნობს მასივი დეკლარაცია.
ასე რომ, როდესაც თქვენ გამოაცხადოს მასივი, ეს არის ის, რაც ზოგადად ფორმატში
აპირებს გამოიყურებოდეს.
ჩვენ ვაპირებთ, რომ ვთქვათ ტიპის.
და მაშინ ჩვენ ვაპირებთ მისცეს სახელი რომ მასივი,
ისევე, როგორც ჩვენ განსაზღვრავს მოცემული ცვლადი.
და ბოლოს ჩვენ გამოყენებით ამ bracket notation ერთხელ
მაგრამ სხვადასხვა კონტექსტში როგორ ჩვენ გამოყენებით ადრე.
>> ასე რომ აქ ეს ჰგავს ჩვეულებრივი ცვლადის დეკლარაცია, რომელიც ჩვენ ვნახეთ.
ასე რომ, ჩვენ ვნახეთ int x ნახევრად მსხვილი ნაწლავის ადრე.
ისე, ახლა ჩვენ შეიძლება ნახოთ რაღაც როგორც int x ფრჩხილებში 5.
და აყენებს ეს იდეა შევიდა GetInt პროგრამა, რომელიც ჩვენ ჰქონდეს
ასე რომ, ჩვენ შეიძლება განახორციელოს ეს იგივე გზით.
>> ვთქვათ CS ჩვენ, როგორც წესი იყენებენ n როგორც რაოდენობის რაღაც.
ასე რომ, აქ ჩვენ ვაპირებთ შესანახად ოთხი სტუდენტებს.
და ახლა ჩვენ შეგვიძლია ვთქვათ, int ასაკი bracket N-- არ საკმაოდ მივიღებ ყოლა
განაცხადოს მასივი ოთხი სტუდენტებს.
ასე რომ, თუ ეს გამოიყურება მეხსიერების მსგავსი იქნება ეს.
წმინდა ეს.
ჩვენ ვაპირებთ, რომ სადღაც ამ memory-- მე დააყენა ეს იქ.
>> ასე რომ, სადღაც მეხსიერებაში.
ერთი, ორი, სამი, ოთხი.
ჩვენ გვყავს ოთხი რიცხვებით in a row ამ მასივი ოთხი რიცხვებით.
ასე რომ, ამჟამად, რა არის ზომა ერთი ასეთი ყუთები?
ჰო.
ეს ოთხი ბაიტი.
ეს არის 32 ბიტი.
ასე რომ, ახლა ეს არის სხვადასხვა საწყისი მასივი, რომ ჩვენ
ვნახეთ ადრე, მასივი სიმბოლო.
სიმებიანი თითოეულ ყუთში იყო მხოლოდ ერთი ბაიტი, რადგან ხასიათი მხოლოდ ერთი ბაიტი.
მაგრამ მასივი რიცხვებით, თითოეული ყუთი უნდა იყოს ოთხი ბაიტი, რათა
შეესაბამება მთელი რიცხვი.
ასე რომ, ეს არის ის, რაც მასივი ოთხი ints რომ გამოიყურებოდეს.
>> და შემდეგ უკან კოდი.
ახლა ჩვენ გვინდა რეალურად მაღაზია რიცხვებით რომ მასივი.
ასე რომ, ახლა ეს არის ძალიან, ძალიან, ძალიან საერთო ნიმუში, რომელიც რაღაც მომენტში
გახდეს კუნთების მეხსიერება.
ასე int i = 0.
მე ნაკლები n.
i plus plus.
ასაკი bracket i შეადგენს GetInt.
>> ასე რომ, ეს ციკლი, ამ ფორმატში, თქვენ უნდა მიიღოს ძალიან გამოიყენება.
ასე რომ, ეს არის ზოგადად, როგორ ჩვენ გადაურბინოთ თითქმის ნებისმიერი მასივი.
ახლა შეამჩნია ამ სახის განმარტავს, თუ რატომ თავიდანვე
ჩვენ არ გვაქვს ამისთვის მარყუჟების აპირებს int i უდრის 1, მე ნაკლები ან ტოლია 10.
მიზეზი იმისა, რომ დაწყებული ნულოვანი ხდის ამ სამუშაოს კარგად მასივები.
ასე რომ, კოლექტორები არის ნულოვანი ინდექსირებული.
თუ ამ მასივი სიგრძე 4, ინდექსების 0 მეშვეობით 3.
>> ასე რომ, პირველი iteration ამ loop
ჩვენ ვაპირებთ, რომ შექმნის ასაკი bracket 0 ტოლი ზარი GetInt.
ასე რომ, რასაც მე მოხდა შესვლის დროს კლავიატურაზე.
მეორე უღელტეხილზე, ჩვენ შექმნის age1 ტოლია GetInt.
მესამე უღელტეხილზე, age2.
საბოლოო უღელტეხილზე age3.
ასე რომ, თუ პირველ უღელტეხილზე მარყუჟის მე შევა რაოდენობა 4 კლავიატურის,
მაშინ ჩვენ ჩადეთ 4 აქ.
იმ შემთხვევაში, თუ მეორე უღელტეხილზე მე შევა 50, ჩვენ დააყენა 50 აქ.
მესამე უღელტეხილზე მე შეიძლება შესვლის -1, 1,
და ბოლოს თუ მე შემოსვლა 0- და მახსოვს, რომ ეს იყო ინდექსი სამი.
>> მას შემდეგ, რაც ჩვენ loop უკან, მე იქნება incremented 4.
i აღარ ნაკლებია, ვიდრე n, რომელიც 4.
ჩვენ შესვენება გარეთ loop.
ასე რომ, რა იქნება ცუდი ეს?
[INAUDIBLE]?
აუდიტორია: [INAUDIBLE]
>> დიახ.
ასე რომ მასივი მხოლოდ ოთხი ადგილებში, რაც იმას ნიშნავს, როგორც ინდექსები 0 მეშვეობით 3.
ასე რომ, თუ ეს მართლაც ასეა, მე მიიღოს ღირებულება 4 რაღაც მომენტში.
ასაკის 4 იქნება შექმნის რაც არ უნდა მოხდეს, რომ იყოს მეტი აქ
რა უნდა ვთქვა, შეიყვანოთ 6.
სწორედ ამას უნდა დააყენოთ ეს 6.
>> მაგრამ ჩვენ არ ვიცით, რა არის მეტი აქ.
ეს არ არის მეხსიერება რომ ჩვენ გვქონდა ხელმისაწვდომობის.
ასე რომ, თუ გახსოვთ წინა ლექცია,
იგი ბეჭდვის ღირებულებები Zamyla და რაღაც მომენტში იგი მოხვდა ამ სეგმენტაცია
ბრალია. ასე, რომ თქვენ ალბათ ხედავს ბევრი სეგმენტაცია ხარვეზებით, თქვენ
განახორციელოს ზოგიერთი პრობლემა კომპლექტი.
მაგრამ ეს არის ერთ-ერთი გზა, რომელიც შეგიძლიათ ექმნებათ სეგმენტაცია
ბრალია, როდესაც თქვენ დაიწყოს წვდომის მეხსიერების გზები, რომ თქვენ არ უნდა იყოს.
ასე რომ, ჩვენ არ გვაქვს წვდომა ამ ადგილას და ეს არის შეცდომა.
>> ასე რომ, ეს არის უკეთესი.
ახლა არის კიდევ პატარა საკითხი ამ კოდი.
და ეს, ძირითადად, რომ ჩვენ ჯერ კიდევ ჩარჩენილი ოთხ სტუდენტებს.
ახლა, თუ გსურთ გამოიყენოთ რვა სტუდენტები, OK.
ეს არ არის, რომ დიდი გარიგება.
შემიძლია წავიდეს, შეცვალოს კომენტარი, და შეცვალოს n.
ახლა ეს იმუშავებს რვა სტუდენტებს.
თუ მე შეადგინონ ამ და აწარმოებს ეს, ის გამოჩნდება ჩემთვის
ის მოითხოვს რიცხვებით რვა სტუდენტები და ის მხოლოდ მუშაობა.
მაგრამ ეს ნაკლები იდეალური უნდა recompile პროგრამა თითოეული დრო
მინდა, რომ შეიცვალოს სტუდენტთა რაოდენობის რომ მე მინდა შესვლის ასაკის.
>> ასე რომ, საბოლოო გაუმჯობესება ეს, როგორც ვნახავთ, აქ ჩვენ
აპირებს მოითხოვოს რაოდენობის ხალხი.
აქ ჩვენ გვაქვს მთელი რიგი ხალხი ოთახი
ან ნებისმიერი ასაკის ადამიანი ოთახში.
მაგრამ ჩვენ ვაპირებთ, რომ მოითხოვოს ნომერი ადამიანი ოთახში შესახებ.
ასე რომ, ეს არის ზუსტად იგივე do- ხოლო მარყუჟი, რომ ჩვენ ვნახეთ ადრე.
ეს არის ზუსტად იგივე do- ხოლო მარყუჟის, რომ თქვენ
შეიძლება ახორციელებს პრობლემა კომპლექტი.
ასე რომ, სანამ ისინი შესვლის n 1-ზე ნაკლები,
ასე რომ ის მივიღე, რომ იყოს მინიმუმ ერთი პირი ოთახი.
რადგან ისინი შესვლის n 1-ზე ნაკლები,
მაშინ ჩვენ ვაპირებთ, რომ შევინარჩუნოთ ითხოვს ერთხელ.
გთხოვთ შეიყვანოთ ნომერი ადამიანი ოთახში.
ახლა, როდესაც ჩვენ გვაქვს ნომერი ხალხი room--
ასე რომ მე შეიძლება შევიდეს, რომ არ 200 ადამიანი ამ ოთახში.
მაშინ ქვემოთ აქ ჩვენ ვაპირებთ, რომ მოდის და განაცხადოს მასივი ზომა 200.
ჩვენ ვაცხადებთ მასივი, რომ დიდი საკმარისი გამართავს 200 ასაკის.
მოდის ქვემოთ, ის ამისთვის loop რომ თქვენ გაქვთ ძალიან გამოიყენება.
ასე რომ iterating ამ მასივი, იმის თითოეული ადგილმდებარეობა
რომ მასივი რიცხვი, და მაშინ საბოლოოდ აქ ჩვენ
უბრალოდ ვიღებთ მაგალითს iterating გამო, რომ მასივი, არ მივანიჭოთ,
მაგრამ წვდომის ღირებულებებს.
>> ასე რომ აქ ჩვენ ვხედავთ, რომ ამბობენ, ერთი წლის შემდეგ,
პირი% მე ვიქნები% i წლის, სადაც პირველი% i არის i + 1.
ამიტომ არის ეს მაჩვენებელი განსხვავებულია.
და მეორე% i აპირებს იყოს მნიშვნელობა ინახება ასაკის array პლუს 1.
ასე რომ, ეს პლიუს 1 არის მხოლოდ იმიტომ, რომ ჩვენ ამბობდა ეს პლუს 1, ასაკის i + 1.
ეს პლიუს 1 არის მხოლოდ იმიტომ, რომ ჩვენ ამბობდა, ერთი წლის შემდეგ პირი
იქნება ამ წლის.
>> რატომ არის ეს i + 1?
რატომ ჩვენ პლუს 1 იქ?
ჰო.
დიახ.
ასე მახსოვს, კოლექტორები ნულოვანი ინდექსირებული.
ასე რომ, თუ ჩვენ დაბეჭდვის ამ გარეთ ვინმე უბრალოდ წავიკითხე გამომავალი,
მერე, ალბათ, გვინდა, რომ რაღაც როგორიცაა პირის ერთი პირი ნომერ,
იქნება 20 წლის.
პირი ნომერი ორი იქნება 15 წლის.
ისინი მირჩევნია ვერ ვხედავ პირი ხმების ნულოვანი არის 15 წლის.
>> ამიტომ შედგენას და უბრალოდ ხედავს, თუ რა ეს გამოიყურება მოსწონს შექმნა გარკვეული სივრცე.
ჩადება ასაკის ადგენს.
მიმდინარე ასაკის.
ჩვენ ვხედავთ რაოდენობის ხალხი ოთახში.
ასე რომ, მე ვიტყოდი, რომ არსებობს სამი ადამიანი ოთახში.
ასაკი პირი ნომერი ერთი, მოდით ვთქვათ, 15, 20, 25.
და ახლა მე ვიტყვი, ერთი წლის ახლა ისინი 16, 21, 26.
ვნახოთ, რომ ეს მუშაობს ო, რომ არ არის ტოლი 3.
ასე რომ, თუ მე ვიტყვი, ადამიანების რიცხვი 5, ერთი, ორი, სამი, ორი, ერთი, ერთი წლის შემდეგ
ისინი უნდა იყოს ორი, სამი, ოთხი, სამი, ორი წლის იყო.
ასე რომ, მე მხოლოდ ადვილად N იყოს 10,000.
ახლა მე უნდა ისხდნენ აქ საკმაოდ ხოლო შესვლის ასაკის, მაგრამ ეს სამუშაოები.
>> ასე რომ, ახლა მეხსიერება სადღაც აქვს მასივი ზომა 10,000,
ასე რომ, საბოლოო ჯამში 40,000 bytes, რადგან არსებობს
ოთხი ბაიტი თითოეული იმ რიცხვებით.
ასე რომ, არსებობს მასივი ზომა 10,000, სადაც შეგვიძლია
შესანახად ასაკის იმ 10,000 ადამიანი.
ყველა უფლება.
კითხვები ნებისმიერ ამ?
ჰო.
რა მოხდება, თუ თქვენ მისცა უარყოფითი რიცხვი?
ვნახოთ, რა მოხდება.
ასე რომ, ამ კონკრეტულ case-- ნომერი ხალხი ოთახი, ნეგატიური.
ეს უარყვეს, იმიტომ, რომ აქ ჩვენ არ
გატარება იმ ფაქტს, რომ, თუ n ნაკლებია, ვიდრე ერთი, ჩვენ ვაპირებთ, ვთხოვოთ ერთხელ.
თუ თქვენ ცდილობენ განაცხადოს მასივი უარყოფითი ზომა,
ის საერთოდ არ მუშაობს.
>> მოდით ცდილობენ.
მოდით იგნორირება, რასაც მნიშვნელობა ისინი შეყვანის n
და უბრალოდ, ვამბობთ int ასაკის ნეგატიური.
მოდით ვნახოთ, თუ ეს კი ადგენს.
მე არ ვარ დარწმუნებული.
No.
ასე რომ, ასაკის გამოცხადდა მასივი უარყოფითი ზომა.
ასე რომ, upfront იგი აღიარებს მასივი ვერ იყოს უარყოფითი ზომა და უარყოფს მას.
ახლა, თუ ჩვენ არ ერევა ამ do- ხოლო loop სწორად,
თუ ჩვენ არ შემოწმების თუ n ნაკლებია, ვიდრე 1
ვთქვათ, ჩვენ მხოლოდ არ აქვს ამ ყველა
და ნაცვლად ჩვენ უბრალოდ აითვისებდა რიცხვი.
არ აქვს მნიშვნელობა რა რომ მთელი რიცხვი, ვაცხადებთ მასივი, რომ ზომა.
>> ასე რომ, შემდგენელი არ შეუძლია შესაძლოა უჩივიან ახლა.
თუ მე კომპილაციის ამას ასე რომ არ უჩივიან,
იმიტომ, რომ მას არ შეუძლია იცოდეს, რომ მე ვარ შესვლას აპირებს უარყოფითი ნომერი,
რომელიც შეიძლება იყოს არასწორი.
ყველა ის იცის, მე შეიძლება შესვლის დადებითი რიცხვი,
რომელიც შესანიშნავად მოქმედებს.
ასე რომ, მე წარმომიდგენია, თუ მე შემოსვლა უარყოფითი 1 ხალხი ოთახი, სეგმენტირება ბრალია.
>> ასე რომ, OK.
მოდით დავამატოთ ეს უკან მხოლოდ შევინარჩუნოთ ის, რაც თავდაპირველად იყო.
ასე რომ, ასაკის.
ახლა თუ მე შევეცდები უარყოფითი age-- ასე რომ, მოდით
ამბობენ, არსებობს ხუთი ადამიანი ოთახში.
ასაკი პირი ნომერ არის -4, პირი სამ
ნულოვანი, პირი three-- OK.
ასე რომ, აქ, ერთი წლის შემდეგ, პირი ნომერი ერთი უარყოფითი იქნება 3 წლის.
ასე რომ, ალბათ, არ აქვს აზრი.
მაგრამ ეს მხოლოდ იმიტომ, რომ ეძებს კოდს ყველა ვაკეთებთ
ითხოვს GetInt.
>> ახლა, თუ ჩვენ ჰქონდა GetPositiveInt ფუნქცია
ან ჩვენ რომ უბრალოდ გააკეთა ეს ერთგვარი იგივე ხოლო loop ქვემოთ იქ,
მაშინ ეს იმუშავებს შესანიშნავად ჯარიმა.
მაგრამ ამ კონკრეტულ შემთხვევაში, ჩვენ უბრალოდ არ
არ უნდა იყოს გატარება უარყოფითი.
ნებისმიერი სხვა კითხვები შესახებ კოლექტორები?
OK.
>> ასე რომ, ჩვენ ახლა ჩანს მასივები.
და ჩვენ ვაპირებთ, უნდა გამოვიყენოთ ამ ბრძანების ხაზი არგუმენტები.
ასე რომ პრობლემა კომპლექტი two-- მე ვიცი, რომ ბევრი თქვენგანი
შესაძლოა კვლავ მუშაობს პრობლემა კომპლექტი ერთი, მაგრამ პრობლემა მითითებული ორი ახლოვდება.
პრობლემა მითითებული ორი, თქვენ აპირებს უნდა იყოს საქმე სიმები, მასივები,
და ბრძანება ხაზი არგუმენტები.
>> ასე რომ, რა ბრძანება ხაზი არგუმენტები?
ახლა, თქვენ ხედავთ, ქვემოთ აქ პატარა teaser ზუსტად რა
იქნება ხდება.
ჩვენ ვხედავთ, int ძირითადი, inc argc, სიმებიანი argv ფრჩხილებში.
ასე რომ, პირველი მოდით ცდილობენ ინტერპრეტაცია რა, რომ ცდილობს ამბობენ.
ახლა, OK.
>> ასე რომ, ბრძანების თქვენ უნდა იყოს შეგუება ზოგიერთი ეს ბრძანებები
ახლა, და თქვენ ალბათ აწარმოებს cd ტერმინალში ადრე.
ასე რომ, თუ ჩვენ ვამბობთ, cd pset1, თქვენ იცით, რომ უნდა
იცვლება შევიდა pset1 დირექტორია.
>> ახლა შეამჩნია, რომ თქვენ არასდროს წერილობითი პროგრამა მოსწონს ეს ადრე.
თითოეული პროგრამა, რომელიც თქვენ წერილობითი, თქვენ აწარმოებს, ვთქვათ, dot ხაზი Mario,
dot slash ხარბ, და მაშინ იგი შეიძლება გამოიწვიოს თქვენ შეყვანა.
ახლა, რომ ის არ არის, რაც ცვლილება დირექტორია აკეთებს.
როდესაც თქვენ აწარმოებს CD, ეს არ ვთქვა, მაშინ, რომელიც დირექტორია გინდათ CD შევიდა?
ამის ნაცვლად, თქვენ უბრალოდ ამბობენ, CD pset1, და ეს მხოლოდ მიდის შევიდა pset1 დირექტორია.
>> ასე რომ, ანალოგიურად გვაქვს სხვა მაგალითები.
მიიღოს hello.
როდესაც თქვენ აწარმოებს მიიღოს, ეს არ ვთქვა, მაშინ, რომელიც პროგრამის გსურთ, რათა?
თქვენ უბრალოდ ამბობენ, იმ ბრძანების ხაზი მიიღოს hello.
>> Move არის კიდევ ერთი მაგალითი.
ეს ერთი ჩვენ გადავდივართ mario.c წარადგინოს ერთი დირექტორია.
ახლა ჩვენ ვიცით, ეს მაგალითი ჩვენ ნამდვილად ავლით ორი არგუმენტები.
არსებობს mario.c როგორც პირველი არგუმენტი, და dot dot არის მეორე არგუმენტი.
და მაშინ, როდესაც თქვენ აწარმოებს, რათა, თქვენ ვხედავთ, რომ მართლაც ხანგრძლივი ბრძანება ხაზი
რომ მართლაც ხანგრძლივი ბრძანება დაბეჭდილი ბრძანებათა სტრიქონიდან.
ასე რომ, ხანგრძლივი ბრძანება ამ მხოლოდ მოკლე ნაწილი,
მაგრამ ახლა ჩვენ გვაქვს სამი ბრძანების ხაზი არგუმენტები.
Dot dash ნულოვანი, hello, და hello.c.
>> ასე რომ, ეს არის ბრძანება ხაზი არგუმენტები, არგუმენტები
რომ თქვენ გადადის ზე ბრძანების ხაზი ისე, რომ იგი
არ უნდა აიძულა როდესაც თქვენ აწარმოებს პროგრამა.
ეს იქნება სამწუხარო, თუ, როდესაც თქვენ გაიქცა Clang მისი თქმით, "OK,
რომელიც პროგრამაში, რომელიც ფაილი ხარ შედგენის?
Hello.c.
რა დროშები რომ თქვენ მინდა შევა? dash o.
რა გსურთ ფაილი ეწოდოს?
hello.
არა, უბრალოდ აწარმოებს clang dash o მიესალმები hello.c.
>> ასე ეძებს უკან ეს.
ახლა argc-- argc არის არგუმენტი ითვლის.
ეს რიცხვი ბრძანება ხაზი არგუმენტები შევიდა ბრძანებათა ონლაინ.
ისე, argv-- ტექნიკურად V დგას ვექტორი,
რომელიც ძირითადად იმას ნიშნავს მასივი.
მაგრამ თქვენ შეგიძლიათ იგნორირება, რომ.
Argv-- სიმებიანი argv, ასე რომ, სიმებიანი argv ფრჩხილებში.
ასე რომ, ეს არის კიდევ ერთი ფორმა ფრჩხილებში თქვენ არ მინახავს ადრე.
ასე რომ, ჩვენ ვნახეთ bracket ნოტაცია, როდესაც ჩვენ განაცხადა,
როგორიცაა, string s უდრის Zamyla.
s bracket 0 ხელმისაწვდომი ხასიათი ზ
>> ჩვენ ასევე ჩანს ფრჩხილებში, როდესაც ჩვენ ვთქვით, int ასაკის bracket 5.
რომ განაცხადა მასივი ზომა 5.
ასე რომ, აქ არის მობილური ფრჩხილებში ჩვენ არ მინახავს ადრე.
ასე რომ, ეს ერთგვარი სიმებიანი argv, რომ იქნება სრულიად ნაცნობი
რომ ეს იქნებოდა მხოლოდ სიმებიანი.
ახლა ფრჩხილები რომ ეს არის მასივი.
ასე რომ, სიმებიანი argv ფრჩხილებში საშუალებით რომ argv მასივი სტრიქონები.
ახლა ტექნიკურად სიმებიანი არის მასივი სიმბოლო.
ასე რომ, ეს არის მასივი მასივი სიმბოლო.
მაგრამ ეს ბევრად უფრო ადვილია ფიქრი ეს უბრალოდ მასივი სტრიქონები.
>> რატომ შეიძლება ფრჩხილებში უნდა იყოს ცარიელი?
მსგავსად, რატომ არ შეიძლება ითქვას, bracket 5, bracket n?
ჰო.
ჩვენ არ ვიცით, რამდენი პორტები არ ვაპირებთ, რომ იყოს.
ასე რომ, თუ გადავხედავთ clang მაგალითად, ჩვენ ითქვას clang dash o მიესალმები hello.c.
ამ კონკრეტულ შემთხვევაში, არ მოხდება სამი ბრძანება ხაზი არგუმენტები.
ასე რომ, brackets-- ჩვენ დავინახავთ, მეორე, ეს არ იქნება სამი.
ეს ტექნიკურად იქნება ოთხი.
მაგრამ ფრჩხილებში, ჩვენ გვინდა ვთქვათ, არსებობს სამი.
მაგრამ ახლა, თუ ჩვენ შევხედე ნაბიჯი mario.c dot dot, ფრჩხილები
ჩვენ გვინდა, რომ ბოლო ორი მათგანი.
>> და არსებობს ბევრი ბრძანებები, ცვლადი ნომერი ბრძანების
არგუმენტები.
ასე რომ, რა ეს ვერსია ფრჩხილი ნოტაცია მიუთითებს
ის არის, რომ argv არის მასივი სტრიქონები.
მაგრამ ჩვენ არ ვიცით, რამდენი სიმები არიან, რომ მასივი.
და როგორ უნდა მაშინ იცით, თუ როგორ ბევრი სიმები მასივი?
ეს არის მთელი წერტილი argc.
argc გვეუბნება, თუ როგორ ხანგრძლივი argv არის.
>> ასე რომ, ბოლო რამ უნდა გონება არის ის, რომ, ტექნიკურად,
ბრძანება თავად ითვლის, როგორც ერთი ბრძანების ხაზი არგუმენტები.
ასე CD pset1, არსებობს ორი ბრძანების ხაზი არგუმენტები.
პროგრამა თავისთავად, CD, და შემდეგ ფაქტობრივი არგუმენტი ნაწილი, pset1.
ნებისმიერი პროგრამა, რომელიც თქვენ წერილობითი დღემდე უკვე ჰქონდა ერთი ბრძანება ხაზი არგუმენტი dot
სლეში Mario.
ეს არის ერთადერთი ბრძანება ხაზი არგუმენტი.
>> ასე რომ, ახლა ეძებს clang dash o მიესალმები hello.c.
რა არის argc?
4.
ამიტომ argc არის 4.
Clang, argv bracket 0 clang.
argv bracket 1 dash 0.
argv bracket 2 hello, და argv bracket 3 hello.c.
OK, ასე რომ ამ, და მაშინ ჩვენ გამოგიგზავნით შევხედოთ ზოგიერთი პროგრამული მაგალითები.
>> OK.
ასე რომ, ჩვენ შევხედოთ hello3.c.
ასე რომ, ეს უნდა იყოს ნაცნობი ერთ-ერთი პირველი გ მაგალითები
ჩვენ გვქონდა, სადაც ჩვენ უბრალოდ, ვამბობთ, hello მსოფლიოში, მაგრამ ახლა ეს უფრო ზოგადი.
ასე რომ, აქ ჩვენ ვამბობთ მიესალმები % s წარმატებული ო argv bracket 1.
გაფრთხილების ასე წლამდე ამ ეტაპზე, ეს არის რა ჩემი template ფაილის ჰგავდა.
მე მქონდა int ძირითადი (void), და მაშინ მე რამე ძირითად ფუნქციას.
ახლა ნაცვლად, ერთხელ ჩვენ დავიწყოთ საქმე ბრძანების ხაზი არგუმენტები,
ჩვენ უნდა განვაცხადო, სხვადასხვა ფორმით მთავარი.
>> ასე რომ, ეძებს hello3 ერთხელ, მთავარი აპირებს
მიიღოს ორი არგუმენტი, ახლა int argc, რაოდენობის ბრძანება ხაზი არგუმენტები,
და სიმებიანი argv ფრჩხილებში, ფაქტობრივი strings შევიდა ბრძანებათა ონლაინ.
ამიტომ, მე ვაპირებ, რომ შეიცვალოს თარგი ასახავს ამ ფაქტს.
ახლა როდესაც წერთ პროგრამა, თუ არ
უნდა მიიღოს ნებისმიერი ბრძანების ხაზი არგუმენტები, მაშინ უბრალოდ გამოიყენოთ int ძირითადი (void).
მაგრამ ახლა, როდესაც თქვენ წერა ბრძანება ხაზი არგუმენტი პროგრამები, რომლებიც
თქვენ უნდა აკეთებს პრობლემის მითითებული two-- ასე რომ, ახლა, რომ თქვენ გაშვებული
პროგრამა, რომელიც უნდა მიიღოს ბრძანების ხაზი არგუმენტები,
თქვენ უნდა მთავარი ამ ფორმით.
>> ასე რომ, აქ ეს არის დიდი გამოყენება ბრძანების ხაზი არგუმენტი.
ასე რომ, ბეჭდვის argv 1.
OK მოდით კომპილირება და აწარმოებს ამ პროგრამის.
ჩადება hello3.
ადგენს.
Dot slash hello3.
და ვთქვათ, "Rob".
გამარჯობა Rob.
თუ მე ვიტყვი, "Hello მარია," hello მარია.
გამარჯობა მარია.
Hannah კვლავ აცხადებს, "hello მარია ", იმიტომ, რომ მე არ ვარ
აკეთებს არაფერი ჩვენი argv 2.
Argv 2 ახლა იქნებოდა "Hannah".
Argc იქნება 3.
რა მოხდება, თუ მე ეს?
ასე მიესალმები null.
>> მან მოკლედ შეეხო იმ ფაქტს, რომ, ტექნიკურად, GetString
შესაძლოა დაბრუნდეს null, მაგრამ ჩვენ კიდევ გაცილებით მეტი შევიდა, რასაც null რეალურად არის.
მაგრამ მას, როგორც საკითხია ის ფაქტი, რომ ზოგადად ცუდია.
ჩვენ გააკეთა რაღაც თუ ის დაბეჭდვის "hello null."
და მიზეზი ჩვენ გავაკეთეთ რაღაც არასწორი is-- კარგად,
როდესაც მე გაიქცა dot slash hello3, argc 1.
ასე რომ, ეს ნიშნავს, რომ სიგრძეზე argv 1.
თუ მასივი სიგრძე 1, ერთადერთი სწორი მაჩვენებელი ნულის ტოლია.
ასე რომ, აქ argv 1 გარეთ სპექტრი ამ მასივი.
ეს იყო მსგავსი ადრე, როდესაც მე შევეცადე შესანახად 6 გარეთ ბოლოს მასივი.
ასე რომ, ვცდილობ წვდომის რაღაც გარეთ argv ითვლის,
და ჩვენ ვიღებთ null.
>> ასე რომ, უკეთესი ვერსია ამ, გაუმჯობესება,
მკაფიოდ შემოწმების argc.
ასე რომ, თუ argc უდრის 2, რაც ნიშნავს, რომ გაიქცა რაღაც dot slash hello3 Rob.
და ეს იქნება ბეჭდვა "Hello Rob".
თუ argc არ უდრის 2, მაშინ ის უბრალოდ აპირებს
იგნორირება რასაც თქვენ დააყენა ბრძანება ხაზი არგუმენტი
როგორც ბრძანება ხაზი არგუმენტები.
ან თუ თქვენ არ დააყენოს ნებისმიერი ყველა, ეს უბრალოდ აპირებს იგნორირება, რომ და უბრალოდ ამბობენ,
"გამარჯობა."
>> ამიტომ შედგენას ეს.
ჩადება Hello4.
და გაშვებული Hello4.
Running ეს გზა, რა უნდა დაიბეჭდოს?
"გამარჯობა."
გამარჯობა.
რაც შეეხება Hello4 Rob?
"Hello Rob".
და ბოლოს, hello Rob მარია მხოლოდ "hello თქვენ" კიდევ ერთხელ,
იმიტომ, რომ თქვენ ნამდვილად არ შევა რაღაც, რომ ეს მოსალოდნელი იყო.
თქვენ შევიდა სახელები ვიდრე ეს შეიძლება გაუმკლავდეს,
ასე რომ მხოლოდ დეფოლტი, რომ მიესალმები თუ არა ქცევა.
ასე რომ, ამ?
ან ბრძანების ხაზი არგუმენტები?
>> OK, ასე აღების შევხედოთ რამდენიმე მაგალითები გამოყენების
ბრძანების ხაზი არგუმენტი პირველი ჩვენ argv dash 1 dot გ.
ასე რომ, კომენტარი მისცემს მოშორებით რა ეს პროგრამა უნდა აკეთებს.
მაგრამ შეამჩნია, ახლა ეს ციკლი, ამ მატჩების ზუსტი ნიმუში
მე ამბობდა ადრე.
ჩვენ უბრალოდ არ უნდა იყოს გამოყენებით argc ნაცვლად n.
ახლა argc მართლაც n.
ეს არის სიგრძეზე argv მასივი.
ასე რომ iterating მეტი argv მასივი printf-Ing თითოეულ argv ღირებულება.
>> ასე რომ, თუ მე ამ.
ჩადება argv 1.
იგი ადგენს.
Dot ხაზი argv 1.
უბრალოდ გაშვებული, ეს ნამუშევარი dot slash argv 1
მას შემდეგ, რაც ეს იყო ერთადერთი ბრძანება ხაზი არგუმენტი პროგრამის სახელი.
ყოველთვის იქნება არანაკლებ argc არ შეიძლება იყოს არანაკლებ ერთი,
მას შემდეგ, რაც იქ ყოველთვის მინიმუმ იყოს პროგრამის სახელი აწარმოებს.
ასე რომ, argv 1 Rob ბეჭდვა argv 1 და შემდეგ ახალი ხაზი "Rob".
>> ამიტომ პირველ iteration ამ მარყუჟის, არის 0.
Argv 0 პროგრამის სახელი.
Dot ხაზი argv 1.
და შემდეგ argv 1 არის ჩემი პირველი ბრძანება ხაზი არგუმენტი, რომელიც Rob.
ამ ეტაპზე, ჩვენ ტოლია argc.
ჩვენ შესვენება გარეთ loop და ჩვენ გავაკეთეთ.
ასე რომ, ეს იმუშავებს თვითნებური ხმების ბრძანება ხაზი არგუმენტები.
ყურადღება მიაქციეთ, რომ ბეჭდავს argv 0, argv 1, argv 2, argv 3, argv 4.
და არ არსებობს argv 5.
argc უდრის 5.
ასე რომ, argc-- at i შეადგენს 5, ჩვენ შესვენება გარეთ loop.
OK.
ასე რომ, კითხვები, რომ სანამ ჩვენ შევხედოთ უფრო რთული მაგალითი?
>> ასე რომ, argv 2.
ყველა უფლება.
ასე რომ, ჩვენ ჯერ კიდევ ბეჭდვის ბრძანების ხაზი არგუმენტები.
მაგრამ ახლა შეამჩნია ჩვენ წყობილი for loop.
ასე რომ, რა არის ეს აკეთებს?
ასე რომ, პირველი მარყუჟის აკეთებს ზუსტად ის, რაც ადრე.
ჩვენ ჯერ კიდევ looping ზე თითოეული ბრძანება ხაზი არგუმენტი,
მაგრამ ახლა ეს მეორე მარყუჟის ჩვენ ასევე ჩანს რაღაც მსგავსი ადრე.
როდესაც მას iterating მეტი Zamyla დაბეჭდვისას Z-A-M-Y-L-A.
ასე რომ, ეს მეორე მარყუჟის int j ტოლია 0, n უდრის strlen of argv bracket i.
>> მოდით პირველ ვფიქრობ, the-- მოდით გავლა.
მოდით ვიფიქროთ, რა კომპიუტერი გააკეთოს, თუ მე გაიქცა ეს პროგრამა, როგორც მხოლოდ dot
slash argv dash 2.
ასე რომ, თუ მე გაიქცა ეს კოდი, მაშინ argc იქნება 1-ის ტოლი.
და სიმებიანი argv-- იქ მხოლოდ იქნება ერთი მაჩვენებელი argv,
და რომ იქნება ტოლი dot slash argv 2- პროგრამის სახელი.
>> OK, ასე რომ, ახლა i უდრის 0, მე ნაკლები 1, i პლუს პლუს int j უდრის 0,
n უდრის strlen of argv bracket 0, ასე პირველი iteration ამ loop. argv
bracket 0 dot ხაზი argv 2.
რა არის სიგრძეზე რომ სტრიქონს?
ისე, dot ხაზი A-R-G-V dash 2.
ასე strlen რომ იქნება 8.
ასე კ უდრის 0, n უდრის 8.
რადგან კ ნაკლებია, ვიდრე 8, j ++.
და რომ ჩვენ ვაპირებთ, რომ იყოს ბეჭდვის ერთჯერადი ხასიათი, რომელიც
არის argv bracket i bracket კ.
>> ასე რომ, მხოლოდ i არის ნულოვანი.
ჩვენ ჯერ კიდევ მხოლოდ ერთი ბრძანების ხაზი არგუმენტი.
იმ პირველი მცდელობაა ამისთვის მარყუჟის, ჩვენ
იქნება ბეჭდვა argv bracket 0 bracket 0.
და შემდეგ კ აპირებს ნამატი.
და ჩვენ ვაპირებთ, რომ ბეჭდვა argv bracket 0 bracket 1.
და მაშინ argv bracket 0 bracket 2.
>> ასე რომ, ეს არის ჩვენი პირველი შეხვედრა მრავალ განზომილებიანი მასივები.
დამახსოვრება ადრე რომ ვთქვი რომ argv ტექნიკურად
მასივი კოლექტორები პერსონაჟების.
ასე რომ, აქ თუ ვთქვი რაღაც string s უდრის argv bracket i,
და მე ვთქვი მაშინ, s bracket j, ამ იქნება განხორციელების იგივე.
ახლა, ვნახე s bracket j ადრე.
ეს მხოლოდ წვდომის j-th გმირი ამ სიმებიანი.
ასე რომ, ეს, ჩვენ ვიღებთ j-ე ხასიათი i-th argv.
>> ასე რომ, რა უნდა ეს საბოლოო ჯამში გამომავალი?
ჩადება argv 2.
იგი ადგენს.
Dot slash argv 2.
"Rob მარია Hannah" და მოგვცეს გარკვეული ოთახი.
ასე რომ, ჩვენ ვხედავთ, რომ ეს outputting dot საკუთარი ხაზი და ხაზი
საკუთარი ხაზი და საკუთარი ხაზი.
ეს დაბეჭდვისას თითოეული ინდივიდუალური ხასიათი
თითოეული ბრძანება ხაზი არგუმენტი.
ხოლო შემდეგ, მათ შორის, იმიტომ, რომ ამ ახალი ხაზი
ჩვენ დაბეჭდვის ქვემოთ აქ, მათ შორის ეს კიდე ბეჭდვა ახალი ხაზი.
>> ასე რომ, ეს არის მსგავსი წინასწარი argv dash 1,
რომელიც ბეჭდური ყოველ ბრძანება ხაზი არგუმენტი,
მაგრამ ახლა ჩვენ დაბეჭდვის ბრძანების ხაზი არგუმენტები
და შემდეგ iterating მეშვეობით თითოეულ ხასიათი ყოველი ბრძანება ხაზი არგუმენტი
უნდა მიიღოს ამ გამომავალი.
OK?
ასე რომ, ამ?
>> ერთი რამ უნდა აღინიშნოს, რომ ბრძანების ხაზი არგუმენტი
ასე რომ, ისინი ერთმანეთისგან ფართები თქვენ, რასაკვირველია, ველით, რომ ისინი.
ასე რომ, სიმებიანი შეიძლება ჰქონდეს ფართები იგი.
ეს არ არის სუპერ მნიშვნელოვანია, მაგრამ თუ მე მინდოდა მესამე ბრძანება ხაზი არგუმენტი
აქვს სივრცეში, მაშინ მე შეიძლება ითქვას, რომ რაღაც მსგავსი.
OK?
ასე რომ, ეს ახლა მაინც მხოლოდ სამი ბრძანების ხაზი არგუმენტი კარგად 4.
Dot slash argv dash 2, რობ, მარია და Hannah Bloomberg.
OK.
კითხვები ამ?
>> იქ არაფერი განსაკუთრებული შესახებ სივრცეში ხასიათი.
ეს რაღაც უნდა იყოს, რომ ბრძანების ხაზი ეპყრობა სივრცის ხასიათი
როგორ გამოყოფა თითოეული არგუმენტი.
ყველა უფლება.
ასე რომ, პრობლემა კომპლექტი two-- თქვენ იქნება
ეძებს საიდუმლო გასაღები კრიპტოგრაფიის.
ასე რომ, მსგავსი მაგალითი ჩვენ ვნახეთ, საშობაო ამბავი,
თქვენ უნდა განხორციელების ზოგიერთი ალგორითმები, რომ მოცემულ გაგზავნა,
თქვენ აპირებს შეძლებს უნდა დაშიფვრა, რომ გაგზავნა
რომ მხოლოდ ვინმე, რომ საიდუმლო გასაღები, რომელიც დეკოდერი ბეჭედი,
უნდა შეეძლოს გაშიფვრა.
>> ასე რომ, ეს სტანდარტული გამოცემა.
თქვენ უნდა განხორციელების ორი სხვადასხვა ვერსია.
თუ მოხდება უნდა შევხედოთ იმ ჰაკერების edition-- ახლა,
ჩვენ ვაპირებთ, რათა თქვენ სიმებიანი მოსწონს ეს,
რომელიც წარმოადგენს დაშიფრული პაროლი.
ასე რომ თქვენი მიზანია, რათა გაერკვნენ ის, რაც გაშიფრული პაროლი.
ახლა ეს არის რეალურად როგორ პაროლები ინახება ბევრი კომპიუტერები,
და ეს მხოლოდ ინახავს ამ შემთხვევითი სიმებიანი სიმბოლოს.
თქვენ უნდა გაერკვნენ, თუ როგორ უნდა ამ შემთხვევითი სიმებიანი გმირები
რა ორიგინალური დაგავიწყდათ იყო.
>> და ბოლოს, მას შემდეგ, რაც ამ პრობლემა კომპლექტი, თქვენ უნდა
უნდა შეეძლოს გაიგოს, რას ნიშნავს ეს.
ასე რომ, თქვენ შეისწავლით თუ როგორ გაშიფვრა ეს ერთგვარი შემთხვევითი სტრიქონი.
ანალოგიურად, თუ გახსოვთ კვირაში 0, თქვენ შეიძლება არ მინახავს ამ URL.
და თქვენ უნდა შეეძლოს გაშიფვრა საბოლოოდ.
თქვენ შეიძლება არ იყოს ბედნიერი, როდესაც თქვენ გაშიფვრა და დააჭირეთ ბმულს.
ყველა უფლება.
ეს არის ის დღეს.
ასე რომ, თქვენ მომავალ კვირას!
>> [ელექტრონული მუსიკის დაკვრა]