>> [მუსიკის დაკვრა]
>> DOUG LLOYD ყველა უფლება, მოდით ვისაუბროთ ბრძანება ხაზი არგუმენტები.
ასე რომ, ჯერჯერობით, რა თქმა უნდა, საკმაოდ ბევრი ყველა პროგრამა
ალბათ დაიწყო მოსწონს ეს int ძირითადი ბათილად.
ჩვენ უკვე შეგროვება მომხმარებლის input, თუ ჩვენ სჭირდება
ჩვენი პროგრამების, როგორიცაა Mario პროგრამა, მაგალითად,
მიერ პროგრამა მოთხოვნა.
ჩვენ არ სჭირდებოდა ცვლილებები დეკლარაციის მთავარი,
იმიტომ, რომ ნაცვლად შიგნით ძირითადი ჩვენ უბრალოდ, ვამბობთ, თქვენ შეიძლება ეძახით მისაღებად int.
რამდენად დიდი გინდათ პირამიდის იყოს?
ან შეგიძლიათ ეძახით მისაღებად ათწილადი რამდენად შეცვლის
უნდა მე გამომავალი მომხმარებელი?
>> არსებობს კიდევ ერთი გზა, თუმცა, და თუ გვინდა, ჩვენი მომხმარებლების
შეძლებს გთავაზობთ მონაცემები, რომ ჩვენი პროგრამა
დგინდება გაშვების ნაცვლად, ხოლო პროგრამა გაშვებული,
დახვეწილი განსხვავება მაგრამ ზოგჯერ ძალიან სასარგებლო ერთი,
ჩვენ გვჭირდება ახალი ფორმა გამოცხადების მთავარი.
ჩვენ არ შეგვიძლია გამოვიყენოთ int ძირითადი ბათილად, თუ ჩვენ გვინდა შეაგროვოს სხვა მონაცემებს ბრძანების ხაზი
როდესაც მომხმარებელი ეშვება პროგრამა, აქედან გამომდინარე, ბრძანება ხაზი არგუმენტები.
>> შეგროვება ამ ბრძანების ხაზი არგუმენტები შესახებ,
შეცვალოთ თქვენი დეკლარაცია მთავარი უნდა გამოიყურებოდეს ამას int
მთავარ ღია paren, int argc, მძიმე, სიმებიანი argv, კვადრატულ ფრჩხილებში,
და შემდეგ გახსნა Curly გაუწიოს.
ასე რომ, რას ნიშნავს ეს უკვე?
ასევე, ჩვენ გადადის ორ პარამეტრების, ან არგუმენტებზე, ან საშუალებებით მთავარი.
ერთ-ერთი, მთელი მოუწოდა argc, და სხვა არის რა?
ეს არის მასივი სტრიქონები, არა?
ჩვენ ვხედავთ, რომ კვადრატული ფრჩხილი ნოტაცია.
ეს არის მასივი სტრიქონები.
ეს არ არის ინდივიდუალური სიმებიანი, ეს მასივი სტრიქონები.
და ეს ორი არგუმენტები, argc და argv, საშუალებას გაძლევთ იცოდეს, რა მონაცემების შესახებ
აქვს გათვალისწინებული ბრძანების ხაზი და რამდენი რამ მათ
გათვალისწინებული ბრძანების ხაზი.
Pretty სასარგებლო რამ მუშაობა.
>> Argc დგას არგუმენტი რაოდენობა, და თქვენ უნდა იცოდეს, სხვათა შორის,
რომ თქვენ შეიძლება მოუწოდოს argc რაც გაგიხარდებათ ის.
შეგიძლიათ დარეკოთ argv რასაც თქვენ სურდა.
ეს არის მხოლოდ ჩვეულებრივი სახელები რომ ჩვენ ვიყენებთ them-- არგუმენტი რაოდენობა,
და, როგორც ვნახავთ, მეორე, არგუმენტი ვექტორი, argv.
მაგრამ თქვენ არ უნდა მოვუწოდებთ მათ argc და argv თუ არ გვინდა,
მაგრამ პირობითად, რომ ის, რაც ჩვენ ვაკეთებთ.
>> ასე რომ მაინც argc, არგუმენტი რაოდენობა.
ეს რიცხვი ტიპის ცვლადი და ისე, როგორც თქვენ შეიძლება ველოდოთ, თუ ჩვენ გვაქვს ორი რამ
ჩვენ ვაპირებთ, რომ იყოს მოძიებაში რა ეს აკრეფილი
და როგორ ბევრი პერსონალი მომხმარებლის აკრეფილი, argc არის
გვეტყვით, რამდენად პერსონალის შესახებ აკრეფილი.
ასე რომ, ეს გაძლევთ ნომერი ბრძანების ხაზი არგუმენტები შესახებ
აკრეფილი პროგრამა დასაჯეს.
ასე რომ, თუ თქვენი პროგრამა აწარმოებს dot slash ხარბ,
და შიგნით თქვენი ხარბ პროგრამის მთავარი ფუნქცია
აქვს დეკლარაციაში int ძირითადი int argc, სიმებიანი argv კვადრატულ ფრჩხილებში, მაშინ
argc, ამ შემთხვევაში არის ერთი.
ახლა შეამჩნია, რომ ჩვენ არ ითვლიან რამდენი რამ
მომხმარებლის აკრეფილი შემდეგ პროგრამის სახელი.
პროგრამა სახელი თავად ითვლის როგორც ბრძანება ხაზი არგუმენტი.
>> ასე რომ, dot ხაზი ხარბ, in იმ შემთხვევაში, argc არის ერთი.
იმ შემთხვევაში, თუ მომხმარებლის აკრეფილი slash ხარბ 1024 CS50 ბრძანება ხაზი, argc იმ შემთხვევაში,
იქნება სამი.
და ჩვენ ვიცით, ეს იმიტომ, რომ გზა რომ გაყოფა სიმები
გამოვლინდა, არის თუ არა არსებობს სივრცე, ან tab,
ან რამე მაგდაგვარს მათ შორის.
ასე რომ, ნებისმიერი თანხა თეთრი სივრცის, ე.წ. ღირებულებებს შორის აკრეფილი ბრძანება ხაზი
მიუთითებს რამდენი არსებობს.
ასე რომ, dot ხაზი ხარბ ფართი 1024 სივრცეში CS50, argc, რომ ამ შემთხვევაში, არის სამი.
>> Argv არის არგუმენტი ვექტორი.
ვექტორი, სხვათა შორის, არის მხოლოდ კიდევ ერთი სიტყვა მასივი,
და ეს არის მასივი რომელიც ინახავს სიმები.
ერთი სტრიქონი თითო ელემენტს, რომელიც სტრიქონები, მომხმარებელს რეალურად
აკრეფილი ბრძანება ხაზი როდესაც პროგრამა დასაჯეს.
ახლა, როგორც იმ შემთხვევაში, ნებისმიერი მასივი, თუ
გავიხსენოთ ჩვენი განხილვის მასივები, პირველი ელემენტი argv
ყოველთვის იქნება ნაპოვნი განთავსებულია argv კვადრატული ფრჩხილი ნულოვანი.
ეს არის პირველი ინდექსი საქართველოს argv მასივი.
ასე რომ, will-- და ის ფაქტი, რომ ნება ყოველთვის იქნება პროგრამის სახელი,
ყოველთვის იქნება მდებარეობს argv კვადრატული ფრჩხილი ნულოვანი.
>> ბოლო ელემენტს argv ყოველთვის ი განთავსებულია argv კვადრატულ ფრჩხილებში argc მინუს ერთი.
მიგაჩნიათ თუ არა, რატომ?
დამახსოვრება რამდენი ელემენტები არსებობს ამ მასივი.
კარგად ვიცით, that-- ეს argc რიგი ელემენტები.
იმ შემთხვევაში, თუ მომხმარებლის აკრეფილი სამი რამ ბრძანების ხაზი, argc არის სამი.
მაგრამ იმის გამო, გ, როდესაც ჩვენ ვმუშაობთ მასივები, თითოეული ელემენტის მასივი,
უფრო სწორად, ინდექსები მასივი, დაიწყება ნულოვანი.
თუ ჩვენ გვაქვს სამი ელემენტები ჩვენს მასივი, ჩვენ გვაქვს ელემენტს argv ნულოვანი,
ელემენტს argv ერთი, და ელემენტს argv ორი.
არ არსებობს ელემენტს argv სამი და მასივი ზომა სამი.
ასე რომ, რატომ ბოლო ელემენტი argv ყოველთვის
იხილოთ argv მოედანზე ფრჩხილებში argc მინუს ერთი.
>> მოდით ვივარაუდოთ მომხმარებელი ახორციელებს ხარბ პროგრამა შემდეგნაირად
თუ ისინი აკრიფოთ ბრძანება ხაზი dot სლეში ხარბ ფართი 1024 სივრცეში CS50,
და სხვადსხვა მიზეზის გამო, რომ ჩვენ უკვე მომზადებული ჩვენი ხარბ პროგრამა
ვიცი და მუშაობა ამ ბრძანების ხაზი არგუმენტები.
ჩვენ არ ადრე, როდესაც ჩვენ ვმუშაობდით მასზე ხარბ პრობლემა,
მაგრამ ვთქვათ, ჩვენ ახლა განახლდა ისე, რომ ჩვენ ამის პროცესი
ბრძანების ხაზი არგუმენტები რამდენიმე გზა.
ამ შემთხვევაში, argv ნულოვანი არის dot slash ხარბ.
რა არის argv ერთი?
ისე, ეს 1024, უფლება?
ეს არის 1024, მაგრამ აქ არის მართლაც მნიშვნელოვანია distinction--
გახსოვთ მონაცემები ტიპის argv?
>> იგი ინახავს strings, არა?
მაგრამ ეს ჰგავს 1024 არის მთელი მნიშვნელობა.
ეს არის ძალიან მნიშვნელოვანი განსხვავება, და, ფაქტობრივად,
უნდა გახდეს ის, რომ თქვენ შეიძლება ექმნებათ შემდეგ პრობლემები.
ყველაფერი argv არის ინახება როგორც სიმებიანი.
ამიტომ argv ერთი შინაარსზე string ერთი, ნულოვანი, ორი, ოთხი,
შედგება იმ ოთხი სიმბოლო.
ეს თითქოს მომხმარებლის აკრეფილი ერთ-ერთი, ნულოვანი, ორი, ოთხი
როგორც ინდივიდუალური წერილებს ან სიმბოლო.
ეს არ არის მთელი რიცხვი 1024, და ასე რომ თქვენ არ შეუძლია პირდაპირ
მუშაობა მას და განაცხადა, int 1000, ან საკმაოდ int x უდრის argv ერთი მინუსი 24.
>> ინტუიციურად, შეიძლება ვიფიქროთ, რომ როგორც, OK, ასევე ის 1,024 მინუს 24,
ასე რომ, x უდრის 1,000.
მაგრამ ფაქტია, რომ ეს არ არის საქმე, იმიტომ, რომ argv ერთი სიმებიანი.
სიმებიანი 1024.
ახლა არის ფუნქცია, რომელიც შეიძლება იყოს გამოიყენება კონვერტირება სიმები რიცხვებით.
მე არ გააფუჭებს იგი თქვენთვის ახლა, მაგრამ დარწმუნებული ვარ, Zamyla
ბედნიერი იქნება, რომ გითხრათ ეს walkthrough მომავალში პრობლემა.
მაგრამ ასევე შეგიძლიათ პრობლემა მოსწონს საბაბი
მე, ფუნქციები, ამისათვის მითითებით 50,
თუ წასვლა მინიშნება სახელმძღვანელო იპოვნით ფუნქცია, რომელიც
გახდის ამ კონვერტაციის თქვენთვის.
მაგრამ კიდევ ერთხელ, walkthrough მომავალში პრობლემა,
Zamyla მოხარული იქნება გეტყვით, თუ რა ფუნქცია
ის არის, რომ იქნება კონვერტირება სიმებიანი 1024 რომ რიცხვი 1024.
>> ყველა უფლება, მოძრავი.
ჩვენ დაფარული ჩვენი argv ნულოვანი, ჩვენ დაფარული argv ერთი.
რა არის argv ორი?
CS50.
ეს ერთი, ალბათ, საკმაოდ თვითმმართველობის განმარტებითი.
რა არის argv სამი?
ისე, კიდევ ერთხელ, ჩვენ ნამდვილად არ ვიცი, არა?
ჩვენ გვყავს მასივი ზომა სამი, ეს არის ის, თუ რამდენი ელემენტები შესახებ
აკრეფილი ბრძანებათა ხაზი, ასე რომ, თუ ჩვენ წასვლა argv სამი,
ჩვენ ახლა არღვევთ ფარგლებში ჩვენი მასივი.
კომპილატორი მოდით ამის გაკეთება, იქ არ არის ინტუიციური პრობლემა,
მაგრამ იმ თვალსაზრისით, რეალურად რა ხდება უნდა მოხდეს, ჩვენ ნამდვილად არ ვიცი.
ეს დამოკიდებულია იმაზე, თუ რა არის მდებარეობს მეხსიერების სადაც
argv სამი მოსალოდნელია, რომ იყოს.
ასე რომ, ჩვენ შეიძლება დასრულდეს up მოშორებით scot უფასოდ.
უფრო სავარაუდოა, ვიდრე არ, განსაკუთრებით მაშინ, როდესაც თქვენ მუშაობის argv როგორც ეწინააღმდეგებოდა
ნებისმიერ სხვა მასივი რომ ჩვენს პროგრამაში,
ჩვენ, ალბათ აპირებს განიცდიან სეგმენტაცია ბრალი. ასე რომ კიდევ ერთხელ,
დარწმუნებული უნდა იყოს, არ გადალახონ საზღვრები თქვენი მასივები, განსაკუთრებით argv,
მოცემული მისი მაღალი ხარისხით მნიშვნელობა თქვენს პროგრამებში.
>> მე Doug Lloyd.
ეს არის CS50.