1
00:00:00,000 --> 00:00:04,970

2
00:00:04,970 --> 00:00:07,220
డౌ LLOYD: మీరు చేసిన ఉంటే
నిర్మాణాల మీద మా వీడియో చూసిన,

3
00:00:07,220 --> 00:00:10,950
మీరు ఇప్పటికే మేము కలిగి తెలుసు
మా స్వంత డేటా రకాలను విశదీకరిస్తాయి సామర్థ్యం.

4
00:00:10,950 --> 00:00:14,530
మీరు ఉపయోగించిన నిర్మాణాలు చేసిన ఉంటే కానీ, మీకు తెలిసిన
కొన్నిసార్లు ఆ డేటా రకాల ఉపయోగించి

5
00:00:14,530 --> 00:00:16,446
నిజానికి కొద్దిగా ఉంటుంది
గజిబిజిగా మేము ఎందుకంటే

6
00:00:16,446 --> 00:00:19,210
struct కీవర్డ్ ఉపయోగించాలి
మేము them-- పని చేసినప్పుడు

7
00:00:19,210 --> 00:00:21,257
struct కారు లేదా struct విద్యార్థి.

8
00:00:21,257 --> 00:00:23,090
ఆ టైప్ చాలా వార్తలు
మేము కేవలం కలిగి అనుకుంటే

9
00:00:23,090 --> 00:00:24,830
ఒక నిర్మాణం వంటి సాధారణ ఏదో.

10
00:00:24,830 --> 00:00:26,390
మేము కావలసిన మనం కావలసిన
విషయాలు పని చేయగలరు

11
00:00:26,390 --> 00:00:29,350
కొంచెం సంక్షిప్తలిపి మార్గం,
పూర్ణాంకానికి లేదా చార్, ఏదో చాలా వంటి

12
00:00:29,350 --> 00:00:31,240
టైప్ మరింత సౌకర్యవంతంగా ఉంటుంది.

13
00:00:31,240 --> 00:00:33,100
>> అదృష్టవశాత్తూ, అక్కడ
ఒక విధంగా, C లో దీన్ని

14
00:00:33,100 --> 00:00:37,150
ఇది typedef అని ఏదో తో
ఒక విధంగా సంక్షిప్తలిపి సృష్టించడానికి లేదా తిరగరాశాడు కు

15
00:00:37,150 --> 00:00:38,640
డేటా రకాల పేర్లు.

16
00:00:38,640 --> 00:00:40,720
మీరు డేటా తిరగరాసే
ఇప్పటికే ఉనికిలో రకాల

17
00:00:40,720 --> 00:00:43,970
లేదా మీరు మీ సొంత డేటా రకాల వ్రాయగలవు.

18
00:00:43,970 --> 00:00:46,890
>> మీరు మొదటి విషయం మీరు
సాధారణ విధంగా ఒక రకం నిర్వచించే,

19
00:00:46,890 --> 00:00:52,271
ఆపై మీరు కేవలం ఏదో దానిని అలియాస్
typedef పాత పేరు కొత్త పేరు else--.

20
00:00:52,271 --> 00:00:53,520
ప్రెట్టీ సూటిగా, కుడి?

21
00:00:53,520 --> 00:00:56,240
కాబట్టి మేము, ఉదాహరణకు typedef కాలేదు,
అప్పటికే డేటా

22
00:00:56,240 --> 00:01:00,266
బైట్ సైన్ చేయని చార్ యొక్క రకం.

23
00:01:00,266 --> 00:01:03,140
ఆపై, ఇప్పటి నుండి మేము చేసిన తర్వాత
ఈ రకం మళ్ళీ definition-- చేసిన,

24
00:01:03,140 --> 00:01:07,570
సాధారణంగా ఎగువన అవతరిస్తుంది ఇది
మా డాట్ సి ఫైళ్లు, లేదా ఒక డాట్ H ఫైలు లో

25
00:01:07,570 --> 00:01:10,590
విడిగా, మేము కేవలం
ప్రతిచోటా కాటు ఉపయోగించడానికి

