>> [მუსიკის დაკვრა]
დინამიკები ყველა უფლება.
ასე რომ, მოდით ვისაუბროთ სხვა რამ, რომ სახის უნიკალური C,
რომელიც მონაცემთა ტიპები და ცვლადი.
როდესაც მე ვამბობ, უნიკალური C, მე ნამდვილად მხოლოდ იმას კონტექსტში,
თუ თქვენ უკვე პროგრამისტი მართლაც დიდი ხნის განმავლობაში,
თქვენ ალბათ არ მუშაობდა მონაცემთა ტიპები
თუ თქვენ გამოყენებული თანამედროვე პროგრამირების ენები.
თანამედროვე ენებზე, როგორიცაა PHP და JavaScript,
რომელიც ჩვენ ასევე ვხედავთ პატარა მოგვიანებით, რა თქმა უნდა,
თქვენ არ რეალურად უნდა მიუთითოთ მონაცემები ტიპის ცვლადი
როდესაც თქვენ გამოიყენოს იგი.
>> თქვენ უბრალოდ განაცხადოს და დაიწყოთ გამოყენება.
თუ ეს რიცხვი, ვიცი, რომ ეს რიცხვი.
თუ ეს ხასიათი, იცის, რომ ეს პერსონაჟი.
თუ ეს სიტყვა, იგი დარწმუნებულია, ეს სტრიქონი, ე.წ..
>> მაგრამ C, რომელიც არის ძველი ენა, ჩვენ გვჭირდება
მიუთითოთ მონაცემები ტიპის ყველა ცვლადის
რომ ჩვენ შევქმნათ პირველად რომ ჩვენ ვიყენებთ, რომ ცვლადი.
ასე რომ, C გააჩნია გარკვეული ჩაშენებული მონაცემთა ტიპები.
და მოდით, გაეცნონ ზოგიერთ იმ.
და მაშინ ამის შემდეგ ჩვენ ასევე გაიგო ცოტა ზოგიერთი მონაცემთა ტიპები
რომ ჩვენ წერილობით თქვენ, ასე რომ თქვენ შეგიძლიათ გამოიყენოთ ისინი CS50.
>> პირველი არის int.
Int, მონაცემები ტიპის გამოიყენება ცვლადები რომელიც შესანახად რიცხვი ღირებულებებს.
ასე რომ, 1, 2, 3, უარყოფითი 1, 2, 3, და ასე შემდეგ.
რიცხვებით, რასაც თქვენ უნდა გვახსოვდეს, ვიქტორინა,
ყოველთვის ოთხი ბაიტი მეხსიერება, რომელიც არის 32 ბიტი.
არსებობს რვა ბიტი ბაიტი.
>> ასე რომ, ეს იმას ნიშნავს, რომ მთელი რიგი აფასებს, რომ მთელი რიცხვი შეგიძლიათ ჩაწეროთ
შეზღუდული რა შეიძლება ჯდება 32 ბიტი ღირებულების ინფორმაცია.
ახლა, როგორც ირკვევა, ეს იყო დიდი ხნის წინ გადაწყვიტა
რომ ჩვენ გაიყრებოდნენ რომ სპექტრი 32 ბიტი
უარყოფითი რიცხვებით და დადებითი რიცხვებით,
თითოეულ მიღების ნახევარი სპექტრი.
ასე რომ, სპექტრი ღირებულებებს, რომ ჩვენ წარმოვადგენთ ერთად მთელი რიცხვი მერყეობს უარყოფითი 2
31-ე ძალა 2 31-ე ძალა მინუს 1,
გამოიწვიოს თქვენ ასევე უნდა ადგილზე 0.
>> ასე რომ, ძირითადად ნახევარი შესაძლო მნიშვნელობებია თქვენ შეგიძლიათ შეესაბამება ამ int არის უარყოფითი,
და ნახევარი პოზიტიური.
და უხეშად აქ, ეს არის უარყოფითი 2 მილიარდი დადებითი 2 მლრდ.
მისცეს ან რამდენიმე ასეული მილიონი.
ასე რომ, რაც თქვენ ეტევა რიცხვი ცვლადი.
ახლა ჩვენ ასევე აქვს რაღაც მოუწოდა ხელმოუწერელი რიცხვი.
ახლა ხელმოუწერელი ints არ არის ცალკე ტიპის ცვლადი.
პირიქით, ხელმოუწერელი არის რასაც შესარჩევი.
ის ცვლის მონაცემები გაცნობის რიცხვი ოდნავ.
>> და ამ შემთხვევაში, რა ხელმოუწერელი ნიშნავს და ასევე შეგიძლიათ
გამოყენება ხელმოუწერელი სხვა მონაცემთა ტიპები, რიცხვი არ არის მხოლოდ ერთი.
ის, რაც ეფექტურად აკეთებს არის ორადგილიანი დადებითი სპექტრი ღირებულებებს
რომ მთელი რიცხვი შეუძლია ზე ხარჯზე აღარ საშუალებას აძლევს
თქვენ უნდა მიიღოს უარყოფითი.
ასე რომ, თუ თქვენ გაქვთ ციფრები, რომ თქვენ იცით, მიიღებს უფრო მაღალია, ვიდრე 2 მილიარდი, მაგრამ ნაკლებად
ვიდრე 4 მილიარდი, მაგალითად რომელიც არის 2 32 power--
დაგვჭირდება გამოიყენოს ხელმოუწერელი int თუ
იცით, თქვენი ღირებულება არასოდეს არ იქნება უარყოფითი.
>> თქვენ ზოგჯერ აქვს გამოიყენება ხელმოუწერელი ცვლადები
CS50, რის გამოც მე აღვნიშნო, რომ აქ.
მაგრამ ერთხელ, სპექტრი ღირებულებებს, რომ თქვენ შეგიძლიათ წარმოადგენენ ხელმოუწერელი რიცხვი
როგორც t რეგულარული რიცხვი, რომლებიც 0 2 დან 32 ძალა მინუს 1,
ან დაახლოებით 0 4 მილიარდი.
ასე რომ, თქვენ ეფექტურად გაორმაგდა დადებითი დიაპაზონი, რომ თქვენ შეუძლია მოერგოს,
მაგრამ თქვენ მისცა ყველა უარყოფითი ღირებულებებს.
>> ახლა, როგორც განზე, ხელმოუწერელი არ არის მხოლოდ შესარჩევ
რომ ჩვენ შეიძლება ნახოთ ცვლადი მონაცემთა ტიპები.
ასევე არსებობს რამ მოუწოდა მოკლე და გრძელი და const.
მშენებარე ჩვენ დავინახავთ პატარა ცოტა ხნის შემდეგ, რა თქმა უნდა.
მოკლე და გრძელვადიანი, ჩვენ ალბათ არ.
>> მაგრამ ვიცი, რომ იქ სხვა შესარჩევ.
ხელმოუწერელი არ არის მხოლოდ ერთი.
მაგრამ ეს მხოლოდ ერთი ჩვენ ვაპირებ ვისაუბრო ახლავე.
ასე რომ, ყველა უფლება.
ასე რომ, ჩვენ დაფარული რიცხვებით.
რა არის შემდეგი?
>> სიმბოლო.
ასე რომ, სიმბოლო გამოიყენება ცვლადები რომელიც შესანახად ერთი სიმბოლო.
Char მოკლე ხასიათი.
და ზოგჯერ შეიძლება მოვისმინოთ ადამიანი შეხედულებებსა, როგორც მანქანა.
>> ასე რომ, გმირები ყოველთვის დასჭირდეს ერთი ბაიტი მეხსიერების, რომელიც მხოლოდ 8 ბიტი.
ასე რომ, ეს იმას ნიშნავს, რომ მათ შეუძლიათ მხოლოდ ჯდება ღირებულებების სპექტრი უარყოფითი 2
მეშვიდე ძალა, ან უარყოფითი 128, 2 მე -7 ძალა მინუს 1, ან 127.
>> მადლობა ASCII, ეს იყო დიდი ხნის წინ გადაწყვიტა გზა
რუკაზე იმ დადებითი ციფრები 0 127 სხვადასხვა გმირები
რომ ყველა არსებობს ჩვენს კლავიატურაზე.
ასე რომ, როგორც ვნახავთ, მოგვიანებით რა თქმა უნდა, და თქვენ ალბათ
მოდის გვემახსოვრება რაღაც წერტილი, კაპიტალური, მაგალითად
ხასიათი დედაქალაქში A-- რუკები ნომერი 65.
და მიზეზი ის არის, იმიტომ, რომ ის, რაც არის, რომ ეს
მიერ დანიშნული ASCII სტანდარტი.
>> ამას 97.
ხასიათი 0, როდესაც თქვენ რეალურად აკრიფოთ ხასიათი, არ
წარმოადგენს რაოდენობის ნულოვანი, 48.
თქვენ ვისწავლოთ რამდენიმე ამ როგორც თქვენ გადასვლა.
და თქვენ რა თქმა უნდა მოდის უნდა მათ ცოტა მოგვიანებით CS50.
>> შემდეგი ძირითადი მონაცემები ტიპის მცურავი პუნქტიანი ნომრები.
ასე რომ, მცურავი პუნქტიანი ნომრები არიან ასევე ცნობილია, როგორც რეალური ციფრები.
ისინი ძირითადად ციფრები, რომ აქვს ათობითი წერტილი მათ.
მცურავი პუნქტიანი ღირებულებებს ისევე როგორც რიცხვებით ასევე
შეიცავს 4 ბაიტი მეხსიერება.
ახლა, რომ არ არსებობს გრაფიკი აქ.
იქ არ არის ნომერი ხაზი, რადგან აღწერს სპექტრი float
არ არის ზუსტად ნათელი და ინტუიციური.
>> საკმარისია ითქვას, რომ თქვენ 32 ბიტი მუშაობა.
და თუ თქვენ გაქვთ რამდენიმე ისევე როგორც pi, რომელსაც აქვს
რიცხვი ნაწილი 3 და მცურავი წერტილი ნაწილი, ან ათობითი ნაწილი 0,14159,
და ასე შემდეგ, თქვენ უნდა იყოს შეუძლია წარმოადგინოს ყველა it--
მთელი ნაწილი და ათობითი ნაწილი.
>> ასე რომ, რას ფიქრობთ, რომ შეიძლება ნიშნავდეს?
ერთი ისაა, რომ თუ ათობითი ნაწილი იღებს აღარ და აღარ,
თუ მე მაქვს ძალიან დიდი მთელი ნაწილი, მე შეიძლება არ
შეძლებს, როგორც ზუსტი, ერთად ათობითი ნაწილი.
და რომ მართლაც შეზღუდვა float.
>> მოძრავი აქვს ზუსტი პრობლემა.
ჩვენ მხოლოდ 32 ბიტი მუშაობა, ასე რომ ჩვენ შეგვიძლია მხოლოდ
იყოს იმდენად ზუსტი ჩვენი ათობითი ნაწილი.
ჩვენ არ შეგვიძლია აუცილებლად აქვს ათობითი ნაწილი არის 100 ან 200 ციფრები,
იმიტომ, რომ ჩვენ მხოლოდ უნდა 32 ბიტი მუშაობა.
ასე, რომ ეს შეზღუდვა float.
>> ახლა, საბედნიეროდ, არსებობს სხვა მონაცემები ტიპის მოუწოდა
ორმაგი, რომელიც გარკვეულწილად ეხება ეს პრობლემა.
ორადგილიანი, როგორც მოძრავი, ასევე გამოიყენება შესანახად რეალური ნომრები, ან მცურავი წერტილი
ღირებულებებს.
განსხვავება ისაა, რომ ორადგილიანი ორმაგი სიზუსტით.
ისინი ვერ ჯდება 64 ბიტი მონაცემები, ან რვა ბაიტს.
რას ნიშნავს ეს?
ისე, ეს ნიშნავს, რომ ჩვენ შეიძლება ბევრი უფრო ზუსტი ერთად ათობითი წერტილი.
ნაცვლად იმისა, რომ pi შვიდ ადგილებში, შესაძლოა, ერთად float,
ჩვენ შეგვიძლია შესაძლოა, მას 30 ადგილები.
თუ ეს მნიშვნელოვანია, დაგვჭირდება გამოიყენოთ ორმაგი ნაცვლად float.
ძირითადად, თუ თქვენ მუშაობა არაფერს, სადაც
რომელსაც მართლაც დიდი ათობითი ადგილი და ბევრი სიზუსტით არის მნიშვნელოვანი,
თქვენ ალბათ მინდა გამოიყენოთ ორმაგი overfloat.
ახლა ყველაზე თქვენი მუშაობა CS50, float უნდა საკმარისი.
მაგრამ ვიცი, რომ წყვილთა არსებობს, როგორც გზა გარკვეულწილად გამკლავება სიზუსტით
პრობლემა გაწვდით დამატებით 32 ბიტი მუშაობა თქვენი ნომრები.
>> ახლა ეს არ არის მონაცემები ტიპის.
ეს არის ტიპის.
და ეს ე.წ. ბათილად.
და მე ამაზე ლაპარაკი, აქ იმიტომ, რომ ჩვენ, ალბათ,
ჩანს, რომ რამდენჯერმე უკვე CS50.
და თქვენ შეიძლება გაინტერესებთ რა ეს ყველაფერი.
>> ასე რომ, ბათილად არის ტიპის.
ეს არ არსებობს.
მაგრამ ეს არ არის მონაცემები ტიპის.
>> ჩვენ არ შეგვიძლია შევქმნათ ცვლადი ტიპის ცნოს და მივანიჭოთ მნიშვნელობა იგი.
მაგრამ ფუნქციები, მაგალითად, შეიძლება ჰქონდეს ბათილად დაბრუნების ტიპის.
ძირითადად, თუ ხედავთ ფუნქცია რომ აქვს ბათილად დაბრუნების ტიპის,
ეს იმას ნიშნავს, რომ ეს არ დაბრუნდება მნიშვნელობა.
შეიძლება ფიქრობთ საერთო ფუნქცია, რომელიც ჩვენ გამოიყენება ჯერჯერობით
ამ CS50, რომ არ დაბრუნდება მნიშვნელობა?
>> Printf ერთი.
Printf ფაქტობრივად არ დაბრუნდეს არაფერი თქვენ.
იგი ბეჭდავს რაღაც ეკრანზე, და ეს, ძირითადად,
გვერდითი ეფექტი, რა printf აკეთებს.
მაგრამ ეს არ გაძლევთ მნიშვნელობა უკან.
თქვენ არ ხელში შედეგად და მაღაზია ის რამდენიმე ცვლადი გამოიყენოს იგი მოგვიანებით.
უბრალოდ ბეჭდავს რაღაც ეკრანზე და თქვენ კეთდება.
>> ასე რომ, ჩვენ ვამბობთ, რომ printf არის ბათილად ფუნქცია.
ის დააბრუნებს არაფერი.
>> პერიმეტრზე სიაში ფუნქცია შეიძლება ასევე ბათილია.
და თქვენ ასევე ჩანს, რომ საკმაოდ მწირი CS50 ძალიან.
Int ძირითადი ბათილად.
თუ არა, რომ ბეჭედი ზარი?
ძირითადად რა იმას ნიშნავს, რომ მთავარი არ მიიღოს ნებისმიერი პარამეტრებს.
არ არსებობს არგუმენტი, რომ მისაღებად შევიდა ძირითადი.
ახლა მოგვიანებით ვნახავთ, რომ არ გზა გაივლის არგუმენტები მთავარი,
მაგრამ ჯერჯერობით რაც ჩვენ ჩანს int ძირითადი ბათილად.
მთავარი უბრალოდ არ მიიღოს ნებისმიერი არგუმენტები.
ასე რომ, ჩვენ დააკონკრეტა, რომ განაცხადა, ბათილად.
ჩვენ უბრალოდ, რომ ძალიან გამოკვეთილ იმის შესახებ,
ის, რომ არ მიიღოს ნებისმიერი არგუმენტები.
>> ასე რომ, ახლა, საკმარისია ამბობენ, რომ ბათილად ძირითადად
უნდა მხოლოდ ემსახურება როგორც placeholder თქვენ, როგორც ფიქრი, როგორც არაფერი.
ეს ნამდვილად არ აკეთებს არაფერს.
არ არის დაბრუნებული მნიშვნელობა აქ.
არ არსებობს პარამეტრების აქ.
ეს ბათილად.
ეს ცოტა უფრო რთული, ვიდრე.
მაგრამ ეს არ უნდა საკმარისი უკეთესი ნაწილი, რა თქმა უნდა.
და იმედია ახლა თქვენ გაქვთ პატარა უფრო მეტი კონცეფციის რა ბათილად არის.
>> ასე რომ, იმ ხუთი ტიპის თქვენ ნაცნობობა, რომელიც ჩაშენებული C.
მაგრამ CS50 ჩვენ ასევე გვაქვს ბიბლიოთეკა.
CS50.h, რომელიც შეგიძლიათ მოიცავს.
და რომელიც მოგაწვდით ორი დამატებითი სახის
რომ თქვენ ალბათ შეძლებს გამოყენება თქვენს დავალებებს,
ან უბრალოდ სამუშაო ზოგადად პროგრამირების.
>> პირველი ეს არის bool.
ასე რომ, ლოგიკური მონაცემები ტიპის, bool, გამოიყენება ცვლადები
რომელიც შესანახად ლოგიკური მნიშვნელობა.
თუ თქვენ ოდესმე მსმენია ეს ტერმინი ადრე, თქვენ
ალბათ იცით, რომ ლოგიკური მნიშვნელობა შეუძლია მხოლოდ
ჩატარების ორი სხვადასხვა მკაფიო ღირებულებებს.
ჭეშმარიტი და ყალბი.
ახლა ეს, როგორც ჩანს, საკმაოდ ძირითადი, არა?
ეს არის ერთგვარი სიურპრიზი, რომ ეს არ არსებობს C, როგორც ეს ჩაშენებული.
და ბევრი თანამედროვე ენებზე, რა თქმა უნდა, Booleans
არის სტანდარტული ძირითადად მონაცემები ტიპის.
მაგრამ C, ისინი, ფაქტობრივად, არ არის.
მაგრამ ჩვენ შევქმენით იგი თქვენთვის.
ასე რომ, თუ თქვენ ოდესმე უნდა შეიქმნას ცვლადი რომელთა ტიპის bool,
უბრალოდ დარწმუნებული უნდა იყოს შეიცავდეს CS50.h დასაწყისში თქვენი პროგრამა,
და თქვენ შეძლებთ შექმნათ ცვლადი bool ტიპის.
>> თუ თქვენ დაგავიწყდებათ შეიცავდეს CS50.h, და იწყებ გამოყენებით ლოგიკური ტიპის ცვლადები,
თქვენ შეიძლება ექმნებათ გარკვეული პრობლემები როდესაც თქვენ შედგენის თქვენი პროგრამა.
ასე რომ, უბრალოდ იყოს lookout რომ.
და იქნებ თქვენ შეგიძლიათ დაფიქსირება პრობლემების ფუნტი, მათ შორის cs50.h.
>> სხვა ძირითადი მონაცემები ტიპის, რომ ჩვენ გთავაზობთ თქვენთვის CS50 ბიბლიოთეკა
არის სიმებიანი.
ასე რომ, რა არის სიმებიანი?
Strings მართლაც მხოლოდ სიტყვები.
ისინი კოლექციების სიმბოლო.
ისინი სიტყვა.
ისინი სასჯელს.
ისინი პუნქტებში.
ეს შეიძლება იყოს მთელი წიგნი, კი.
>> ძალიან მოკლე და ძალიან დიდი ხნის სერია გმირები.
თუ თქვენ უნდა გამოვიყენოთ სიმები, მაგალითად, შესანახად სიტყვა,
უბრალოდ რა თქმა უნდა მოიცავს CS50.h დასაწყისში თქვენი პროგრამა
ასე რომ თქვენ შეგიძლიათ გამოიყენოთ string ტიპის.
და მაშინ თქვენ შეგიძლიათ შექმნათ ცვლადები მათი მონაცემების ტიპის სიმებიანი.
ახლა მოგვიანებით, რა თქმა უნდა, ჩვენ ასევე ვხედავთ, რომ
არ არის მთელი ამბავი, ან.
ჩვენ ექმნებათ რამ მოუწოდა სტრუქტურები,
რომელიც საშუალებას გაძლევთ ჯგუფი, რა შეიძლება იყოს რიცხვი და სიმებიანი ერთ ერთეული.
და ჩვენ შეგვიძლია გამოვიყენოთ, რომ გარკვეული მიზნით, რომელიც შეიძლება
მოდის მოსახერხებელი მოგვიანებით, რა თქმა უნდა.
>> და ჩვენ ასევე შეისწავლიან შესახებ განსაზღვრული ტიპის,
რომელიც საშუალებას გაძლევთ შექმნათ საკუთარი მონაცემთა ტიპები.
ჩვენ არ უნდა ფიქრი შესახებ, რომ ახლა.
მაგრამ ვიცი, რომ ეს არის ის, რაღაც ჰორიზონტზე,
რომ იქ კიდევ ბევრი მთელი ეს ტიპი რამ, ვიდრე მე გეუბნებით მხოლოდ
ახლა.
ასე, რომ ახლა გავიგე ცოტა შესახებ ძირითადი მონაცემები
სახის და CS50 მონაცემთა ტიპები, მოდით ვისაუბროთ, თუ როგორ უნდა იმუშაოს ცვლადები
და შექმნას მათ გამოყენებით ამ მონაცემთა ტიპები ჩვენი პროგრამების.
თუ გსურთ, რომ შევქმნათ ცვლადი, ყველა თქვენ უნდა გავაკეთოთ არის ორი რამ.
>> პირველი, თქვენ უნდა მისცეს მას ტიპის.
მეორე, რაც თქვენ უნდა უნდა გავაკეთოთ არის მისცეს მას სახელი.
ერთხელ თქვენ კეთდება, და მჯდომმა მძიმით ბოლოს, რომ ხაზი,
თქვენ შექმნა ცვლადი.
>> ასე რომ, აქ ორი მაგალითი.
Int ნომერი; char წერილი ;.
რა დაგიშავე აქ?
მე შეიქმნა ორი ცვლადი.
>> პირველი, ცვლადი სახელი ნომერი.
და ნომერი ჩატარება შეუძლია რიცხვი ტიპი ღირებულებები, რადგან მისი ტიპის int.
წერილი კიდევ ერთი ცვლადი რომელიც შეიძლება გამართავს გმირები
იმის გამო, რომ მისი მონაცემები ტიპის char.
>> საკმაოდ მარტივია, უფლება?
თუ თქვენ აღმოჩნდეთ ამ სიტუაციაში, როდესაც
თქვენ უნდა შექმნათ სხვადასხვა ცვლადი იგივე ტიპის,
თქვენ მხოლოდ უნდა მიუთითოთ ტიპის სახელი ერთხელ.
მაშინ უბრალოდ ჩამოვთვალოთ მრავალი ცვლადი, ამ ტიპის როგორც თქვენ გჭირდებათ.
>> ასე რომ, მე ვერ მაგალითად, აქ ამ მესამე ხაზი კოდი,
ამბობენ int სიმაღლე ;, ახალი ხაზი.
Int სიგანე ;.
და რომ მუშაობა ძალიან.
მე ჯერ კიდევ ორი ​​ცვლადის მოუწოდა სიმაღლე და სიგანე, რომელთაგან თითოეული
არის მთელი რიცხვი.
მაგრამ მე დაშვებული, რამ C სინტაქსი, კონსოლიდაცია მას ერთი ხაზი.
Int სიმაღლე, სიგანე; ეს არის იგივე.
მე შეიქმნა ორი ცვლადები, ერთი მოუწოდა სიმაღლე ერთი მოუწოდა სიგანე, რომლებიც
შეუძლია ჰოლდინგი მთელი ტიპის ღირებულებებს.
>> ანალოგიურად აქ, შემიძლია სამი მცურავი პუნქტიანი ღირებულებებს ერთდროულად.
შემიძლია იქნებ შევქმნათ ცვლადი მოუწოდა კვადრატული ფესვი 2-
რომელიც, სავარაუდოდ, საბოლოოდ გამართავს მცურავი წერტილი
რომ წარმომადგენლობა მოედანზე ფესვი 2- კვადრატული ფესვი 3 და pi.
მე შეიძლება გაკეთდეს ამ სამი ცალკეული ხაზები.
Float, კვადრატული ფესვი 2; Float კვადრატული ფესვი 3; ათწილადი pi; და, რომ მუშაობა ძალიან.
>> თუმცა ისევ და ისევ, მე შემიძლია მხოლოდ კონსოლიდაცია ეს ერთ ხაზი კოდი.
რაც რამ ცოტა მოკლე, არა როგორც clunky.
>> ახლა ზოგადად, ეს არის კარგი დიზაინი მხოლოდ განაცხადოს ცვლადი, როდესაც დაგჭირდებათ.
და ჩვენ ვსაუბრობთ პატარა ცოტა მეტი რომ
მოგვიანებით, რა თქმა უნდა, როდესაც ჩვენ განვიხილავთ ფარგლებს.
ასე რომ, არ არის აუცილებელი, შექმნა ყველა თქვენი ცვლადები
დასაწყისში პროგრამა, რომელიც ზოგიერთი ადამიანი შეიძლება გაკეთდეს წარსულში,
ან რა თქმა უნდა, ძალიან გავრცელებული კოდირების პრაქტიკა მრავალი წლის წინ
როდესაც მუშაობა C. თქვენ შეიძლება მხოლოდ გსურთ შექმნათ ცვლადი უფლება, როდესაც
დაგჭირდებათ.
ყველა უფლება.
ამიტომ, ჩვენ შევქმენით ცვლადები.
როგორ გამოვიყენოთ ისინი?
მას შემდეგ, რაც ჩვენ განაცხადოს ცვლადი, ჩვენ არ გვჭირდება
მიუთითოთ მონაცემები ტიპის რომ ცვლადი უქმნით.
სინამდვილეში, თუ თქვენ ამის გაკეთება, ალბათ დასრულდება up ერთად რაღაც უცნაური შედეგები
ის, რომ ჩვენ სახის სიპრიალის ახლა.
მაგრამ საკმარისია ითქვას, უცნაური რამ ხდება
დაიწყოს ხდება თუ უნებლიედ ხელახლა განაცხადოს ცვლადები იგივე სახელი
ისევ და ისევ.
>> ასე რომ, აქ მაქვს ოთხი ხაზი კოდი.
და მე მაქვს რამდენიმე კომენტარები არ მხოლოდ იმაზე მიუთითებს,
რა ხდება თითოეული ხაზი უბრალოდ, რათა დაეხმაროს
თქვენ მიიღებთ მდებარე რა ხდება.
ასე int ნომერი ;.
თქვენ ნახეთ, რომ ადრე.
ეს არის ცვლადი დეკლარაცია.
>> მე ახლა ის ცვლადი მოუწოდა ნომერი რომ არის
ჩატარება შეუძლია მთელი ტიპის ღირებულებებს.
მე გამოაცხადა.
>> შემდეგი ხაზი მე მინიჭება მნიშვნელობა ნომერზე.
პუნქტების ტოლია 17.
რა ხდება იქ?
მე გამოსული ხმების 17 შიგნით რომ ცვლადი.
>> ასე რომ, თუ მე ოდესმე შემდეგ ამობეჭდოთ რა შინაარსი ნომერი არიან მოგვიანებით,
ისინი გეტყვიან, რომ ჩემთვის ეს 17.
ამიტომ მე განაცხადა ცვლადი, და მაშინ მე ენიჭება.
>> ჩვენ შეგვიძლია გავიმეოროთ პროცესში ისევ char წერილი ;.
რომ დეკლარაციას.
წერილი ტოლია კაპიტალი H. ეს არის დავალება.
საკმაოდ მარტივია, ძალიან.
>> ახლა ეს პროცესი შეიძლება როგორც ჩანს, სახის სულელური.
რატომ ვაკეთებთ ამას ორი ხაზი კოდი?
არსებობს უკეთესი გზა ამის გაკეთება?
ფაქტობრივად, არ არსებობს.
ზოგჯერ თქვენ შეიძლება ნახოთ ამ ე.წ. ინიციალიზაციისას.
ეს მაშინ, როდესაც თქვენ გამოაცხადოს ცვლადი და მივანიჭოთ მნიშვნელობა ამავე დროს.
ეს არის რეალურად საკმაოდ საერთო რამ უნდა გააკეთოს.
როდესაც თქვენ შექმნით ცვლადი, თქვენ, როგორც წესი, გვინდა, რომ ზოგიერთი ძირითადი მნიშვნელობა.
მაშინაც კი, თუ ეს 0 ან რამე.
თქვენ უბრალოდ მისცეს მას მნიშვნელობა.
>> თქვენ შეგიძლიათ ინიციალიზაცია ცვლადი.
Int ნომერი ტოლია 17 არის იგივე, რაც პირველი ორი ხაზი კოდი ზემოთ.
Char წერილი ტოლია h არის იგივე, რაც მესამე და მეოთხე ხაზი კოდი ზემოთ.
ყველაზე მნიშვნელოვანი takeaway აქ როდესაც ჩვენ ვაცხადებთ და მინიჭების
ცვლადების შემდეგ ჩვენ განაცხადა, რომ, ცნობა
მე არ გამოყენებით მონაცემების ტიპის კიდევ ერთხელ.
მე არ ვამბობ, int ნომერი ტოლია 17 მეორე ხაზი კოდი, მაგალითად.
მე უბრალოდ ვამბობ, ნომერი ტოლია 17.
>> ისევ და ისევ, ხელახლა გამოცხადების ცვლადი შემდეგ თქვენ უკვე განაცხადა, რომ ეს შეიძლება გამოიწვიოს
ზოგიერთი უცნაური შედეგად.
ასე რომ, ფრთხილად, რომ.
>> მე Doug Lloyd.
და ეს არის CS50.