[Powered by Google Translate] ვისაუბროთ იმაზე მასივები.
ასე რატომ უნდა ოდესმე გვინდა გამოვიყენოთ კოლექტორები?
კარგად ვთქვათ თქვენ გაქვთ პროგრამა, რომელიც სჭირდება შესანახად 5 სტუდენტი პირადობის მოწმობები.
ეს შეიძლება, როგორც ჩანს გონივრული ჰქონდეს 5 ცალკე ცვლადები.
იმის გამო ჩვენ ვხედავთ bit, დავიწყებთ დათვლის საწყისი 0.
ცვლადები გვექნება იქნება int id0, int ID1, და ასე შემდეგ.
ვერანაირ ლოგიკას გვინდა ანსამბლის სტუდენტი ID უნდა იყოს დაკოპირებული და pasted
თითოეული ამ სტუდენტი პირადობის მოწმობები.
თუ გვინდა, რომ შეამოწმოს, რომელიც სტუდენტებს მოხდეს იყოს CS50,
ჩვენ ჯერ უნდა შევამოწმოთ, თუ id0 წარმოადგენს სტუდენტი რა თქმა უნდა.
მაშინ იგივეს მომდევნო სტუდენტი, ჩვენ უნდა დააკოპირეთ და ჩასვით კოდი id0
და შეცვლის ყველა დამთხვევა of id0 ერთად ID1 და ა.შ. ამისთვის id2, 3, და 4.
>> როგორც კი გესმით, რომ ჩვენ უნდა დააკოპირეთ და ჩასვით,
თქვენ უნდა დაიწყოს ფიქრი, რომ არსებობს უკეთესი გამოსავალი.
არის რა, თუ ხვდები, თქვენ არ გჭირდებათ 5 სტუდენტი პირადობის მოწმობები, არამედ 7?
თქვენ უნდა დაბრუნდეს თქვენს კოდის და დაამატე id5, id6,
და დააკოპირეთ და ჩასვით ლოგიკა შესამოწმებლად, თუ პირადობის მოწმობები ეკუთვნის კლასი ამ 2 ახალი პირადობის მოწმობები.
არაფერია დამაკავშირებელი ყველა ამ პირადობის მოწმობების ერთად, და ა.შ. არ არსებობს გზა გეკითხებით
პროგრამის ამის პირადობის მოწმობისათვის 0 მეშვეობით 6.
კარგად არის ხვდები თქვენ გაქვთ 100 სტუდენტი პირადობის მოწმობები.
ის იწყებს ჩანს ნაკლები იდეალური საჭიროა ცალკე განაცხადოს თითოეული პირადობის მოწმობა,
და დააკოპირეთ და ჩასვით ნებისმიერი ლოგიკა იმ ახალი პირადობის მოწმობები.
მაგრამ იქნებ ჩვენ ვაპირებთ, ჩვენ ამას ყველა 100 სტუდენტი.
მაგრამ რა, თუ თქვენ არ იცით, თუ რამდენი სტუდენტი იქ სინამდვილეში?
არსებობს რამოდენიმე N სტუდენტები და თქვენი პროგრამის ვთხოვო მომხმარებლის რა რომ n.
Uh Oh. ეს არ არის იმუშავებს კარგად.
შენი პროგრამა მუშაობს მხოლოდ გარკვეული მუდმივი მოსწავლეთა რაოდენობას.
>> გადაჭრის ყველა ამ პრობლემის სილამაზის მასივი.
რა არის მასივი?
ზოგიერთ პროგრამირების ენების მასივი ტიპის შესაძლოა გავაკეთოთ უფრო მეტი,
მაგრამ აქ ჩვენ ფოკუსირება ძირითად მასივი მონაცემები სტრუქტურა ისევე როგორც დაინახავთ მას C.
Array მხოლოდ დიდი ბლოკი მეხსიერება. ეს არის ის.
როდესაც ჩვენ ვამბობთ, რომ ჩვენ გვაქვს მასივი 10 რიცხვებით, რომ მხოლოდ იმას ნიშნავს, რომ ჩვენ გვაქვს გარკვეული ბლოკი
მეხსიერების რომ არის დიდი საკმარისი გამართავს 10 ცალკე რიცხვებით.
თუ ვივარაუდებთ, რომ მთელი რიცხვი არის 4 ბაიტი, ეს იმას ნიშნავს, რომ მასივი 10 რიცხვებით
არის უწყვეტი ბლოკი 40 ბაიტი მეხსიერებაში.
მაშინაც კი, როდესაც თქვენ იყენებთ მრავალგანზომილებიანი მასივები, რომელიც ჩვენ არ წავიდეს აქ,
ეს ჯერ კიდევ მხოლოდ დიდი ბლოკი მეხსიერება.
მრავალგანზომილებიანი ნოტაცია მხოლოდ მოხერხებულობისთვის.
თუ თქვენ გაქვთ 3 by 3 მრავალგანზომილებიანი მასივი რიცხვებით,
შემდეგ თქვენი პროგრამა მართლაც მხოლოდ ჩათვალოს როგორც დიდი ბლოკი 36 ბაიტი.
საერთო რაოდენობა რიცხვებით არის 3 ჯერ 3, და ყოველი მთელი რიცხვი იკავებს 4 ბაიტს.
>> მოდით შევხედოთ ძირითადი მაგალითი.
ჩვენ აქ 2 სხვადასხვა გზით გამოცხადების მასივები.
ჩვენ უნდა კომენტარის 1 მათგანი გარეთ პროგრამის შედგენა
რადგან ჩვენ ვაცხადებთ x ორჯერ.
ჩვენ შევხედოთ ზოგიერთი განსხვავებები ამ 2 სახის დეკლარაციების bit.
ორივე ეს ხაზები განაცხადოს მასივი ზომა N,
სადაც ჩვენ არ # define N როგორც 10.
ჩვენ შეგვეძლო ასევე ადვილად ვთხოვე მომხმარებლის ამისთვის დადებითი მთელი რიცხვი
და გამოიყენება, რომ მთელი რიცხვი, როგორც რაოდენობის ელემენტები ჩვენს მასივი.
არა ჩვენი სტუდენტი ID მაგალითად ადრე, ეს არის სახის მოსწონს გამოცხადების 10 სრულიად ცალკე
წარმოსახვითი ცვლადები; x0, x1, x2, და ა.შ. მდე xN-1.
იგნორირება ხაზები სადაც ჩვენ ვაცხადებთ მასივი, შეამჩნია კვადრატულ ფრჩხილებში ხელუხლებელი
შიგნით ამისთვის მარყუჟების.
როდესაც ჩვენ წერენ რაღაც x [3], რომელიც მე მხოლოდ იკითხება x bracket 3,
შეგიძლიათ წარმოიდგინოთ, რომ მას მოსწონს ითხოვს წარმოსახვითი x3.
გაითვალისწინეთ, ვიდრე მასივი ზომა N, ეს ნიშნავს, რომ ხმების შიგნით ფრჩხილებში,
რომელიც ჩვენ მოვუწოდებთ ინდექსი, შეიძლება იყოს არაფერს 0 დან N-1,
რომელიც სულ N მაჩვენებლები.
>> ვიფიქროთ იმაზე, თუ როგორ ეს რეალურად მუშაობს
გვახსოვდეს, რომ მასივი არის დიდი ბლოკი მეხსიერება.
თუ ვივარაუდებთ, რომ მთელი რიცხვი არის 4 ბაიტი, მთელი მასივი x არის 40 ბიტიანი ბლოკი მეხსიერება.
ამიტომ x0 ეხება პირველივე 4 bytes of ბლოკი.
X [1] ეხება შემდეგი 4 ბაიტი და ასე შემდეგ.
ეს ნიშნავს, რომ დაწყების x არის ყველა პროგრამა ოდესმე სჭირდება ტრეკზე.
თუ გსურთ გამოიყენოთ x [400], მაშინ პროგრამა იცის, რომ ეს არის ეკვივალენტი
უბრალოდ 1,600 ბაიტი დაწყებიდან x.
Where'd მივიღებთ 1,600 ბაიტი საწყისი? უბრალოდ 400 ჯერ 4 ბაიტი თითო რიცხვი.
>> სანამ მოძრავი, ძალიან მნიშვნელოვანია გვესმოდეს, რომ C
არ არსებობს აღსრულების ინდექსი, რომ ჩვენ გამოიყენონ მასივი.
ჩვენი დიდი ბლოკი მხოლოდ 10 რიცხვებით ხანგრძლივი, მაგრამ არაფერი დაწეროთ ჩვენზე თუ ჩვენ წერენ x [20]
ან თუნდაც x [-5].
ინდექსი კი არ უნდა იყოს რიცხვი.
ეს შეიძლება იყოს ნებისმიერი თვითნებური გამოხატვის.
პროგრამაში ვიყენებთ ცვლადი მე საწყისი ამისთვის loop გვერდზე შევიდა მასივი.
ეს არის ძალიან გავრცელებული ნიმუში, looping საწყისი i = 0 to სიგრძეზე მასივი,
და შემდეგ გამოყენებით მე როგორც მაჩვენებელია მასივი.
ამ გზით თქვენ ეფექტურად loop მთელ მასივი,
და თქვენ შეგიძლიათ მიანიჭოთ თითოეულ ადგილზე მასივში ან ვიყენებთ მას გარკვეული გაანგარიშებით.
>> პირველ for loop, მე იწყება 0,
და ასე იქნება სამუშაოდ მიავლინოს 0 spot in მასივი, ღირებულების 0 ჯერ 2.
მერე increments და უნდა მივუთითოთ პირველ ადგილზე მასივში ღირებულება 1 ჯერ 2.
მერე increments ისევ და ასე შემდეგ წლამდე უნდა მივუთითოთ მისი პოზიციონირება N-1 მასივში
ღირებულება N-1 ჯერ 2.
ამიტომ, ჩვენ შევქმენით მასივში პირველი 10 კი ნომრები.
იქნებ evens იქნებოდა ცოტა უკეთესი სახელი ცვლადი ვიდრე X,
მაგრამ, რომ მისცემდა რამ მოშორებით.
მეორე მარყუჟის მაშინ უბრალოდ ბეჭდავს ღირებულებებს, რომ ჩვენ უკვე ინახება შიგნით მასივი.
>> მოდით ვეცადოთ გაშვებული პროგრამის ორივე ტიპის მასივი დეკლარაციების
და შეხედეთ გამომავალი პროგრამის.
რამდენადაც ვხედავთ, პროგრამა ისე იქცევა ისევე როგორც სახის დეკლარაციები.
მოდით ასევე შეხედეთ რა ხდება თუ შევცვლით პირველი loop to არ შეჩერება N
არამედ ვთქვა 10,000.
გზა მიღმა ბოლოს მასივი.
Oops. იქნებ ვხედავთ ამ ადრე.
სეგმენტაცია ბრალია ნიშნავს, რომ თქვენი პროგრამა შეეჯახა.
თქვენ იწყებთ ვხედავთ ამ როდესაც თქვენ შეეხოთ სფეროებში მეხსიერების თქვენ არ უნდა ეხება.
აქ ჩვენ ეხება 10,000 ადგილების მიღმა დაწყების x,
რაც აშკარად არის ადგილი მეხსიერებაში ჩვენ არ უნდა ეხება.
ასე რომ ყველაზე მეტად ჩვენს ალბათ არ შემთხვევით დააყენა 10,000 ნაცვლად N,
მაგრამ რა, თუ რაიმე უფრო დახვეწილი, როგორიც ვთქვათ, ჩაწერის ნაკლები ან ტოლია N
in for loop მდგომარეობა განსხვავებით ნაკლები ნ
გახსოვდეთ, რომ მასივი მხოლოდ ინდექსების საწყისი 0 დან N-1,
რაც იმას ნიშნავს, რომ ინდექსი N სცილდება ბოლოს მასივი.
პროგრამა შეიძლება არ ჩამოვარდნის ამ შემთხვევაში, მაგრამ მაინც შეცდომა.
ფაქტობრივად, ეს შეცდომა იმდენად გავრცელებული, რომ მას აქვს საკუთარი სახელი,
ეცხოვრათ 1 შეცდომა.
>> სწორედ ეს საფუძვლები.
რა არის ძირითადი განსხვავება 2 ტიპის მასივი დეკლარაციების?
ერთი განსხვავება ის არის, სადაც დიდი ბლოკი მეხსიერება მიდის.
პირველ დეკლარაციაში, რომელიც მე მოვუწოდებ bracket-array ტიპის,
თუმცა ეს არ ნიშნავს პირობითი სახელი,
ეს გაგრძელდება Stack.
ხოლო მეორე, რომელიც მე მოვუწოდებ კურსორი-array ტიპის, ეს გაგრძელდება ბევრი.
ეს იმას ნიშნავს, რომ როდესაც ფუნქცია დააბრუნებს, bracket მასივი ავტომატურად deallocated,
ხოლო, როგორც თქვენ უნდა explicitily მოვუწოდებთ უფასოდ მაჩვენებელი მასივი
ანდა თქვენ გაქვთ მეხსიერების გაჟონვის.
გარდა ამისა, bracket მასივი არ არის რეალურად ცვლადი.
ეს არის მნიშვნელოვანი. უბრალოდ სიმბოლოა.
თქვენ შეგიძლიათ ვფიქრობ, რომ ეს მუდმივი რომ შემდგენელი ირჩევს თქვენთვის.
ეს ნიშნავს, რომ ჩვენ არ შეგვიძლია გავაკეთოთ რაღაც x + + ერთად bracket ტიპის,
თუმცა ეს შესანიშნავად მოქმედებს ერთად კურსორი ტიპის.
>> მაჩვენებელი ტიპის ცვლადი.
იყიდება მაჩვენებელი ტიპის, ჩვენ გვაქვს 2 ცალკე ბლოკები მეხსიერება.
ცვლადი x თავად ინახება დასტის და არის მხოლოდ ერთი მაჩვენებელი,
მაგრამ დიდი ბლოკი მეხსიერება ინახება ბევრი.
ცვლადი x on დასტის მხოლოდ ინახავს მისამართი
დიდი ბლოკი მეხსიერება შესახებ ბევრი.
ერთი გავლენა ამ არის ერთად ზომის ოპერატორს.
თუ თქვენ ეკითხებით ზომა bracket მასივი, ეს მოგცემთ ზომის დიდი ბლოკი მეხსიერება,
რაღაც 40 ბაიტი,
მაგრამ თუ თქვენ ეკითხებით ზომა კურსორის ტიპის მასივი,
ეს მოგცემთ ზომის ცვლადი x თავად, რომელიც ელექტრო სავარაუდოდ მხოლოდ 4 ბაიტი.
გამოყენება კურსორი-array ტიპის, შეუძლებელია პირდაპირ ითხოვენ
ზომა დიდი ბლოკი მეხსიერება.
ეს არ არის ჩვეულებრივ ბევრი შეზღუდვა რადგან ჩვენ ძალიან იშვიათად სურთ ზომა
დიდი ბლოკი მეხსიერება, და ჩვენ შეგვიძლია გამოვთვალოთ ჩვეულებრივ, თუ ჩვენ სჭირდება.
>> საბოლოოდ, bracket მასივი ხდება, მოგვაწოდოს მალსახმობი ამისთვის ინიციალიზაციისას მასივი.
ვნახოთ, თუ როგორ შეეძლო დაეწერა პირველი 10 კი რიცხვებით გამოყენებით კომბინაცია initilization.
ერთად კურსორი მასივი, არ არსებობს გზა ამის კომბინაცია მოსწონს ეს.
ეს არის მხოლოდ შესავალი რა შეგიძლიათ გააკეთოთ ერთად მასივები.
ისინი გამოჩნდება თითქმის ყველა პროგრამა წერთ.
იმედია შეგიძლიათ ნახოთ უკეთესი გზა კეთების სტუდენტი პირადობის მოწმობები მაგალითად
დასაწყისიდან ვიდეო.
>> ჩემი სახელი არის რობ Bowden, და ეს არის CS50.