1
00:00:00,000 --> 00:00:02,395
>> [సంగీతాన్ని]

2
00:00:02,395 --> 00:00:05,750

3
00:00:05,750 --> 00:00:06,506
>> డౌ LLOYD: OK.

4
00:00:06,506 --> 00:00:08,880
మనం పూర్ణాంకం పనిచేసిన,
మేము పాత్రలతో పనిచేసిన,

5
00:00:08,880 --> 00:00:11,930
మేము తేలియాడుతున్న పనిచేసిన,
డబుల్స్, తీగలు మరియు bools.

6
00:00:11,930 --> 00:00:14,870
మేము చాలా అన్ని అందంగా అయిపోయిన చేసిన
[వినబడని] రకాల ఆ

7
00:00:14,870 --> 00:00:17,100
అన్ని పాటు మాకు అందుబాటులో ఉన్నాయి.

8
00:00:17,100 --> 00:00:19,430
కానీ ఇప్పుడు మేము మరింత ఏదో చేయాలనుకుంటున్నారా.

9
00:00:19,430 --> 00:00:20,210
మేము ఎలా చెయ్యాలి?

10
00:00:20,210 --> 00:00:22,560
ఎలా మేము వివిధ రకాల డేటా సృష్టించాలి?

11
00:00:22,560 --> 00:00:26,130
మేము నిర్మాణాలు ఉపయోగించి ద్వారా చేయవచ్చు.

12
00:00:26,130 --> 00:00:30,180
కాబట్టి నిర్మాణాలు మాకు ఏకం చేయడానికి అనుమతిస్తుంది
వివిధ రకాల వేరియబుల్స్

13
00:00:30,180 --> 00:00:34,810
ఒక సింగిల్, కొత్త వేరియబుల్ రకం,
ఇది మేము దాని సొంత రకం పేరు కేటాయించవచ్చు.

14
00:00:34,810 --> 00:00:37,570
ఈ ఒక నిజంగా బలమైన
విషయం, చేస్తామని ఉండాలి

15
00:00:37,570 --> 00:00:40,900
మేము సమూహం ఇప్పుడు ఎందుకంటే
వివిధ రకాల డేటా అంశాలతో

16
00:00:40,900 --> 00:00:43,910
కలిసి ఒక తార్కిక సంబంధం ఉందని.

17
00:00:43,910 --> 00:00:46,440
మేము దీన్ని చేయగలిగారు చేసిన
విధమైన శ్రేణితో, కుడి?

18
00:00:46,440 --> 00:00:49,540
మేము సమూహాన్ని చేయవచ్చు వేరియబుల్స్
అదే డేటా రకం

19
00:00:49,540 --> 00:00:53,410
కలిసి ఒక పెద్ద యూనిట్ లో
జ్ఞాపకశక్తి, ఒక శ్రేణి యొక్క.

20
00:00:53,410 --> 00:00:56,660
>> కానీ మేము కలపాలి లేకపోతున్నాను
కలిసి వివిధ రకాల డేటా.

21
00:00:56,660 --> 00:01:02,610
మేము ఒక పూర్ణాంకం జత చెప్పలేను
మరియు ఒక పాత్ర, మరియు ఒక డబుల్ అన్ని

22
00:01:02,610 --> 00:01:05,330
అదే విషయం మరియు
ఒకే యూనిట్ ఆ కాల్.

23
00:01:05,330 --> 00:01:08,830
కానీ నిర్మాణాలు, లేదా
తరచుగా, structs గా సూచిస్తారు

24
00:01:08,830 --> 00:01:09,585
మేము నిజానికి చెయ్యవచ్చు.

25
00:01:09,585 --> 00:01:12,370
సో ఒక నిర్మాణం విధమైన ఉంది
ఒక సూపర్ వేరియబుల్ వంటి.

26
00:01:12,370 --> 00:01:16,530
కల్గి ఉంటుంది వేరియబుల్
అది లోపలి ఇతర వేరియబుల్స్.

27
00:01:16,530 --> 00:01:19,650
ఇక్కడ ఒక ఉదాహరణ ఉంది
చాలా సాధారణ నిర్మాణం.

28
00:01:19,650 --> 00:01:23,380
ఈ వాక్యనిర్మాణం చూస్తారు ఏమిటి
ఒక కారు కోసం ఒక నిర్మాణాన్ని సృష్టించేందుకు ఇష్టం.

