1
00:00:00,000 --> 00:00:02,360
>> დევიდ ჯ Malan: როგორც თქვენ ალბათ იცით,
ტემპერატურა იზომება გამოყენებით

2
00:00:02,360 --> 00:00:04,360
სხვადასხვა მასშტაბის სხვადასხვა
კუთხეში მსოფლიოში.

3
00:00:04,360 --> 00:00:09,370
მაგალითად, 212 გრადუსი ფარენგეიტი არის
100 გრადუსი და 32 გრადუსი

4
00:00:09,370 --> 00:00:11,810
Fahrenheit არის 0 გრადუსი.

5
00:00:11,810 --> 00:00:14,230
არ იქნება ლამაზი თუ ჩვენ გვქონდა კომპიუტერი
პროგრამა, რომელიც საშუალებას გვაძლევს

6
00:00:14,230 --> 00:00:16,950
კონვერტირება, მაგალითად, Fahrenheit
to გრადუსი?

7
00:00:16,950 --> 00:00:18,510
>> ისე, ჩვენ შეგვიძლია დავწეროთ, რომ პროგრამა.

8
00:00:18,510 --> 00:00:24,350
მოდით დავიწყოთ მოიცავს cs50.h,
ასე რომ ჩვენ შეგვიძლია გამოვიყენოთ ფუნქცია მოუწოდა

9
00:00:24,350 --> 00:00:28,610
მიიღეთ float, რომელიც, ისევე როგორც კიდევ int, იღებს
ნომრის შესახებ, მაგრამ ამ დროს

10
00:00:28,610 --> 00:00:31,440
მცურავი პუნქტიანი ნომერი ერთ - ერთი
ერთად ათობითი წერტილი.

11
00:00:31,440 --> 00:00:34,840
>> მოდით ასევე მოიცავს სტანდარტული io.h
ასე რომ ჩვენ გვაქვს წვდომა

12
00:00:34,840 --> 00:00:36,230
ფუნქციები, როგორიცაა ბეჭდვითი ვ.

13
00:00:36,230 --> 00:00:40,000
და მოდით ასევე ვაცხადებ მთავარი
ჩვეულ რეჟიმში.

14
00:00:40,000 --> 00:00:42,675
>> მოდით მომდევნო შეეკითხება მომხმარებელს ამისთვის
ტემპერატურა Fahrenheit.

15
00:00:42,675 --> 00:00:46,050

16
00:00:46,050 --> 00:00:49,220
მოდით ახლა რეალურად მიიღონ, რომ ტემპერატურის
საწყისი მომხმარებელი, პირველი

17
00:00:49,220 --> 00:00:52,910
გამოცხადების ცვლადში
f ტიპის float.

18
00:00:52,910 --> 00:00:56,750
Float, კიდევ ერთხელ, რაც იმას ნიშნავს, ცვლადი, რომელიც
ინახავს მცურავი პუნქტიანი ღირებულება,

19
00:00:56,750 --> 00:00:58,200
ერთი ათობითი წერტილი.

20
00:00:58,200 --> 00:01:01,780
>> მოდით მივანიჭოთ მას დაბრუნების
ღირებულება მისაღებად float.

21
00:01:01,780 --> 00:01:06,080
და მაშინ მოდით ცოტა არითმეტიკული
ეს, პირველ გამოცხადების მეორე float

22
00:01:06,080 --> 00:01:11,690
ე.წ. C განთავსების გრადუსი და მაღაზიის C
შედეგად ზოგიერთი საერთო არითმეტიკული.

23
00:01:11,690 --> 00:01:19,060
5.0 იყოფა 9.0 ჯერ F მინუს 32.0.

24
00:01:19,060 --> 00:01:23,440
>> მოდით ახლა ბეჭდვა შედეგი
ამ გამოთვლები.

25
00:01:23,440 --> 00:01:24,730
პროცენტი f -

26
00:01:24,730 --> 00:01:27,890
ფიქსირდება placeholder for
მცურავი წერტილი ღირებულება -

27
00:01:27,890 --> 00:01:31,680
მძიმე C ამობეჭდოთ
ტემპერატურა აღწევს.

28
00:01:31,680 --> 00:01:33,000
გადავარჩინოთ ჩემი საბოლოო.

29
00:01:33,000 --> 00:01:38,220
კომპილირდება ერთად F to C. Run პროგრამა
ერთად dot slash F to C.

30
00:01:38,220 --> 00:01:39,940
>> და მოდით ცდილობენ იმ საერთო
ტემპერატურა.

31
00:01:39,940 --> 00:01:45,820
212 გრადუსი ფარენგეიტი
არის 100 გრადუსი.

32
00:01:45,820 --> 00:01:50,090
32 გრადუსი ფარენგეიტი არის
0 გრადუსი ცელსიუსით.

33
00:01:50,090 --> 00:01:54,240
>> ახლა საშუალებას დახვეწა ამ პროგრამის პატარა
ცოტა არ დაბეჭდვის საკმაოდ ბევრი 0 ნახვა

34
00:01:54,240 --> 00:01:55,820
მას შემდეგ, რაც ათობითი ადგილი.

35
00:01:55,820 --> 00:01:57,940
ამის გაკეთება, მე ვაპირებ
დავუბრუნდეთ ხაზი 11.

