>> SPEAKER 1: యొక్క ఒక ప్రోగ్రామ్ను రాయడం లెట్ పేర్లు వినియోగదారు మరియు అడుగుతుంది
మూడు విద్యార్ధ ఇళ్ళు.
ఇప్పుడు, ఆ పేర్లు మరియు ఇళ్ళు నిల్వ మేము, ఏ, ఆరు వేరియబుల్స్ ఉపయోగించవచ్చు.
మూడు పేర్లు తీగలను, మరియు మరొక ఇళ్ళు కోసం మూడు తీగలను,
కానీ మేము ఇప్పటికే మేము శుభ్రం తెలుసు బదులుగా శ్రేణుల ఉపయోగించి ఆ కోడ్,
ఉదాహరణకు కోసం పరిమాణం 3 యొక్క వ్యూహం మూడు పేర్లు, మరియు మరో శ్రేణి
ఇళ్ళు కోసం పరిమాణం 3.
కానీ మేము ఈ శుభ్రం చేయవచ్చు అవుతుంది మరింత ఇప్పటికీ, మరియు వాస్తవానికి ఆ ఉంచడానికి
కలిసి పేర్లు మరియు ఇళ్ళు, కాబట్టి ఒక విద్యార్థి యొక్క పేరు మరియు అతని లేదా ఆమె హౌస్
ఏదో కు, చుట్టబడి అదే వేరియబుల్, మాట్లాడటం.
>> ఇది చేయుటకు, అయితే, మేము ప్రకటించాలని అవసరం మా స్వంత డేటా రకం, C లో మా స్వంత రకం,
సి రచయితలు తప్పనిసరిగా జరగలేదు సంవత్సరాల క్రితం అనుకుంటున్నాను.
దీన్ని మేము కీవర్డ్ ఉపయోగించవచ్చు typedef, పాటు
ఇతర కీవర్డ్ struct.
యొక్క పరిశీలించి చూద్దాం.
Structs.h యొక్క లోపల, ఇప్పటికే చేసిన ప్రారంభించిన సంపాదించిన
CS50 లైబ్రరీ సహా.
నేను తరువాత, typedef struct టైప్ వెళుతున్న ఆపై ఒక వంకర కలుపు.
Struct లోపలి, నేను వెళుతున్న ఒక విద్యార్థి కలదు పేర్కొనవచ్చు ఒక
పేరు స్ట్రింగ్ అని, మరియు మరొక స్ట్రింగ్ హౌస్ అని.
నేను నా వంకర జంట కలుపులు మూసివేసి వెళుతున్న, మరియు పేర్కొనే పేరు
ఈ కొత్త డేటా రకం విద్యార్థి ఉండాలి.
ఇతర మాటలలో, ఈ వాక్యనిర్మాణం ద్వారా నేను కలిగి నా సొంత కొత్త డేటా రకం ప్రకటించింది
ఒక క్షణం క్రితం ఉన్నాయి, మరియు లేదు ఈ డేటాను రకం లోపలి రెండు డేటా ఉన్నాయి
ఖాళీలను లేదా డేటా సభ్యులు, పేరు అని ఒక, ఒకటి అని ఇల్లు, వీటిలో
రకం స్ట్రింగ్ యొక్క ఉన్నాయి.
>> యొక్క ఇప్పుడు ఈ రకం ఉపయోగిస్తాను ఒక వాస్తవ కార్యక్రమంలో.
Structs0.c, నేను అదేవిధంగా సంపాదించిన చేసిన నాకు కొన్ని ఇప్పటికే ప్రారంభించారు
బాయిలెర్ప్లేట్ కోడ్, మరియు నేను ఇప్పుడు రెడీ ఈ డేటాను ఉపయోగించడానికి వెళుతున్న
క్రింది, విద్యార్థి టైప్.
నేను మొదటి ఒక డిక్లేర్ వెళుతున్న రకం విద్యార్థి శ్రేణి, నేను చేస్తాము
శ్రేణి విద్యార్థులు కాల్ -
బహువచనం -
మరియు నేను దాని పరిమాణం ఉంటుంది పేర్కొనండి విలువ ఇది, నోటీసు, మూడు,
స్థిరమైన విద్యార్థులు -
అన్ని రాజధానులు -
నేను ఇక్కడ డిక్లేర్డ్ చేసిన, ముందు ఫైలులో.
యొక్క తిరుపతి నుంచి పై iterate లెట్ విద్యార్థులు మరియు వినియోగదారు
వారి పేర్లు మరియు ఇళ్ళు.
>> నేను 0 Int పొందండి కోసం, నేను తక్కువ ఉంది స్థిరమైన కంటే, నేను + +.
ఇప్పుడు ఈ శరీరం లోపలి లూప్, నేను ఏదో ప్రింట్ వెళుతున్న
విద్యార్థి యొక్క పేరు వంటి.
నేను నిజంగా పొందండి వెళుతున్న నిర్దేశించి విద్యార్థి యొక్క పేరు
విద్యార్థులు నేను బ్రాకెట్.
ఇతర పదాల నేను i-th విద్యార్థి ఇష్టం ఇప్పుడు అని విద్యార్థులు శ్రేణి, కానీ
నేను i-th విద్యార్ధుల వద్ద పొందడానికి కావలసిన పేరు, మరియు దీన్ని, నేను ఉపయోగించే వెళుతున్న
. ఆపరేటర్లు, ఒక వద్ద పొందడానికి struct యొక్క నిర్దిష్ట పొలాలలో.
నేను విద్యార్థులు i. పేరు బ్రాకెట్ పేర్కొనండి GetString తిరిగి విలువ గెట్స్ ().
ఇంతలో, నేను ప్రింట్ వెళుతున్న ఇలాంటి ఏదో, విద్యార్థి మాట్లాడుతూ
ఇల్లు, మరియు ఇప్పుడు నేను తెలుపుటకు వెళుతున్న ఆ i-th విద్యార్థులు హౌస్ రంగంలో
తిరిగి విలువ పొందుటకు కమిటీ GetString మరొక కాల్ ().
>> ఇప్పుడు ఈ మూడు ఏదో ఒకటి చూద్దాం విద్యార్థులు 'పేర్లు మరియు ఇళ్ళు,
ముద్రణ వంటి సాధారణ ఏదో ఒక వాక్యంలో ప్రతి బయటకు.
Int కోసం i 0, మళ్ళీ నేను కంటే తక్కువ చేసుకోగా విద్యార్థులు, నేను + +, printf "% s% s లో ఉంది.
బాక్ స్లాష్ n ", మరియు ఇప్పుడు నాకు ప్లగ్ వీలు ఆ రెండు రంగాలలో విలువలు,
విద్యార్థులు, i. పేరు, కామాతో బ్రాకెట్ విద్యార్థులు నేను బ్రాకెట్. హౌస్, దగ్గరగా
బ్రాకెట్, సెమికోలన్.
>> ఇప్పుడు నేను ఒక మరింత పనిని చేయడానికి అవసరం.
ఈ ఫైలు దిగువన, నేను అవసరం కేటాయించారు స్వేచ్ఛా మెమొరీ
GetSring (), ద్వారా తెర వెనుక ఇది కోర్సు క్రమంలో, malloc కాల్స్
తీగలను కోసం మెమరీని కేటాయించాల్సిన యూజర్ రకాల.
కానీ ఈ సులభం.
నేను 0 Int పొందండి కోసం, నేను కంటే తక్కువ విద్యార్థులు, నేను + +, మరియు శరీరం లోపలి
ఈ లూప్, నేను కేవలం వెళుతున్న ఉచిత విద్యార్థులు బ్రాకెట్ నేను. పేరును,
మరియు ఉచిత విద్యార్థులు నేను బ్రాకెట్. హౌస్.
>> ఇప్పుడు, మేము స్పష్టంగా ఉచ్చులు కోసం మూడు ఉపయోగించిన ఈ కార్యక్రమంలో, నిజంగా నేను
కేవలం ఒక ఉపయోగిస్తారు, అయితే ఈ కావచ్చు కేవలం ప్రదర్శన కోసమని, కాబట్టి
మేము మూడు విభిన్న లో పేర్కొనవచ్చు మేము చేస్తున్న దాన్ని ఖచ్చితంగా వేసింది.
మేము మొదటి ఒక పేరు మరియు ఒక ఇల్లు చేస్తున్నారు విద్యార్థులు ప్రతి, మేము అప్పుడు ఉన్నారు
కోసం పేరు మరియు ఇంటి ముద్రించిన మూడు విద్యార్ధ ప్రతి, మరియు
అప్పుడు మేము మెమొరీ చూడాలని విద్యార్థులు ప్రతి ఉపయోగించే.
కానీ ఖచ్చితంగా మేము ఈ మిళితం చేసిన కాలేదు లూప్ ఒక పెద్ద లోకి.
>> కంపైల్, ఇప్పుడు సేవ్, ఈ ప్రోగ్రామ్ రన్.
తయారు structs 0. / structs 0, విద్యార్థి పేరు, యొక్క డేవిడ్ అందించడానికి వీలు, అతను జీవింతురు
మాథుర్ హౌస్, విద్యార్థి యొక్క పేరు, లెట్స్ లారెన్ చెప్పటానికి, ఆమె Leverett జీవింతురు
హౌస్, విద్యార్థి యొక్క పేరు, రాబ్, ఎవరైనా Kirkland హౌస్ లో నివసిస్తున్నారు.
నిజానికి, డేవిడ్, మాథుర్ ఉంది లారెన్, Leverett లో ఉంది
మరియు రాబ్ కిర్క్ల్యాండ్ ఉంది.