29
00:01:23,380 --> 00:01:25,250
ఇప్పుడు, యొక్క ఇక్కడ వాక్యనిర్మాణం ద్వారా వీడలేదు.

30
00:01:25,250 --> 00:01:27,400
Struct, ఆ
సూచిస్తుంది కీవర్డ్

31
00:01:27,400 --> 00:01:30,270
నేను ఇక్కడ ఒక కొత్త రకం డేటా సృష్టించడం నేను ఆ.

32
00:01:30,270 --> 00:01:33,860
ముఖ్యంగా, డేటా రకం పేరు
మేము చూస్తారు వంటి, struct కారు ఉండదని.

33
00:01:33,860 --> 00:01:36,640
కానీ ఈ చిట్కా యొక్క విధమైన ఉంది
కంపైలర్ ఆఫ్ ఈ

34
00:01:36,640 --> 00:01:42,440
వేరియబుల్స్ యొక్క ఒక సమూహం వలె ఆ అన్నారు
అదే రకం భాగంగా పరిగణించేందుకు

35
00:01:42,440 --> 00:01:44,010
ఒక నిమిషం లో.

36
00:01:44,010 --> 00:01:46,340
>> కార్లు, నిర్మాణం కేవలం పేరు.

37
00:01:46,340 --> 00:01:50,590
మళ్ళీ, ఇక్కడ డేటా రకం అన్నారు
struct కారు, కేవలం కారు ఉండాలి.

38
00:01:50,590 --> 00:01:53,060
కానీ మీరు విభిన్నమైనది కలిగి ఉంటే
మీరు బహుళ structs సృష్టిస్తే

39
00:01:53,060 --> 00:01:56,950
అదే కార్యక్రమంలో, మీరు అవసరం
struct మరియు struct మధ్య భేదాన్ని మాత్రమే సూచిస్తాయి.

40
00:01:56,950 --> 00:02:00,140
కాబట్టి struct కారు, నేను కూడా కలిగి ఉండవచ్చు
struct విద్యార్థి, ఉదాహరణకు,

41
00:02:00,140 --> 00:02:01,790
అదే కార్యక్రమంలో.

42
00:02:01,790 --> 00:02:05,980
గిరజాల జంట కలుపులు లోపల
అని పిలవబడే అన్ని రంగాల్లో

43
00:02:05,980 --> 00:02:07,954
లేదా నిర్మాణం యొక్క సభ్యులు.

44
00:02:07,954 --> 00:02:10,370
కాబట్టి విషయాలు కొన్ని ఏమిటి
ఒక కారు స్వతస్సిద్ధంగా ఉంటుంది?

45
00:02:10,370 --> 00:02:15,270
సరే, సాధారణంగా ఒక సంవత్సరం ఉంది పిల్లలు
ఒక మోడల్ పేరు, మరియు లైసెన్స్ ప్లేట్,

46
00:02:15,270 --> 00:02:18,000
సాధారణంగా చేసే ఓడోమీటార్
అది మైళ్ళ కొన్ని సంఖ్య,

47
00:02:18,000 --> 00:02:19,225
మరియు ఉండవచ్చు ఒక ఇంజిన్ పరిమాణం.

48
00:02:19,225 --> 00:02:23,570
మీరు చూడగలరు గా, నేను అప్ మిక్సింగ్ చేస్తున్నాను
పూర్ణాంకాల మరియు అక్షరాలు మరియు డబుల్స్.

49
00:02:23,570 --> 00:02:26,420
వారు అన్ని చేయబోతున్నామని
ఈ కొత్త డేటా రకం భాగంగా.

50
00:02:26,420 --> 00:02:29,750
>> చివరగా, ఆఖరి విషయం నేను చెయ్యాల్సిన,
ఈ చిన్న సెమికోలన్ మర్చిపోతే లేదు

51
00:02:29,750 --> 00:02:30,290
చివరలో.

52
00:02:30,290 --> 00:02:34,380
మేము నిర్మాణం నిర్వచించు పూర్తిచేసిన తర్వాత,
మేము చివరిలో సెమికోలన్ ఉంచాలి.