36
00:01:57,940 --> 00:02:03,430
და ვიდრე უბრალოდ მიუთითოთ პროცენტს f,
მე ვაპირებ ნაცვლად დააკონკრეტა, ვთქვათ,

37
00:02:03,430 --> 00:02:08,800
0.1 f, ინფორმირება ბეჭდვითი ვ რომ მე მხოლოდ
გვინდა ბეჭდვა მცურავი პუნქტიანი ღირებულება

38
00:02:08,800 --> 00:02:11,750
ერთ ღირებულება შემდეგ ათობითი ადგილი.

39
00:02:11,750 --> 00:02:13,630
>> მოდით resave ჩემი პროგრამა.

40
00:02:13,630 --> 00:02:19,680
Recompile იგი მიიღოს F to C. შემდეგ
გამეორება იგი dot slash F to C. და

41
00:02:19,680 --> 00:02:24,910
მოდით გაიმეორეთ, ვთქვათ, 212,
რომელიც მაძლევს 100.0.

42
00:02:24,910 --> 00:02:28,360
>> ახლა ეს აღსანიშნავია, რომ მე
რაღაც ძალიან შეგნებულად ხაზი 9.

43
00:02:28,360 --> 00:02:35,830
შეამჩნევთ, თუ როგორ დავწერე 5 5.0, 9
როგორც 9.0, და კიდევ 32 როგორც 32.0.

44
00:02:35,830 --> 00:02:39,000
ისე, პირველი ორი იმ ღირებულებები იყო
სრულიად შეგნებულად არჩეული უნდა იყოს

45
00:02:39,000 --> 00:02:42,200
მცურავი პუნქტიანი ღირებულებებს, არა მხოლოდ იმიტომ,
თანმიმდევრულობა დანარჩენი

46
00:02:42,200 --> 00:02:42,940
ჩემი პროგრამა -

47
00:02:42,940 --> 00:02:45,110
რომელიც აშკარად მოიცავს მცურავი
წერტილი ღირებულებებს -

48
00:02:45,110 --> 00:02:50,210
არამედ იმიტომ, რომ თურმე C, თუ თქვენ
დაყოფის int სხვა int,

49
00:02:50,210 --> 00:02:54,350
რის პასუხი თქვენ ვაპირებთ კიდევ არის
თავად int, მაშინაც კი, თუ ეს ნიშნავს,

50
00:02:54,350 --> 00:02:57,450
მქონე გადაყარეთ ყველაფერი
მას შემდეგ, რაც ათობითი წერტილი.

51
00:02:57,450 --> 00:03:04,990
>> სხვა სიტყვებით, თუ შევცვალო ამ 5.0 to
5 ან ამ 9.0 9 და შემდეგ resave

52
00:03:04,990 --> 00:03:10,550
ჩემი პროგრამა, recompile ერთად მიიღოს F C,
და შემდეგ ხელახლა გაუშვით dot slash F

53
00:03:10,550 --> 00:03:15,310
to C და ტიპის შეყვანის მოსწონს 212,
შეამჩნევთ, რომ პასუხი მე ვაპირებ

54
00:03:15,310 --> 00:03:17,860
უნდა ამ დროს არის რეალურად საკმაოდ არასწორია.

55
00:03:17,860 --> 00:03:23,570
0.0 არ არის სწორი ხარისხი
აღწევს, როგორც 212 ფარენგეიტი.

56
00:03:23,570 --> 00:03:24,500
>> ისე, რა ხდება?

57
00:03:24,500 --> 00:03:29,410
ასევე, ხაზი 9, იმიტომ, რომ 5 არის
რიცხვი და იმის გამო, 9 არის

58
00:03:29,410 --> 00:03:34,810
რიცხვი, შედეგი მათემატიკურად
უნდა იყოს 0,5555 და ასე შემდეგ.

59
00:03:34,810 --> 00:03:39,120
არამედ იმიტომ, რომ შედეგი, რომლის მიხედვითაც
C-ს წესებს, უნდა იყოს int, რომ

60
00:03:39,120 --> 00:03:44,020
0,5555 იღებს დააგდეს დაშორებით,
ტოვებს us მხოლოდ 0.

61
00:03:44,020 --> 00:03:48,600
>> ასე რომ, საბოლოო ჯამში, მე დასრულდება მდე გამრავლებით
სრულიად შემთხვევით 0 ჯერ f minus

62
00:03:48,600 --> 00:03:52,830
32.0, რომელიც არ აქვს მნიშვნელობა რა
ყოველთვის აპირებს მომეცი 0.

63
00:03:52,830 --> 00:03:56,930
ასე რომ გვახსოვდეს, ნებისმიერ დროს გამოყენებით
მცურავი პუნქტიანი ღირებულებების სიახლოვე

64
00:03:56,930 --> 00:03:59,860
ints, თქვენ შეიძლება არ ემთხვეოდეს
მიიღოს პასუხი, ასე რომ თქვენ ველით.

65
00:03:59,860 --> 00:04:04,220
და ასე იზრუნოს გამოიყენოს, როგორც მე გააკეთა
პირველ შემთხვევაში, მცურავი პუნქტიანი ღირებულებებს

66
00:04:04,220 --> 00:04:06,530
მთელი, რათა თავიდან ავიცილოთ ისეთი საკითხები.

67
00:04:06,530 --> 00:04:08,267