డౌ LLOYD: మీరు చేసిన ఉంటే నిర్మాణాల మీద మా వీడియో చూసిన,
మీరు ఇప్పటికే మేము కలిగి తెలుసు మా స్వంత డేటా రకాలను విశదీకరిస్తాయి సామర్థ్యం.
మీరు ఉపయోగించిన నిర్మాణాలు చేసిన ఉంటే కానీ, మీకు తెలిసిన కొన్నిసార్లు ఆ డేటా రకాల ఉపయోగించి
నిజానికి కొద్దిగా ఉంటుంది గజిబిజిగా మేము ఎందుకంటే
struct కీవర్డ్ ఉపయోగించాలి మేము them-- పని చేసినప్పుడు
struct కారు లేదా struct విద్యార్థి.
ఆ టైప్ చాలా వార్తలు మేము కేవలం కలిగి అనుకుంటే
ఒక నిర్మాణం వంటి సాధారణ ఏదో.
మేము కావలసిన మనం కావలసిన విషయాలు పని చేయగలరు
కొంచెం సంక్షిప్తలిపి మార్గం, పూర్ణాంకానికి లేదా చార్, ఏదో చాలా వంటి
టైప్ మరింత సౌకర్యవంతంగా ఉంటుంది.
>> అదృష్టవశాత్తూ, అక్కడ ఒక విధంగా, C లో దీన్ని
ఇది typedef అని ఏదో తో ఒక విధంగా సంక్షిప్తలిపి సృష్టించడానికి లేదా తిరగరాశాడు కు
డేటా రకాల పేర్లు.
మీరు డేటా తిరగరాసే ఇప్పటికే ఉనికిలో రకాల
లేదా మీరు మీ సొంత డేటా రకాల వ్రాయగలవు.
>> మీరు మొదటి విషయం మీరు సాధారణ విధంగా ఒక రకం నిర్వచించే,
ఆపై మీరు కేవలం ఏదో దానిని అలియాస్ typedef పాత పేరు కొత్త పేరు else--.
ప్రెట్టీ సూటిగా, కుడి?
కాబట్టి మేము, ఉదాహరణకు typedef కాలేదు, అప్పటికే డేటా
బైట్ సైన్ చేయని చార్ యొక్క రకం.
ఆపై, ఇప్పటి నుండి మేము చేసిన తర్వాత ఈ రకం మళ్ళీ definition-- చేసిన,
సాధారణంగా ఎగువన అవతరిస్తుంది ఇది మా డాట్ సి ఫైళ్లు, లేదా ఒక డాట్ H ఫైలు లో
విడిగా, మేము కేవలం ప్రతిచోటా కాటు ఉపయోగించడానికి
మేము సైన్ చేయని చార్ ఉపయోగిస్తారు ఉండేది.
ఆ టైప్ చాలా తక్కువ ఉంది.
>> CS50 యొక్క లైబ్రరీ, మేము దీన్ని మేము స్ట్రింగ్ వంటి చార్ స్టార్ typedef.
మేము సంగ్రహించబడింది ఎందుకంటే గమనికలు దూరంగా ఆలోచన.
నిజానికి ఒక స్ట్రింగ్ నిజంగా ఆ మొదటి పాత్ర ఒక పాయింటర్
అక్షరాలు యొక్క వ్యూహం, అది కేవలం ఎందుకంటే
చుట్టూ మీ తల పొందడానికి చాలా గందరగోళంగా ఆ కానీ మేము ఏమి వాస్తవం.
మరియు కోడ్ యొక్క ఈ లైన్ నిజానికి ఉనికిలో CS50 డాట్ H typedef చార్ స్టార్ స్ట్రింగ్ లో
కేవలం ఒక చిన్న తక్కువ చేయడానికి గజిబిజిగా ఎదుర్కోవటానికి కలిగి.
ఇప్పటికే మీరు బహుశా ఒక చూసిన ఇక్కడ విలువ కొద్దిగా,
కానీ గొప్ప typedef అవుతుంది నిర్మాణాలు కలుపుకుంటే,
నేను ముందు పేర్కొన్నట్లు.
స్ట్రక్చర్స్ ఒక రెండు పదాల రకం పేరు.
అందువలన వారు నిజంగా బాధించే ఉంటుంది ఆ రకమైన వేరియబుల్స్ సృష్టించడానికి,
లేదా [వినబడని] struct ఏదో మీ లైన్లు కేవలం నిజంగా దీర్ఘ, నిజంగా పొందవచ్చు.
కాబట్టి మీరు వచ్చి typedef ఉపయోగించవచ్చు చాలా తక్కువ ఏదైనా.
>> నేను ఈ క్రింది విధంగా ఒక కారు నిర్వచించే చేస్తే, నేను కలిగి ఒక car-- struct కారు నా నిర్వచనం,
మరియు అప్పుడు అన్ని, వంకర కలుపు తెరవడానికి నా నిర్మాణం రంగాలలో,
దగ్గరగా వంకర కలుపు, సెమీ colon-- నేను నా డేటా రకం నిర్వచించిన చేసిన తర్వాత,
నేను struct typedef చేయవచ్చు కారు అండర్ t కారు.
ఆపై నేను ఇప్పుడు ప్రతి, ఆ చేసిన ఉన్నప్పుడు సమయం నేను వాడుట ఉండేది struct
కారు, నేను కారు అండర్ t ఉపయోగించవచ్చు.
ఆ విధంగా చాలా తక్కువ ఉంది ఈ నిర్మాణం యొక్క ఈ ఆలోచన వ్యక్తీకరించవచ్చు
నేను సృష్టించిన.
>> ప్రత్యామ్నాయంగా, నిర్మాణాలు ఎందుకంటే కాబట్టి సాధారణంగా typedef ఉపయోగిస్తారు,
మీరు నిజంగా నిర్వచించలేదు ఫంక్షన్ ఉంది ప్రారంభ మరియు ముగింపు మధ్య లో టైప్ చేయండి.
కాబట్టి typedef నిర్మాణం మళ్ళీ సాధారణంగా typedef పాత పేరు, కొత్త పేరు,
పేర్లు ఇప్పటికే ఎక్కడ మీరు సృష్టించిన రకాల.
కానీ మీరు నిజంగా ఒక నిర్మాణం నిర్వచించలేదు కుడి typedef మధ్యలో
బదులుగా నిర్వచించటానికి కలిగి అది విడిగా, ఆపై
అది ఒక typedef చేయండి.
మరియు కేవలం వంటి చూస్తారు దీన్ని typedef struct కారు,
బహిరంగ వంకర జంట కలుపు, మీ రంగంలో అన్ని నిర్వచనాలు, దగ్గరగా వంకర కలుపు, కారు t.
కాబట్టి పాత పేరు అన్ని అంశాలను లో ఉంది ఎరుపు, మీరు కేవలం నిర్మాణం నిర్వచించు చేస్తున్నారు
మరియు అదే సమయంలో నామకరణ.
ఆపై కొత్త పేరు కారు అండర్ t ఉంది.
కాబట్టి మేము ఉపయోగించడానికి మొదలు ఉంటే కోడ్ లో ఈ, గతంలో నేను
చెప్పారు ఉండవచ్చు, struct కారు MyCar సెమీ కోలన్.
సరే నేను ఇకపై అలా లేదు.
ఇప్పుడు నేను typedef ఉపయోగిస్తారు చేసిన, నేను కేవలం కారు అండర్ t, MyCar చెప్పగలను.
ఆ విధంగా చాలా తక్కువ ఉంది దీన్ని, మరియు నిజానికి, అంతే కు
చాలా ఎక్కువగా అన్నారు అనుకూలమైన, ముఖ్యంగా
మీరు నిర్మాణాలు ఉపయోగించడానికి మొదలు మీ కోడ్ లో చాలా ఎక్కువ.
>> నేను డౌ లాయిడ్ ఉన్నాను.
ఈ CS50 ఉంది.