53
00:02:34,380 --> 00:02:37,325
ఇది చాలా సాధారణ వాక్యనిర్మాణ వార్తలు
తప్పు, ఒక ఫంక్షన్ తో ఎందుకంటే,

54
00:02:37,325 --> 00:02:40,200
ఉదాహరణకు, మీరు కేవలం వుంటుంది
బహిరంగ వంకర జంట కలుపు, దగ్గరగా వంకర కలుపు.

55
00:02:40,200 --> 00:02:42,950
మీరు ఒక సెమికోలన్ చాలు లేదు
ఒక ఫంక్షన్ నిర్వచనం ముగింపు.

56
00:02:42,950 --> 00:02:46,430
ఈ ఒక ఫంక్షన్ ఎలా
నిర్వచనం, కానీ అది కాదు,

57
00:02:46,430 --> 00:02:49,653
అందువలన సెమికోలన్ ఉంది
కేవలం ఒక రిమైండర్ అని మీరు

58
00:02:49,653 --> 00:02:52,440
ఎందుకంటే, అక్కడ అది ఉంచాలి
కంపైలర్ లేకపోతే రెడీ

59
00:02:52,440 --> 00:02:53,510
దానితో ఏమి తెలుసు.

60
00:02:53,510 --> 00:02:56,160
ఇది చాలా సాధారణ లోపం
అనుకోకుండా చేయడానికి

61
00:02:56,160 --> 00:02:58,570
మీరు మొదటి నిర్మాణాలు నిర్వచించు చేస్తున్నారు.

62
00:02:58,570 --> 00:02:59,500
>> అలాగే.

63
00:02:59,500 --> 00:03:02,824
కాబట్టి మేము సాధారణంగా మా నిర్మాణాలు నిర్వచించే
మా కార్యక్రమాలు అగ్రభాగాన

64
00:03:02,824 --> 00:03:05,490
వారు బహుశా చూడాలని ఎందుకంటే
బహుళ విధులను ఉపయోగించుకోకుండా.

65
00:03:05,490 --> 00:03:08,850
మేము ఒక నిర్వచించే వద్దు
ఒక ఫంక్షన్ యొక్క లోపల struct,

66
00:03:08,850 --> 00:03:12,110
అప్పుడు మేము only-- ఎందుకంటే
నిర్మాణం యొక్క పరిధిని నిజంగా

67
00:03:12,110 --> 00:03:13,790
మాత్రమే ఆ ఫంక్షన్ యొక్క లోపల ఉంది.

68
00:03:13,790 --> 00:03:17,450
మేము బహుశా ఒక నిర్మాణం నిర్వచించడానికి కావలసిన
కాబట్టి మేము బహుళ విధులను లో ఉపయోగించవచ్చు,

69
00:03:17,450 --> 00:03:20,670
లేదా బహుశా బహుళ లో
కలిసి ముడిపడిన ఫైళ్లు

70
00:03:20,670 --> 00:03:22,920
మా సింగిల్ కార్యక్రమం సృష్టించడానికి.

71
00:03:22,920 --> 00:03:24,920
కొన్నిసార్లు కూడా బదులుగా
నిర్మాణం నిర్వచించు

72
00:03:24,920 --> 00:03:27,961
మీరు నెలకొల్పాడు అగ్రభాగాన మీ
పౌండ్ కలిగి మరియు మీ పౌండ్ నిర్వచిస్తుంది

73
00:03:27,961 --> 00:03:32,080
ఉదాహరణకు, మీరు వాటిని పెట్టి ఉండవచ్చు
ప్రత్యేక డాట్ h ఫైళ్లు, అప్పుడు మీరు

74
00:03:32,080 --> 00:03:35,020
పౌండ్ మీరే ఉన్నాయి.

75
00:03:35,020 --> 00:03:37,620
>> కాబట్టి మేము నిర్మాణాలు కలిగి, కానీ ఇప్పుడు
మేము వాటిని లోపల పొందాలి.

76
00:03:37,620 --> 00:03:39,800
ఎలా మేము లోపలి వస్తుందా
ప్రాప్తి ఒక నిర్మాణం

77
00:03:39,800 --> 00:03:43,530
ఆ ఉప వేరియబుల్స్, ఆ వేరియబుల్స్
ఆ నిర్మాణం లోపల ఉనికిలో?

78
00:03:43,530 --> 00:03:46,810
Well, మేము అనే ఉంది
మాకు అనుమతిస్తుంది డాట్ ఆపరేటర్లు