26
00:01:10,590 --> 00:01:12,180
మేము సైన్ చేయని చార్ ఉపయోగిస్తారు ఉండేది.

27
00:01:12,180 --> 00:01:14,300
ఆ టైప్ చాలా తక్కువ ఉంది.

28
00:01:14,300 --> 00:01:19,280
>> CS50 యొక్క లైబ్రరీ, మేము దీన్ని
మేము స్ట్రింగ్ వంటి చార్ స్టార్ typedef.

29
00:01:19,280 --> 00:01:21,400
మేము సంగ్రహించబడింది ఎందుకంటే
గమనికలు దూరంగా ఆలోచన.

30
00:01:21,400 --> 00:01:25,072
నిజానికి ఒక స్ట్రింగ్ నిజంగా ఆ
మొదటి పాత్ర ఒక పాయింటర్

31
00:01:25,072 --> 00:01:26,780
అక్షరాలు యొక్క వ్యూహం,
అది కేవలం ఎందుకంటే

32
00:01:26,780 --> 00:01:29,863
చుట్టూ మీ తల పొందడానికి చాలా గందరగోళంగా
ఆ కానీ మేము ఏమి వాస్తవం.

33
00:01:29,863 --> 00:01:35,140
మరియు కోడ్ యొక్క ఈ లైన్ నిజానికి ఉనికిలో
CS50 డాట్ H typedef చార్ స్టార్ స్ట్రింగ్ లో

34
00:01:35,140 --> 00:01:39,021
కేవలం ఒక చిన్న తక్కువ చేయడానికి
గజిబిజిగా ఎదుర్కోవటానికి కలిగి.

35
00:01:39,021 --> 00:01:41,520
ఇప్పటికే మీరు బహుశా ఒక చూసిన
ఇక్కడ విలువ కొద్దిగా,

36
00:01:41,520 --> 00:01:44,160
కానీ గొప్ప typedef అవుతుంది
నిర్మాణాలు కలుపుకుంటే,

37
00:01:44,160 --> 00:01:45,780
నేను ముందు పేర్కొన్నట్లు.

38
00:01:45,780 --> 00:01:48,550
స్ట్రక్చర్స్ ఒక రెండు పదాల రకం పేరు.

39
00:01:48,550 --> 00:01:52,020
అందువలన వారు నిజంగా బాధించే ఉంటుంది
ఆ రకమైన వేరియబుల్స్ సృష్టించడానికి,

40
00:01:52,020 --> 00:01:56,310
లేదా [వినబడని] struct ఏదో మీ
లైన్లు కేవలం నిజంగా దీర్ఘ, నిజంగా పొందవచ్చు.

41
00:01:56,310 --> 00:01:59,400
కాబట్టి మీరు వచ్చి typedef ఉపయోగించవచ్చు
చాలా తక్కువ ఏదైనా.

42
00:01:59,400 --> 00:02:04,650
>> నేను ఈ క్రింది విధంగా ఒక కారు నిర్వచించే చేస్తే, నేను కలిగి
ఒక car-- struct కారు నా నిర్వచనం,

43
00:02:04,650 --> 00:02:07,230
మరియు అప్పుడు అన్ని, వంకర కలుపు తెరవడానికి
నా నిర్మాణం రంగాలలో,

44
00:02:07,230 --> 00:02:11,030
దగ్గరగా వంకర కలుపు, సెమీ colon--
నేను నా డేటా రకం నిర్వచించిన చేసిన తర్వాత,

45
00:02:11,030 --> 00:02:15,680
నేను struct typedef చేయవచ్చు
కారు అండర్ t కారు.

46
00:02:15,680 --> 00:02:19,670
ఆపై నేను ఇప్పుడు ప్రతి, ఆ చేసిన ఉన్నప్పుడు
సమయం నేను వాడుట ఉండేది struct

47
00:02:19,670 --> 00:02:22,680
కారు, నేను కారు అండర్ t ఉపయోగించవచ్చు.

