>> დევიდ ჯ Malan: როგორც თქვენ ალბათ იცით, ტემპერატურა იზომება გამოყენებით
სხვადასხვა მასშტაბის სხვადასხვა კუთხეში მსოფლიოში.
მაგალითად, 212 გრადუსი ფარენგეიტი არის 100 გრადუსი და 32 გრადუსი
Fahrenheit არის 0 გრადუსი.
არ იქნება ლამაზი თუ ჩვენ გვქონდა კომპიუტერი პროგრამა, რომელიც საშუალებას გვაძლევს
კონვერტირება, მაგალითად, Fahrenheit to გრადუსი?
>> ისე, ჩვენ შეგვიძლია დავწეროთ, რომ პროგრამა.
მოდით დავიწყოთ მოიცავს cs50.h, ასე რომ ჩვენ შეგვიძლია გამოვიყენოთ ფუნქცია მოუწოდა
მიიღეთ float, რომელიც, ისევე როგორც კიდევ int, იღებს ნომრის შესახებ, მაგრამ ამ დროს
მცურავი პუნქტიანი ნომერი ერთ - ერთი ერთად ათობითი წერტილი.
>> მოდით ასევე მოიცავს სტანდარტული io.h ასე რომ ჩვენ გვაქვს წვდომა
ფუნქციები, როგორიცაა ბეჭდვითი ვ.
და მოდით ასევე ვაცხადებ მთავარი ჩვეულ რეჟიმში.
>> მოდით მომდევნო შეეკითხება მომხმარებელს ამისთვის ტემპერატურა Fahrenheit.
მოდით ახლა რეალურად მიიღონ, რომ ტემპერატურის საწყისი მომხმარებელი, პირველი
გამოცხადების ცვლადში f ტიპის float.
Float, კიდევ ერთხელ, რაც იმას ნიშნავს, ცვლადი, რომელიც ინახავს მცურავი პუნქტიანი ღირებულება,
ერთი ათობითი წერტილი.
>> მოდით მივანიჭოთ მას დაბრუნების ღირებულება მისაღებად float.
და მაშინ მოდით ცოტა არითმეტიკული ეს, პირველ გამოცხადების მეორე float
ე.წ. C განთავსების გრადუსი და მაღაზიის C შედეგად ზოგიერთი საერთო არითმეტიკული.
5.0 იყოფა 9.0 ჯერ F მინუს 32.0.
>> მოდით ახლა ბეჭდვა შედეგი ამ გამოთვლები.
პროცენტი f -
ფიქსირდება placeholder for მცურავი წერტილი ღირებულება -
მძიმე C ამობეჭდოთ ტემპერატურა აღწევს.
გადავარჩინოთ ჩემი საბოლოო.
კომპილირდება ერთად F to C. Run პროგრამა ერთად dot slash F to C.
>> და მოდით ცდილობენ იმ საერთო ტემპერატურა.
212 გრადუსი ფარენგეიტი არის 100 გრადუსი.
32 გრადუსი ფარენგეიტი არის 0 გრადუსი ცელსიუსით.
>> ახლა საშუალებას დახვეწა ამ პროგრამის პატარა ცოტა არ დაბეჭდვის საკმაოდ ბევრი 0 ნახვა
მას შემდეგ, რაც ათობითი ადგილი.
ამის გაკეთება, მე ვაპირებ დავუბრუნდეთ ხაზი 11.
და ვიდრე უბრალოდ მიუთითოთ პროცენტს f, მე ვაპირებ ნაცვლად დააკონკრეტა, ვთქვათ,
0.1 f, ინფორმირება ბეჭდვითი ვ რომ მე მხოლოდ გვინდა ბეჭდვა მცურავი პუნქტიანი ღირებულება
ერთ ღირებულება შემდეგ ათობითი ადგილი.
>> მოდით resave ჩემი პროგრამა.
Recompile იგი მიიღოს F to C. შემდეგ გამეორება იგი dot slash F to C. და
მოდით გაიმეორეთ, ვთქვათ, 212, რომელიც მაძლევს 100.0.
>> ახლა ეს აღსანიშნავია, რომ მე რაღაც ძალიან შეგნებულად ხაზი 9.
შეამჩნევთ, თუ როგორ დავწერე 5 5.0, 9 როგორც 9.0, და კიდევ 32 როგორც 32.0.
ისე, პირველი ორი იმ ღირებულებები იყო სრულიად შეგნებულად არჩეული უნდა იყოს
მცურავი პუნქტიანი ღირებულებებს, არა მხოლოდ იმიტომ, თანმიმდევრულობა დანარჩენი
ჩემი პროგრამა -
რომელიც აშკარად მოიცავს მცურავი წერტილი ღირებულებებს -
არამედ იმიტომ, რომ თურმე C, თუ თქვენ დაყოფის int სხვა int,
რის პასუხი თქვენ ვაპირებთ კიდევ არის თავად int, მაშინაც კი, თუ ეს ნიშნავს,
მქონე გადაყარეთ ყველაფერი მას შემდეგ, რაც ათობითი წერტილი.
>> სხვა სიტყვებით, თუ შევცვალო ამ 5.0 to 5 ან ამ 9.0 9 და შემდეგ resave
ჩემი პროგრამა, recompile ერთად მიიღოს F C, და შემდეგ ხელახლა გაუშვით dot slash F
to C და ტიპის შეყვანის მოსწონს 212, შეამჩნევთ, რომ პასუხი მე ვაპირებ
უნდა ამ დროს არის რეალურად საკმაოდ არასწორია.
0.0 არ არის სწორი ხარისხი აღწევს, როგორც 212 ფარენგეიტი.
>> ისე, რა ხდება?
ასევე, ხაზი 9, იმიტომ, რომ 5 არის რიცხვი და იმის გამო, 9 არის
რიცხვი, შედეგი მათემატიკურად უნდა იყოს 0,5555 და ასე შემდეგ.
არამედ იმიტომ, რომ შედეგი, რომლის მიხედვითაც C-ს წესებს, უნდა იყოს int, რომ
0,5555 იღებს დააგდეს დაშორებით, ტოვებს us მხოლოდ 0.
>> ასე რომ, საბოლოო ჯამში, მე დასრულდება მდე გამრავლებით სრულიად შემთხვევით 0 ჯერ f minus
32.0, რომელიც არ აქვს მნიშვნელობა რა ყოველთვის აპირებს მომეცი 0.
ასე რომ გვახსოვდეს, ნებისმიერ დროს გამოყენებით მცურავი პუნქტიანი ღირებულებების სიახლოვე
ints, თქვენ შეიძლება არ ემთხვეოდეს მიიღოს პასუხი, ასე რომ თქვენ ველით.
და ასე იზრუნოს გამოიყენოს, როგორც მე გააკეთა პირველ შემთხვევაში, მცურავი პუნქტიანი ღირებულებებს
მთელი, რათა თავიდან ავიცილოთ ისეთი საკითხები.