79
00:03:46,810 --> 00:03:50,990
నిర్మాణం రంగాలలో యాక్సెస్.

80
00:03:50,990 --> 00:03:55,490
ఉదాహరణకు, యొక్క నేను డిక్లేర్డ్ చేసిన చెప్పటానికి వీలు
నా నిర్మాణం డేటా ఎక్కడో టైప్

81
00:03:55,490 --> 00:03:59,020
నా ప్రోగ్రామ్ యొక్క పైభాగంలో, లేదా బహుశా
నేను పౌండ్ చేసిన ఒక డాట్ h ఫైలు ఉన్నాయి.

82
00:03:59,020 --> 00:04:03,360
నేను అప్పుడు ఒక కొత్త సృష్టించడానికి కావాలా
డేటా రకం వేరియబుల్, నేను చెప్పగలను

83
00:04:03,360 --> 00:04:06,260
struct కారు, నా కారు, సెమికోలన్.

84
00:04:06,260 --> 00:04:11,580
నేను Int చెప్పగల్గినవి జస్ట్ వంటి
x, లేదా స్ట్రింగ్ సెమికోలన్ పేరు.

85
00:04:11,580 --> 00:04:18,100
>> ఇక్కడ డేటా రకం, struct కారు
వేరియబుల్ పేరు, నా కారు

86
00:04:18,100 --> 00:04:23,770
ఆపై నేను డాట్ ఆపరేటర్లు ఉపయోగించవచ్చు
నా కారు వివిధ రంగాల్లో యాక్సెస్.

87
00:04:23,770 --> 00:04:27,494
నేను నా కారు చెప్పగలను
డాట్ సంవత్సరం 2011 సమానం.

88
00:04:27,494 --> 00:04:28,410
ఆ సంపూర్ణ మంచిది.

89
00:04:28,410 --> 00:04:34,210
మీరు గుర్తు ఉంటే ఇయర్, ఒక నిర్వచించారు
ఈ struct కారు లోపలి పూర్ణాంక రంగంలో

90
00:04:34,210 --> 00:04:35,200
డేటా రకం.

91
00:04:35,200 --> 00:04:39,966
Struct కారు డేటా కాబట్టి ఏ వేరియబుల్
రకం, అటువంటి నా కారు, నేను నా కారు చెప్పగలను

92
00:04:39,966 --> 00:04:44,030
డాట్ సంవత్సరం సమానం ఆపై కేటాయించి
అది కొన్ని పూర్ణ సంఖ్య విలువ, 2011.

93
00:04:44,030 --> 00:04:47,290
నా కారు డాట్ ప్లేట్ CS50 సమానం.

94
00:04:47,290 --> 00:04:51,180
నా కార్డ్ డాట్ ఓడోమీటార్
50505 సెమికోలన్ సమానం.

95
00:04:51,180 --> 00:04:53,270
ఆ అన్ని ఉన్నాయి
సంపూర్ణ జరిమానా మరియు ఆ

96
00:04:53,270 --> 00:04:57,802
మేము యాక్సెస్ ఎలా
నిర్మాణం యొక్క ఖాళీలను.

97
00:04:57,802 --> 00:05:00,260
స్ట్రక్చర్స్, అయితే, అవసరం లేదు
స్టాక్ రూపొందించినవారు ఉంటుంది.

98
00:05:00,260 --> 00:05:02,950
జస్ట్ మేము ఏ ఇతర వేరియబుల్ ఇష్టం
డైనమిక్ వాటిని కేటాయించాలని.

99
00:05:02,950 --> 00:05:06,309
మేము ఒక కార్యక్రమం కలిగి ఉంటే గనక
అనేక నిర్మాణాలు ఉత్పత్తి చేయబడుతుంది,

100
00:05:06,309 --> 00:05:08,100
మేము ఎన్ని తెలియదు
మేము అవసరం చూడాలని

101
00:05:08,100 --> 00:05:10,800
అప్పుడు మేము డైనమిక్ అవసరం
ఆ నిర్మాణాలు కేటాయించాలని

102
00:05:10,800 --> 00:05:12,960
మా కార్యక్రమం వంటి నడుస్తుంటే.