48
00:02:22,680 --> 00:02:26,480
ఆ విధంగా చాలా తక్కువ ఉంది
ఈ నిర్మాణం యొక్క ఈ ఆలోచన వ్యక్తీకరించవచ్చు

49
00:02:26,480 --> 00:02:28,530
నేను సృష్టించిన.

50
00:02:28,530 --> 00:02:33,620
>> ప్రత్యామ్నాయంగా, నిర్మాణాలు ఎందుకంటే
కాబట్టి సాధారణంగా typedef ఉపయోగిస్తారు,

51
00:02:33,620 --> 00:02:37,980
మీరు నిజంగా నిర్వచించలేదు ఫంక్షన్ ఉంది
ప్రారంభ మరియు ముగింపు మధ్య లో టైప్ చేయండి.

52
00:02:37,980 --> 00:02:42,020
కాబట్టి typedef నిర్మాణం మళ్ళీ
సాధారణంగా typedef పాత పేరు, కొత్త పేరు,

53
00:02:42,020 --> 00:02:45,360
పేర్లు ఇప్పటికే ఎక్కడ
మీరు సృష్టించిన రకాల.

54
00:02:45,360 --> 00:02:49,620
కానీ మీరు నిజంగా ఒక నిర్మాణం నిర్వచించలేదు
కుడి typedef మధ్యలో

55
00:02:49,620 --> 00:02:51,760
బదులుగా నిర్వచించటానికి కలిగి
అది విడిగా, ఆపై

56
00:02:51,760 --> 00:02:52,990
అది ఒక typedef చేయండి.

57
00:02:52,990 --> 00:02:55,780
మరియు కేవలం వంటి చూస్తారు
దీన్ని typedef struct కారు,

58
00:02:55,780 --> 00:02:59,957
బహిరంగ వంకర జంట కలుపు, మీ రంగంలో అన్ని
నిర్వచనాలు, దగ్గరగా వంకర కలుపు, కారు t.

59
00:02:59,957 --> 00:03:03,290
కాబట్టి పాత పేరు అన్ని అంశాలను లో ఉంది
ఎరుపు, మీరు కేవలం నిర్మాణం నిర్వచించు చేస్తున్నారు

60
00:03:03,290 --> 00:03:05,610
మరియు అదే సమయంలో నామకరణ.

61
00:03:05,610 --> 00:03:07,790
ఆపై కొత్త పేరు
కారు అండర్ t ఉంది.

62
00:03:07,790 --> 00:03:10,150
కాబట్టి మేము ఉపయోగించడానికి మొదలు ఉంటే
కోడ్ లో ఈ, గతంలో నేను

63
00:03:10,150 --> 00:03:13,279
చెప్పారు ఉండవచ్చు, struct
కారు MyCar సెమీ కోలన్.

64
00:03:13,279 --> 00:03:14,820
సరే నేను ఇకపై అలా లేదు.

65
00:03:14,820 --> 00:03:20,265
ఇప్పుడు నేను typedef ఉపయోగిస్తారు చేసిన, నేను
కేవలం కారు అండర్ t, MyCar చెప్పగలను.

66
00:03:20,265 --> 00:03:22,640
ఆ విధంగా చాలా తక్కువ ఉంది
దీన్ని, మరియు నిజానికి, అంతే కు

67
00:03:22,640 --> 00:03:24,515
చాలా ఎక్కువగా అన్నారు
అనుకూలమైన, ముఖ్యంగా

68
00:03:24,515 --> 00:03:27,730
మీరు నిర్మాణాలు ఉపయోగించడానికి మొదలు
మీ కోడ్ లో చాలా ఎక్కువ.

69
00:03:27,730 --> 00:03:28,810
>> నేను డౌ లాయిడ్ ఉన్నాను.

70
00:03:28,810 --> 00:03:30,640
ఈ CS50 ఉంది.

71
00:03:30,640 --> 00:03:32,415