>> [მუსიკის დაკვრა]
>> DOUG LLOYD: OK.
ჩვენ მუშაობდა მთელი რიცხვები, ჩვენ მუშაობდა გმირები,
ჩვენ მუშაობდა მოძრავი, ორადგილიანი, სიმები, და bools.
ჩვენ ამოწურა საკმაოდ ბევრი ყველა [INAUDIBLE] ტიპები,
უკვე ჩვენს ხელთ არსებული ყველა ერთად.
მაგრამ ახლა ჩვენ გვინდა, რომ რაღაც უფრო მეტი.
როგორ უნდა გავაკეთოთ, რომ?
როგორ უნდა შექმნათ სხვადასხვა მონაცემთა ტიპები?
ჩვენ შეგვიძლია ამის გაკეთება გამოყენებით სტრუქტურებში.
ასე სტრუქტურების საშუალებას გვაძლევს გავაერთიანოთ ცვლადი სხვადასხვა ტიპის
ერთ, ახალი ცვლადი ტიპის, რომელიც ჩვენ შეგვიძლია მივანიჭოთ საკუთარი ტიპის სახელი.
ეს არის ძალიან ძლიერი რამ უნდა იყოს ვერ გააკეთებს,
იმიტომ, რომ ჩვენ შეგვიძლია ჯგუფი ელემენტები სხვადასხვა მონაცემთა ტიპები
ერთად რომ აქვს ლოგიკური კავშირი.
ჩვენ შევძელით ამის გაკეთება, მასივები ერთგვარი, არა?
ჩვენ შეგვიძლია ჯგუფი ცვლადები იგივე მონაცემების ტიპის
ერთად დიდი ერთეული მეხსიერების მასივი.
>> მაგრამ ჩვენ ვერ შევძელით ავურიოთ მდე სხვადასხვა მონაცემთა ტიპები ერთად.
ჩვენ არ შეგვიძლია, ვთქვათ, წყვილი რიცხვი, და ხასიათი, და ორმაგი ყველა
იგივე რამ და მოვუწოდებთ, რომ ერთი ერთეული.
მაგრამ სტრუქტურების, ან ხშირად უწოდებენ structs,
ჩვენ რეალურად შეუძლია.
ასე რომ, სტრუქტურა, ერთგვარი საქართველოს, როგორც სუპერ ცვლადი.
ეს არის ცვლადი, რომელიც შეიცავს სხვა ცვლადები შიგნით მას.
ასე რომ, აქ არის მაგალითი იმისა, ძალიან მარტივი სტრუქტურა.
ეს არის ის, რაც სინტაქსი გამოიყურება მინდა, რომ შეიქმნას სტრუქტურა მანქანა.
ახლა, მოდით გავლა სინტაქსი აქ.
Struct, ეს არის სიტყვით, რომელიც მიუთითებს,
რომ მე შექმნა ახალი ტიპის მონაცემის აქ.
კერძოდ, მონაცემთა ტიპის სახელი იქნება struct მანქანა, როგორც ვნახავთ.
მაგრამ ეს არის ერთგვარი წვერი off შემდგენელი, რომ ეს
როგორც ჯგუფის ცვლადები, რომ აპირებს უნდა ჩაითვალოს ნაწილი იმავე ტიპის
ერთ წუთში.
>> ავტო, მხოლოდ სახელი სტრუქტურა.
ისევ და ისევ, მონაცემები ტიპის აქ აპირებს უნდა იყოს struct მანქანა, არა მხოლოდ მანქანა.
მაგრამ თუ თქვენ გაქვთ different-- თუ თქვენ შექმნათ მრავალი structs
იმავე პროგრამით, თქვენ უნდა განასხვავოს struct და struct.
ასე რომ, struct მანქანა, მე შესაძლოა, ასევე აქვს struct სტუდენტი, მაგალითად,
იმავე პროგრამით.
შიგნით curly აფრთხილებს ყველა ე.წ. სფეროებში,
ან წევრები სტრუქტურა.
რა არის ზოგიერთი რამ, რომლებიც თან ახლავს მანქანა?
ისე, ეს, როგორც წესი, აქვს წელს, მოდელი სახელი და ლიცენზია ფირფიტა,
odometer, რომ ჩვეულებრივ აქვს გარკვეული რაოდენობის მილი მასზე,
და შესაძლოა ძრავის ზომა.
და როგორც ხედავთ, მე აღრევას რიცხვებით და გმირები და ორადგილიანი.
ისინი ყველა იქნება ნაწილი ამ ახალი მონაცემები ტიპის.
>> და ბოლოს, საბოლოო რამ უნდა გავაკეთოთ, არ უნდა დაგვავიწყდეს, რომ ეს პატარა მძიმით
ბოლოს.
მას შემდეგ, რაც დასრულდება განსაზღვრის სტრუქტურა, ჩვენ უნდა დააყენოს მძიმით დასასრულს.
ეს არის ძალიან გავრცელებული სინტაქსური შეცდომა, რადგან ფუნქცია,
მაგალითად, თქვენ უბრალოდ უნდა ღია Curly გაუწიოს, მჭიდრო Curly გაუწიოს.
თქვენ არ დააყენოს მძიმით ბოლოს ფუნქცია განმარტება.
ეს ჰგავს ფუნქცია განმარტება, მაგრამ ეს არ არის,
და ასე მძიმით იქ არის შეხსენება, რომ თქვენ
უნდა დააყენოს ის არსებობს, რადგან შემდგენელი სხვაგვარად არ
იცით, რა უნდა გააკეთოს ეს.
ეს არის ძალიან გავრცელებული შეცდომა შემთხვევით, რათა
როდესაც თქვენ პირველი განსაზღვრის სტრუქტურებში.
>> OK.
ასე რომ, ჩვენ, როგორც წესი, განსაზღვრავს ჩვენს სტრუქტურები ძალიან დაბრუნება ჩვენი პროგრამების
იმიტომ, რომ ისინი ალბათ აპირებს გამოყენებული იქნას მრავალი ფუნქციები.
ჩვენ არ გვინდა, რომ განსაზღვროს struct შიგნით ფუნქცია,
იმიტომ, რომ მაშინ ჩვენ შეგვიძლია only-- ფარგლებს სტრუქტურა ნამდვილად
მხოლოდ არსებობს შიგნით რომ ფუნქცია.
ჩვენ გვინდა, ალბათ, სურს განსაზღვროს სტრუქტურა ასე რომ, ჩვენ შეგვიძლია გამოვიყენოთ იგი მრავალი ფუნქციები,
ან შესაძლოა, მრავალი ფაილი, რომელიც ერთმანეთთან
შევქმნათ ჩვენი ერთ პროგრამაში.
ზოგჯერ ასევე ნაცვლად განსაზღვრის სტრუქტურა
ძალიან ზევით სადაც თქვენ თქვენს ფუნტი მოიცავს და თქვენი ფუნტი განსაზღვრავს,
მაგალითად, თქვენ შესაძლოა ამით მათ ცალკე dot თ ფაილი, რომელიც თქვენ შემდეგ
ფუნტი მოიცავს თავს.
>> ასე რომ, ჩვენ სტრუქტურებში, მაგრამ ახლა ჩვენ უნდა ვისწავლოთ მათგან.
როგორ მივიღოთ შიგნით სტრუქტურა ხელმისაწვდომობა
იმ sub-ცვლადები, იმ ცვლადის რომ არსებობს შიგნით სტრუქტურა?
ისე, ჩვენ გვაქვს რაღაც მოუწოდა dot ოპერატორი, რომელიც საშუალებას გვაძლევს
წვდომის სფეროებში სტრუქტურა.
ასე მაგალითად, ვთქვათ, მე გამოაცხადა ჩემი სტრუქტურის მონაცემები აკრიფოთ სადღაც
ზედა ჩემი პროგრამა, ან შესაძლოა, dot თ ფაილი რომ მე ფუნტი შედის.
თუ მე მინდა, რომ შევქმნათ ახალი ცვლადი რომ მონაცემები ტიპის, შემიძლია ვთქვა,
struct მანქანა, ჩემი მანქანა, მძიმით.
ისევე, როგორც მე შეიძლება ითქვას, int x, ან სიმებიანი სახელი მძიმით.
>> მონაცემთა ტიპის აქ არის struct მანქანა, სახელი ცვლადი არის ჩემი მანქანა,
და მერე შეგიძლიათ გამოიყენოთ dot ოპერატორი წვდომის სხვადასხვა სფეროებში ჩემი მანქანა.
ასე რომ, შემიძლია ვთქვა, ჩემი მანქანა dot წელს უდრის 2011 წელს.
სწორედ შესანიშნავად ჯარიმა.
წელი, თუ გავიხსენებთ, განისაზღვრა, როგორც მთელი ველი შიგნით ამ struct მანქანის
მონაცემები ტიპის.
ასე რომ ნებისმიერი ცვლადი struct მანქანის მონაცემები ტიპის, როგორიცაა ჩემს მანქანაში, შემიძლია ვთქვა, ჩემი მანქანა
dot წელს შეადგენს და შემდეგ მივანიჭოთ ეს რაღაც მთელი ღირებულება, 2011 წელს.
ჩემი მანქანა dot დისკო შეადგენს CS50.
ჩემი ანკეტა dot odometer უდრის 50505 მძიმით.
ყველა იმ შესანიშნავად ჯარიმა და ეს არის ის,
როგორ ჩვენ შედიხართ სფეროში სტრუქტურა.
სტრუქტურებში, თუმცა, არ უნდა შეიქმნება Stack.
ისევე, როგორც ნებისმიერი სხვა ცვლადი, ჩვენ შეიძლება დინამიურად გამოყოფს მათ.
თუ ჩვენ გვაქვს პროგრამა, რომელიც შეიძლება მომტანი ბევრი სტრუქტურები,
ჩვენ არ ვიცით, რამდენი ჩვენ ვაპირებთ, რომ უნდა,
მაშინ ჩვენ უნდა დინამიურად გამოყოფს იმ სტრუქტურებს
როგორც ჩვენი პროგრამა გაშვებული.
ასე რომ, თუ ჩვენ ვაპირებთ, რათა შეამოწმონ სფეროში სტრუქტურა ამ კონტექსტში,
გავიხსენოთ, რომ ჩვენ ჯერ უნდა dereference მომცეთ სტრუქტურა,
და კიდევ ჩვენ dereference მაჩვენებელი, მაშინ ჩვენ შეუძლია სფეროებში.
თუ ჩვენ მხოლოდ მაჩვენებელი სტრუქტურა,
ჩვენ ვერ ვიტყვით მაჩვენებელი dot სფეროში ასახელებს და რა ჩვენ ვეძებთ.
არსებობს დამატებითი ნაბიჯი dereferencing.
ასე რომ, ვთქვათ, რომ ნაცვლად previous--
ისევე, როგორც წინა მაგალითად, ნაცვლად გამოცხადების
დასტის, struct მანქანა, ჩემი მანქანა, მძიმით, მე ვიტყვი, struct მანქანა,
ვარსკვლავი, მომცეთ struct მანქანის მოუწოდა ჩემი მანქანა,
შეადგენს malloc ზომა struct მანქანა.
ზომა ჩვენ გაერკვნენ, თუ რამდენი ბაიტი თქვენი ახალი მონაცემები ტიპის იკავებს.
თქვენ არ აუცილებლად მხოლოდ უნდა გამოვიყენოთ ზომა, სიგანე, int, ან char, ან
ჩაშენებული მონაცემთა ტიპები.
შემდგენელი არის smart საკმარისი გაერკვნენ, თუ რამდენი ბაიტი
მიერ მოთხოვნილი თქვენი ახალი სტრუქტურა.
ასე რომ, მე malloc თავს ერთეული მეხსიერება დიდი საკმარისი გამართავს struct მანქანა,
და მომცეთ უკან რომ ბლოკი მეხსიერება,
და რომ მომცეთ ენიჭება ჩემი მანქანა.
>> ახლა, თუ მინდა, რომ ხელმისაწვდომობის სფეროში ჩემი მანქანა,
მე პირველად dereference ჩემი მანქანის გამოყენებით dereference ოპერატორი, ვარსკვლავი
რომ ჩვენ ვნახეთ ეხლა პოინტერები ვიდეო, და შემდეგ მე dereference,
მერე შეგიძლიათ გამოიყენოთ dot ოპერატორი წვდომის სხვადასხვა სფეროებში ჩემი მანქანა.
Star ჩემი მანქანა dot წელს უდრის 2011 წელს.
ეს იქნებოდა ეფექტი ჩვენ გვინდა, ამ შემთხვევაში,
იმიტომ, რომ ჩვენ დინამიურად გამოყოფილი ჩემი მანქანა.
>> სწორედ ამგვარი შემაშფოთებელი, თუმცა, არა?
აქ არის 2 ნაბიჯი პროცესი ახლა.
ახლა ჩვენ უნდა dereference-- ჩვენ გვაქვს ვარსკვლავი ოპერატორი,
და ჩვენ გვაქვს dot ოპერატორი.
და როგორც მოსალოდნელი იყო, იმიტომ, რომ C პროგრამისტები მიყვარს მოკლე გზა
გავაკეთოთ ყველაფერი, არ არის მოკლე გზა ამის გაკეთება.
არსებობს კიდევ ერთი ოპერატორი მოუწოდა arrow, რაც ამ პროცესში ბევრი ადვილია.
გზა arrow მუშაობს ეს პირველი dereferences
მომცეთ მარცხენა მხარეს ოპერატორი,
და შემდეგ, მას შემდეგ, რაც dereferenced მომცეთ მარცხენა,
ის იღებს სფერო.
ასე რომ, ადრე ჩვენ გვქონდა ასეთი ვარსკვლავი ჩემი მანქანა dot ყველა ამ პერსონალის,
როგორიც იყო ბევრი ხდება.
მაგრამ რა შეგვიძლია ნაცვლად გააკეთოს არის ამ ჩემი მანქანა arrow წელს უდრის 2011 წელს.
>> ისევ და ისევ, რა ხდება აქ?
პირველი, მე dereferencing ჩემი მანქანა.
რაც კიდევ ერთხელ, მომცეთ აქ.
ამის შემდეგ, მას შემდეგ, რაც dereferenced ჩემი მანქანის,
შემდეგ შედიხართ სფეროებში წელს, დისკო, და odometer
ისევე, როგორც შემეძლო, სანამ, რომელსაც პირველი მეორადი ვარსკვლავი dereference ჩემი მანქანა,
და dot წვდომის სფეროში.
ასე რომ თქვენ შეგიძლიათ სტრუქტურები, თქვენ შეგიძლიათ აქვს მითითებას სტრუქტურები,
და თქვენ უნდა გზები მისასვლელი სფეროში იმ სტრუქტურების,
თუ თქვენ გაქვთ მითითებას მათ ან ცვლადი თავს.
Dot ან arrow, დამოკიდებულია როგორ ცვლადი გამოცხადდა.
მე Doug Lloyd, ეს არის CS50.