103
00:05:12,960 --> 00:05:16,600
మరియు మేము ప్రాప్తి చూడాలని కనుక
ఆ సందర్భంలో ఒక నిర్మాణం యొక్క ఖాళీలను,

104
00:05:16,600 --> 00:05:20,660
మేము మొదటి dereference అవసరమైన రీకాల్
నిర్మాణం ఒక పాయింటర్ గా

105
00:05:20,660 --> 00:05:24,810
ఆపై మేము ఒకసారి dereference
పాయింటర్, అప్పుడు మేము ఖాళీలను యాక్సెస్ చేయవచ్చు.

106
00:05:24,810 --> 00:05:26,830
మేము ఒక కలిగి ఉంటే
నిర్మాణం గణితానికి,

107
00:05:26,830 --> 00:05:32,120
మేము కేవలం పాయింటర్ డాట్ రంగంలో చెప్పలేను
పేరు మరియు మేము చూస్తున్న ఏమి పొందండి.

108
00:05:32,120 --> 00:05:34,259
Dereferencing యొక్క అదనపు దశల ఉంది.

109
00:05:34,259 --> 00:05:36,050
కాబట్టి యొక్క అని పిలవబడు
బదులుగా previous-- యొక్క

110
00:05:36,050 --> 00:05:38,770
కేవలం మునుపటి ఉదాహరణకు వంటి,
బదులుగా దీన్ని ప్రకటించే

111
00:05:38,770 --> 00:05:43,680
స్టాక్, struct కారు, నా
కారు, సెమికోలన్, నేను, struct కారు చెప్పే

112
00:05:43,680 --> 00:05:48,020
స్టార్, ఒక ఒక పాయింటర్
struct కారు, నా కారు అని

113
00:05:48,020 --> 00:05:51,250
struct కారు malloc పరిమాణం సమానం.

114
00:05:51,250 --> 00:05:54,950
ఎన్ని మేము యొక్క పరిమాణం కనిపెడతాడు
మీ కొత్త డేటా రకం తీసుకుంటుంది బైట్లు.

115
00:05:54,950 --> 00:05:58,570
మీరు తప్పనిసరిగా మాత్రమే ఉపయోగించడానికి అవసరం లేదు
వెడల్పు Int, లేదా చార్, లేదా ఏ యొక్క పరిమాణం

116
00:05:58,570 --> 00:05:59,715
అంతర్నిర్మిత డేటా రకాల.

117
00:05:59,715 --> 00:06:02,090
కంపైలర్ తగినంత స్మార్ట్ ఉంది
ఎన్ని బైట్లు దొరుకుతుందని

118
00:06:02,090 --> 00:06:04,170
మీ కొత్త నిర్మాణం అవసరం.

119
00:06:04,170 --> 00:06:09,610
ఐతే నేను మెమరీ యూనిట్ malloc
ఒక struct కారు కలిగి తగినంత పెద్ద,

120
00:06:09,610 --> 00:06:12,410
మరియు నేను తిరిగి పాయింటర్ పొందుటకు
మెమరీ ఆ బ్లాక్,

121
00:06:12,410 --> 00:06:16,090
మరియు ఆ పాయింటర్ నా కారు కేటాయించిన.

122
00:06:16,090 --> 00:06:18,050
>> ఇప్పుడు, నేను యాక్సెస్ అనుకుంటే
నా కారు రంగాలలో,

123
00:06:18,050 --> 00:06:22,615
నేను మొదటి నా కారు dereference ఉపయోగించి
dereference ఆపరేటర్లు, నక్షత్రం

124
00:06:22,615 --> 00:06:26,620
మేము గమనికలు నుండి చూసిన
వీడియోలు, మరియు అప్పుడు నేను dereference తర్వాత,

125
00:06:26,620 --> 00:06:32,200
అప్పుడు నేను డాట్ ఆపరేటర్లు ఉపయోగించవచ్చు
నా కారు వివిధ రంగాల్లో యాక్సెస్.

126
00:06:32,200 --> 00:06:35,490
సంవత్సరం 2011 సమానం డాట్ నా కారు స్టార్.

127
00:06:35,490 --> 00:06:38,480
ఆ ప్రభావం వుంటుంది
మేము ఈ సందర్భంలో కావాలి,

128
00:06:38,480 --> 00:06:41,960
మేము డైనమిక్ చేసిన ఎందుకంటే
నా కారు కేటాయించింది.

129
00:06:41,960 --> 00:06:43,610
>> కుడివైపు, అయితే, రకమైన బాధించే ఉంది?

130
00:06:43,610 --> 00:06:44,818
ఇప్పుడు ఒక 2-దశల ప్రక్రియ ఉంది.

131
00:06:44,818 --> 00:06:47,460
ఇప్పుడు మేము dereference-- కలిగి
మేము ఒక స్టార్ ఆపరేటర్లు కలిగి,

132
00:06:47,460 --> 00:06:48,910
మరియు మేము ఒక డాట్ ఆపరేటర్లు కలిగి.

133
00:06:48,910 --> 00:06:51,660
మరియు మీరు ఆశించవచ్చు వంటి, ఎందుకంటే
సి ప్రోగ్రామర్లు తక్కువ మార్గాల్లో ప్రేమ

134
00:06:51,660 --> 00:06:53,740
పనులను, ఒక ఉంది
తక్కువ మార్గం దీన్ని.

135
00:06:53,740 --> 00:06:57,790
బాణం అని మరొక ఆపరేటర్లు ఉంది,
ఈ ప్రక్రియ చాలా సులభం.

136
00:06:57,790 --> 00:07:00,750
బాణం పనిచేస్తుంది మార్గం
అది మొదటి dereferences

137
00:07:00,750 --> 00:07:03,560
ఎడమ పాయింటర్
ఆపరేటర్లు వైపు,

138
00:07:03,560 --> 00:07:06,620
ఆపై, తర్వాత dereferenced మమేకమయ్యారు
ఎడమ పాయింటర్,

139
00:07:06,620 --> 00:07:09,620
అది కుడి రంగంలో యాక్సెస్.

140
00:07:09,620 --> 00:07:14,170
కాబట్టి గతంలో మేము ఈ విధమైన వచ్చింది
నా కారు, ఈ విషయాన్ని డాట్ స్టార్

141
00:07:14,170 --> 00:07:15,880
అక్కడ జరగబోతోంది చాలా ఉంది.

142
00:07:15,880 --> 00:07:22,040
కానీ మనం దానికి బదులుగా చేయవచ్చు దీన్ని ఉంది
నా కారు బాణం సంవత్సరం 2011 సమానం.

143
00:07:22,040 --> 00:07:23,580
>> మళ్ళీ, ఇక్కడ ఏమి జరుగుతున్నది?

144
00:07:23,580 --> 00:07:25,720
మొదటి, నేను నా కారు dereferencing చేస్తున్నాను.

145
00:07:25,720 --> 00:07:27,810
ఇది మళ్ళీ, ఇక్కడ ఒక పాయింటర్ ఉంది.

146
00:07:27,810 --> 00:07:31,270
అప్పుడు, తరువాత సంభవించిన
నేను నా కారు dereferenced

147
00:07:31,270 --> 00:07:35,130
అప్పుడు ఖాళీలను యాక్సెస్ చేయవచ్చు
సంవత్సరం, పళ్ళాలు మరియు ఓడోమీటార్

148
00:07:35,130 --> 00:07:40,020
కేవలం నేను అనుకొనుట గా మొదటి కలిగి ముందు
నా కారు, dereference ఉపయోగించే స్టార్,

149
00:07:40,020 --> 00:07:42,020
మరియు రంగంలో యాక్సెస్ కలదు.

150
00:07:42,020 --> 00:07:45,290
సో మీరు, నిర్మాణాలు కలిగి
నిర్మాణాలు గమనికలు కలిగి ఉంటాయి,

151
00:07:45,290 --> 00:07:48,360
మరియు మీరు ఆక్సెస్ మార్గాలను కలిగి
ఆ నిర్మాణాలు ఖాళీలను,

152
00:07:48,360 --> 00:07:52,600
మీరు గమనికలు ఉందా అని
వాటిని లేదా చరరాశులు తాము.

153
00:07:52,600 --> 00:07:57,640
డాట్ లేదా బాణం, బట్టి
వేరియబుల్ ఎలా ప్రకటించబడింది.

154
00:07:57,640 --> 00:08:00,510
నేను డౌ లాయిడ్ ఉన్నాను, ఈ CS50 ఉంది.

155
00:08:00,510 --> 00:08:01,975