మనము  మాడ్యూల్ 1 లో సి ప్రోగ్రామింగ్ గురించి చర్చిస్తున్నాము.
 ఇప్పుడు మనం మాట్లాడుకుంటుంది పార్ట్-2.
 ముందు భాగంలో మనము  డేటా రకాలు, వేరియబుల్స్, ఆపరేటర్లు, ఎక్స్ప్రెషన్స్ మరియు స్టేట్మెంట్స్ (ఆదేశాలు), ముఖ్యంగా నియంత్రణ ఆదేశాలతో సహా C లోని ప్రాథమిక భావనలను  చూశాము .
 ఇప్పుడు, మేము ముందుకు వెళ్తాము మరియు సి లోని వివిధ ఉత్పన్న రకాలు గురించి మాట్లాడుతాము, సి లో సర్వసాధారణంగా ఉత్పన్నమైన రకాలు శ్రేణులని మీకు తెలుసు.
 శ్రేణి అనేది డేటా అంశాల సమాహారం.
 కాబట్టి, వేరియబుల్ అనేది ఒకే డేటా అంశం, ఇది ఒకే విలువ; శ్రేణి అంటే ఒకటి లేదా అంతకంటే ఎక్కువ డేటా ఐటెమ్‌ల సమాహారం, అన్ని డేటా అంశాలు ఒకే రకంగా ఉండాలి.
 కాబట్టి, Int ఒక శ్రేణి అని నేను చెబితే, ఆ శ్రేణి (శ్రేణి) లోని అన్ని విలువలు పూర్ణాంకంగా ఉండాలి.
 శ్రేణి రకం చార్ (చార్) అని నేను చెబితే, ప్రతి మూలకం తప్పనిసరిగా టైప్ క్యారెక్టర్ కలిగి ఉండాలి.
 శ్రేణుల సందర్భంలో, మనం చేయవలసిన మొదటి విషయం ఏమిటంటే, మనం ఏదైనా వేరియబుల్ (ల) ను డిక్లేర్ చేయాల్సిన అవసరం ఉన్నట్లే శ్రేణి (శ్రేణి) ను ప్రకటించడం, కాబట్టి మనం ఈ శ్రేణిని ఉపయోగించవచ్చు.
 కాబట్టి, సహజంగా, మేము పేరును పేర్కొనాలి; శ్రేణి యొక్క మూలకం యొక్క రకం ఏమిటో మనం చెప్పాలి; మరియు శ్రేణి మద్దతు ఇవ్వగల గరిష్ట సంఖ్యల సంఖ్య ఏమిటో కూడా మేము పేర్కొనాలి.
 ఇప్పుడు, ఈ గరిష్ట సంఖ్యలను అనేక రకాలుగా పేర్కొనవచ్చు.
 మరియు మనం చూసేటప్పుడు ఇది C ++ లోని శ్రేణుల (శ్రేణుల) C లోని శ్రేణుల నుండి కొంత భిన్నంగా ఉంటుంది, కానీ C లోని ఒక నిర్దిష్ట శ్రేణి (శ్రేణి) మూలలో బ్రాకెట్లలో డబుల్ బ్యాలెన్స్‌గా 10. నిర్వచించబడుతుంది, ఇది మిగిలిన రకం రకపు డబుల్ మూలకాల శ్రేణి అని మరియు గరిష్టంగా 10 అటువంటి మూలకాలను కలిగి ఉంటుందని చెబుతుంది.
 లేకపోతే, మేము మానిఫెస్ట్ స్థిరాంకం ద్వారా ఆకారాన్ని నిర్వచించవచ్చు మరియు శ్రేణిని నిర్వచించడానికి దాన్ని ఉపయోగించవచ్చు.
 అప్పుడు శ్రేణిని కూడా ప్రారంభించవచ్చు, మేము రెండవ భాగానికి వెళ్తున్నాము.
 అందువల్ల, శ్రేణులను కూడా ప్రారంభించవచ్చు, నేను శ్రేణిని ప్రకటిస్తే, మూలకాలకు నిర్దిష్ట విలువ లేదు, కానీ నేను శ్రేణిని ప్రకటించగలను, అలాగే ప్రారంభించగలను. Am
 కాబట్టి, 'Int ప్రైమ్‌లు [5]' కామాలతో వేరు చేయబడిన మరియు ఒక జత వంకర కలుపులలో సంతృప్తి చెందిన విలువల జాబితాతో ప్రారంభించబడిందని నేను చెబితే, ఆ జాబితాలోని మొదటి విలువ శ్రేణి యొక్క మొదటి మూలకానికి వెళుతుంది మీకు 0 వ సూచిక మూలకం తెలుసు.
 రెండవది జాబితాలోని రెండవ మూలకానికి వెళుతుంది, ఇది సూచిక ఒకటి మరియు మొదలైనవి.
 C లో ఆసక్తికరంగా, ప్రత్యేకంగా వ్యక్తీకరించబడిన ఆకారం లేకుండా కూడా శ్రేణులను ప్రారంభించడానికి అనుమతిస్తారు.
 అందువల్ల, నేను వాస్తవంగా రూపొందించకుండా అతిక్రమణలను మాత్రమే వ్రాయగలను మరియు సి కంపైలర్ చేసే పనుల యొక్క ప్రారంభ జాబితాను ఇవ్వగలను; మీరు దానితో ఎన్ని మూలకాలను ప్రారంభించారో ఇది కనుగొంటుంది మరియు ఇది శ్రేణి యొక్క పరిమాణం లేదా బహుళ అంశాలు ఉంటాయని umes హిస్తుంది.
 అందువల్ల, ప్రైమ్‌లు 2, 3, 5, 7 మరియు 11 ల జాబితాతో ప్రారంభించబడితే, 5 అంశాలు ఉన్నాయి, కాబట్టి ఇది ఐదు మూలకాల శ్రేణి అవుతుంది.
 మరియు నేను అలాంటి సందర్భాల్లో కూడా చూపించాను, ఎందుకంటే పరిమాణం ఏమిటో మీకు తెలియదు, ప్రతి మూలకం యొక్క పరిమాణంతో విభజించబడిన శ్రేణి యొక్క మొత్తం పరిమాణం అని మీరు అనుకునే పరిమాణాన్ని లెక్కించడానికి అత్యంత నమ్మదగిన మార్గం ఏమిటి. ఖచ్చితంగా పొందండి శ్రేణిని కలిగి ఉన్న మూలకాల సంఖ్య.
 మీరు పెద్ద శ్రేణిని కలిగి ఉండటం మరియు తక్కువ సంఖ్యలో మూలకాలతో ప్రారంభించడం కూడా సాధ్యమే; ప్రారంభం ఎల్లప్పుడూ ఉంటుంది.
 మరియు అలాంటి సందర్భాల్లో మిగిలిన అంశాలు 0 కి ప్రారంభించబడతాయి, కానీ మీరు దానిలో ఒక ప్రారంభ జాబితాను ఉంచలేరు, అది ఎర్ యొక్క పరిమాణం కంటే పెద్దది.
 ప్రారంభించినా లేదా ప్రారంభించకపోయినా ప్రతి మూలకం ద్వారా శ్రేణిని యాక్సెస్ చేయవచ్చు.
 అందువల్ల, శ్రేణి మూలకాలను ప్రాప్యత చేయడానికి, మేము సూచికను ఉపయోగిస్తున్నట్లు మనం చూడవచ్చు మరియు ఆ శ్రేణి (శ్రేణి) స్థానంలో ఉన్న అంశాలను చదవవచ్చు లేదా యాక్సెస్ చేయవచ్చు.
 అదేవిధంగా, నేను దానిని వ్యక్తీకరణ యొక్క ఎడమ వైపున కూడా వ్రాయలేకపోయాను మరియు శ్రేణి మూలకానికి అప్పగించగలను.
 నిర్వచించిన ప్రతి శ్రేణి ఒకే మూలకం లాంటిదని సి umes హిస్తుంది.
 అందువల్ల, నేను శ్రేణుల శ్రేణుల (శ్రేణుల) (శ్రేణుల) మరియు శ్రేణుల (శ్రేణుల) శ్రేణుల (శ్రేణుల) మరియు శ్రేణులను నిర్వచించగలను; మరియు ఈ విధంగా, నేను చాలా కోణాలలో విస్తరించగలను.
 కాబట్టి, వీటిని మల్టీ డైమెన్షనల్ అర్రేస్ అంటారు.
 కాబట్టి, మల్టీ డైమెన్షనల్ అర్రే యొక్క సరళమైనది రెండు డైమెన్షనల్ అర్రే, ఇది మేము సాధారణంగా గణితంలో చెబుతాము, మేము సాధారణంగా వాటిని మాతృక అని పిలుస్తాము.
 కాబట్టి, ఇది రెండు కోణాలతో ఇవ్వబడుతుంది; A అనేది వరుసల సంఖ్య మరియు నిలువు వరుసల సంఖ్య.
 కాబట్టి, మేము int mat [3] [4] ను నిర్వచించినట్లయితే, ఈ మొత్తం మత్ శ్రేణి (శ్రేణి) లో 3 వరుసలు మరియు 4 నిలువు వరుసలు ఉన్నాయని అర్థం.
 కాబట్టి, ఇది రెండు డైమెన్షనల్ చేస్తుంది; సహజంగానే ఇది రెండు డైమెన్షనల్ అయితే, దానిని యాక్సెస్ చేయడానికి వరుస సూచిక మరియు కాలమ్ సూచిక యొక్క రెండు సూచికలు అవసరం.
 మీరు దీన్ని 3, 4 యొక్క అధిక పరిమాణానికి విస్తరించవచ్చు, కానీ మీకు సాధారణ ఉపయోగంలో 3 లేదా అంతకంటే ఎక్కువ డైమెన్షనల్ శ్రేణులు ఉంటాయి.
 శ్రేణుల పక్కన నిర్మాణాలు ఉన్నాయి.
 కాబట్టి, శ్రేణి ఒక సేకరణ వలె ఉంటుంది మరియు మేము నెమ్మదిగా కంటైనర్ అనే పదాన్ని ఉపయోగించడం ప్రారంభిస్తాము, ఇది C లో అంత సాధారణం కాదు, కాని మేము C ++ లో చూస్తాము మరియు ముఖ్యంగా C ++ తో వచ్చే ప్రామాణిక లైబ్రరీ, సాధారణంగా ఉపయోగించే పదాలు కంటైనర్లు ఇతర అంశాలను కలిగి ఉన్నవి కాబట్టి కంటైనర్లు అని పిలుస్తారు.
 శ్రేణి ఒక కంటైనర్; ఇది నిర్దిష్ట ప్రవర్తనతో కూడిన డేటా ఐటెమ్‌ల సమాహారం, మనం చూసినట్లుగా అన్ని అంశాలు ఒకే రకానికి చెందినవి.
 ఇప్పుడు, దీనికి విరుద్ధంగా, నిర్మాణం కూడా ఒక కంటైనర్; ఇది డేటా వస్తువుల సమాహారం, కానీ ఇక్కడ డేటా అంశాలు వివిధ రకాలుగా ఉంటాయి; అవి తప్పనిసరిగా వివిధ రకాలుగా ఉండవలసిన అవసరం లేదు, కానీ అవి వేర్వేరు రకాలుగా ఉంటాయి.
 కాబట్టి, నేను ఒక నిర్మాణంలో చూస్తే, ఈ డేటా అంశాలను తరచుగా సభ్యులు అని పిలుస్తారు; నిర్మాణం యొక్క పాత్ర లేదా డేటా ఐటెమ్‌ను అర్ధం చేసుకోవడానికి మేము ఈ పదాన్ని సభ్యుడు లేదా డేటా సభ్యుడిని ఎక్కువగా ఉపయోగిస్తాము, సంక్లిష్ట సంఖ్యను సృష్టించడాన్ని మేము సులభతరం చేస్తాము.ఉదాహరణలను చూపిద్దాం.
 మనకు తెలిసినట్లుగా సంక్లిష్ట సంఖ్యలకు రెండు అక్షరాలు ఉన్నాయి - నిజమైన భాగం మరియు inary హాత్మక భాగం.
 కాబట్టి, ప్రతి భాగం రెట్టింపు కావచ్చు.
 కాబట్టి, రెండు అక్షరాలు ఉన్నాయని మాకు చెప్పే సమ్మేళనంతో ఒక నిర్మాణాన్ని మేము నిర్వచించాము; ఈ సందర్భంలో, రెండూ ఒకే రకానికి చెందినవి, ఆపై సి ఈ నిర్మాణ రకానికి చెందిన వేరియబుల్‌గా ప్రకటించబడుతుంది.
 మేము తదుపరిదాన్ని కూడా చేయవచ్చు; మీరు నిజంగా విభిన్న రకాల అక్షరాలు ఉన్న నిర్మాణాన్ని కలిగి ఉన్నారని మేము చూపిస్తాము.
 కాబట్టి, పుస్తక నిర్మాణంలో మొదటి రెండు అక్షరాలు శీర్షిక మరియు రచయిత; అవి పాత్ర యొక్క శ్రేణులు, అంటే అవి టైటిల్ పేరు మరియు రచయిత పేరు యొక్క తీగలుగా మారుతాయి; మరియు మూడవ అక్షరం వాస్తవానికి పూర్ణాంకం, ఇది పుస్తక ID ని కలిగి ఉంటుంది.
 నిర్మాణాలను వాటి పేరు ప్రకారం నేరుగా నిర్వచించవచ్చు, మరియు మేము దానిని కీవర్డ్ నిర్మాణం లేదా నిర్మాణాన్ని ఉపయోగించి ఉపయోగించవచ్చు మరియు నిర్మాణాన్ని కలిసి పేరు పెట్టవచ్చు మరియు ఈ రకానికి డిర్ కీవర్డ్ ఉపయోగించి మారుపేరు ఇవ్వవచ్చు.
 టైప్ డెఫ్ అనేది చిన్న నిర్వచనం యొక్క సంక్షిప్తీకరణ.
 మరియు మేము C ++ లోకి వెళుతున్నప్పుడు, టైప్ డెఫ్ నిజంగా టైప్ డెఫినిషన్ ఎందుకు కాదు, ఇది ఒక రకమైన తప్పుడు పేరు, కానీ చారిత్రాత్మకంగా ఇది ఈ కీవర్డ్‌ని ఉపయోగించింది మరియు C లో ఉపయోగించడం కొనసాగుతోంది, కాని ఇది ప్రాథమికంగా మారుపేరు.
 ఇది మనకు ఉన్నట్లుగా, స్ట్రక్ట్ పుస్తకాల నిర్మాణ సముదాయానికి ఇచ్చిన మరొక పేరు.
 ఇది సులభం అవుతుంది.
 మీరు ఒక రకమైన డెఫ్ ఉపయోగిస్తే, మీరు దాన్ని నేరుగా ఉపయోగించవచ్చు
 కాబట్టి, మేము నిర్మాణాలను యాక్సెస్ చేయడానికి వస్తే, కాంప్లెక్స్ మాత్రమే ఉపయోగించడానికి సంక్లిష్టంగా నిర్వచించబడినందున, మేము కాంప్లెక్స్ కాంప్లెక్స్ను ఉపయోగించాలి మరియు వేరియబుల్ పేరును అనుసరించాలి.
 కానీ ఇక్కడ పుస్తకాలు టైప్ డెఫ్ ద్వారా నిర్వచించబడ్డాయి, కాబట్టి నేను పుస్తకాలను మాత్రమే వ్రాయగల నిర్మాణాత్మక పుస్తకాలతో పుస్తకాలు వ్రాయవలసిన అవసరం లేదు, ఇది పుస్తకానికి మొత్తం పేరును ఇచ్చింది.
 కాబట్టి, దీన్ని ఈ విధంగా ఉపయోగించడం సులభం అవుతుంది.
 ఇప్పుడు, ఏదైనా స్ట్రక్చర్ వేరియబుల్ ను సాధారణ వేరియబుల్ లాగా ప్రారంభించవచ్చు; మరియు మేము శ్రేణిని ప్రారంభించిన విధంగానే సంజ్ఞామానం జరుగుతుంది.
 దీనికి విరుద్ధంగా, శ్రేణులలో, వంకర కలుపులలో ఏర్పడిన జాబితా అంటే విభిన్న భాగాలు లేదా శ్రేణి యొక్క విభిన్న సూచిక అంశాలు; నిర్మాణం విషయంలో, దీని అర్థం వేర్వేరు భాగాలు లేదా శ్రేణుల డేటా సభ్యులు; మరియు మీరు ఈ ప్రారంభ విలువలను జాబితా చేసే విధానం, డేటా సభ్యులు పై నుండి క్రిందికి జాబితా చేయబడిన విధానం.
 కాబట్టి, ఈ కోడ్‌లో ఇచ్చిన నిర్దిష్ట కేసులను పరిశీలిస్తే, మీరు ప్రారంభ కాంప్లెక్స్ x ను 2.0, 3.5 తో చూపిస్తాము, అంటే 2.0 యొక్క మొదటి అక్షరం (అక్షరం) 'రీ' అని అర్ధం., దీని ప్రారంభ విలువ ఉంటుంది .
 కాబట్టి, మీరు వాటిని పై నుండి క్రిందికి చదివి, ఈ జాబితాను ఎడమ నుండి కుడికి చదివి వాటికి అనుగుణంగా ఉండండి.
 కాబట్టి, 3.5 im & # 39; లు ప్రారంభ విలువ అవుతుంది.
 కాబట్టి, మనం ఈ విధంగా ఆలోచిస్తే, x సంక్లిష్ట సంఖ్య 2.0 + j 3.5 అవుతుంది.
 మేము ఒకటి లేదా కొద్ది మంది సభ్యులను మాత్రమే ప్రారంభించే అవకాశం ఉంది, కానీ మీరు దీన్ని ప్రారంభ భాగం నుండి మాత్రమే చేయగలరు.
 మీరు మళ్ళీ 'రీ' ను దాటవేయలేరు మరియు 'ఇమ్' ను మాత్రమే ప్రారంభించలేరు, కానీ మీరు ఇక్కడ 4.2 తో చేస్తున్నట్లుగా మీరు 'రీ' ను ప్రారంభించవచ్చు మరియు పేర్కొన్న విధంగా 'ఇమ్' ను వదిలివేయండి. ఇక్కడ చేయలేదు.
 అప్పుడు నిర్మాణం యొక్క ప్రతి అక్షరాన్ని డాట్ సంజ్ఞామానం ద్వారా చూడవచ్చు, మనం ఇక్కడ చూపించే డాట్ ఆపరేటర్.
 కాబట్టి, x ఒక సంక్లిష్టమైన వేరియబుల్ అయితే, ఒక నిర్మాణం వేరియబుల్, ఆపై ఈ వేరియబుల్ x యొక్క 'రీ' భాగం x.re గా వ్రాయబడుతుంది.
 అదేవిధంగా, ఇక్కడ పుస్తకం పైన పేర్కొన్న పుస్తకాల నిర్మాణం, కాబట్టి దీనికి పుస్తకం 'ఐడి' అక్షరం ఉంది.
 కాబట్టి, నిర్మాణ అక్షరాన్ని యాక్సెస్ చేయడానికి మేము డాట్ సంజ్ఞామానాన్ని ఉపయోగిస్తాము.
 అందువల్ల, సాధారణంగా ఉపయోగించే రెండు సి మధ్య మనం చూడవచ్చు, సి రెండు అత్యంత శక్తివంతమైన కంటైనర్లలో రెండు వేర్వేరు రీతులను కలిగి ఉంటుంది; అన్ని అంశాలు ఒకే రకానికి చెందినవి.
 ఇది స్థానం ద్వారా ప్రాప్తి చేయబడుతుంది, దీనిని స్థాన ప్రాప్యత అని పిలుస్తారు, ఎందుకంటే మీరు మొదటి నుండి మొదలయ్యే మొదలు, రెండవది, కాబట్టి మీరు సంఖ్య ద్వారా వెళ్ళండి, కాబట్టి శ్రేణిని ఇండెక్స్డ్ కంటైనర్ అని కూడా పిలుస్తారు, ఎందుకంటే మీరు సంఖ్యల వారీగా మూలకాలను యాక్సెస్ చేయండి.
 దీనికి విరుద్ధంగా, నిర్మాణంలో, మూలకాలు వేర్వేరు రకాలుగా ఉంటాయి.
 అందువల్ల, జాబితాలోని మొదటి అక్షరం ఏమిటి లేదా జాబితాలోని మూడవ అక్షరం ఏమిటి మొదలైన వాటికి ఎక్కువ ప్రాముఖ్యత లేదు.
 అందువల్ల, మీరు మూలకాలను పేరు ద్వారా యాక్సెస్ చేస్తారు.
 ఇప్పుడు ఇది కూడా ఒక శైలి, ఇది మీరు పేరు ద్వారా ఏదైనా యాక్సెస్ చేయగలరా లేదా మీరు రాష్ట్రాల వారీగా ఏదైనా యాక్సెస్ చేయగలరా అని మేము వివిధ భాషలలో చూస్తాము, మరియు మేము ఫంక్షన్‌ను అభ్యర్ధించినప్పుడు ఇలాంటి ప్రాప్యత సమస్యలు తలెత్తుతాయి మేము మీ గురించి కూడా మాట్లాడుతాము తెలుసుకోవడం కూడా పరిస్థితి నుండి.
 ప్రోగ్రామింగ్ లాంగ్వేజ్ యొక్క కొన్ని సాధారణ అంశాలు ఇవి అని నేను కోరుకుంటున్నాను, దాని మధ్య యాక్సెస్ మెకానిజం అంటే ఏమిటి లేదా దాని పేరు పెట్టబడిన దాని గురించి మీరు మూలకాల జాబితాను కలిగి ఉన్నప్పుడు జాగ్రత్తగా ఉండాలి.
 కాబట్టి, నిర్మాణంలో, మేము ఒక రకాన్ని చూస్తాము; శ్రేణిలో, మేము మరొకటి చూస్తాము.
 ఇప్పుడు సి పై నడుస్తున్నది మరొక రకమైన నిల్వ కంటైనర్‌కు మద్దతు ఇస్తుంది, ఇది నిర్మాణాల మాదిరిగానే ఉంటుంది, వాటిని సంఘాలు అంటారు.
 ఇప్పుడు, ఒకే తేడా ఏమిటంటే, మీరు ఉపయోగించే కీవర్డ్‌కి బదులుగా యూనియన్ కీవర్డ్‌ని ఉపయోగించడం.
 మీరు పేర్కొన్న విధానం లేదా మీరు సభ్యులను చేరే విధానం నిర్మాణం మరియు అసోసియేషన్ మధ్య సమానంగా ఉంటుంది.
 కానీ భిన్నమైనది ఏమిటంటే మెమరీని కేటాయించిన విధానం.
 మీకు ఇద్దరు, మూడు వేర్వేరు సభ్యులతో ఒక నిర్మాణం ఉంటే, ఆ నిర్మాణ రకం యొక్క వేరియబుల్ సృష్టించబడినప్పుడు, ఆ ప్రాంతం సభ్యులందరికీ కేటాయించబడుతుంది.
 కాబట్టి, మీరు ఈ నిర్మాణానికి తిరిగి వెళితే, ఇక్కడ రెండు అక్షరాలు ఉన్నాయని మీరు చూస్తారు, సంక్లిష్ట నిర్మాణాన్ని నిర్వచించిన తరువాత, ఈ రెండు అక్షరాలు వాస్తవానికి కేటాయించబడతాయి.
 అందువల్ల, ప్రతి ఒక్కటి డబుల్ టెక్స్ట్ బైట్లు అని మనం అనుకుంటే, మొత్తం సంక్లిష్ట నిర్మాణం యొక్క పరిమాణం 8 బైట్లు ప్లస్ 8 బైట్లు 16 బైట్లు, రెండూ ఉన్నందున.
 దీనికి విరుద్ధంగా, అనుబంధంలో, ఈ కేటాయింపు జ్ఞాపకార్థం అతిపెద్ద పాత్ర కోసం మాత్రమే చేయబడుతుంది.
 అందువల్ల, పేరు అసోసియేషన్ సూచించినట్లు మీ ప్రాథమిక umption హ ఈ అన్ని రంగాల యూనియన్ అని మీరు నిర్ధారిస్తారు, కాబట్టి ఏ సమయంలోనైనా ఒకటి మాత్రమే ఉంటుంది.
 కాబట్టి, సహజంగానే మీరు వాటిలో ఒకదాన్ని మాత్రమే సూచిస్తుంటే, తార్కిక విషయం అయిన అతి పెద్దదానికి మీకు తగినంత స్థలం కావాలి.
 కాబట్టి, మేము ఈ యూనియన్ ప్యాకెట్‌ను పరిశీలిస్తే, ప్యాకెట్‌లో 3 అక్షరాలు (డబుల్) మరియు నాలుగు (చార్) రకాలు ఉన్నాయని చూస్తాము.
 అందువల్ల, మేము 32-బిట్ యంత్రంలో పరిమాణం గురించి సహేతుకమైన umption హను తీసుకుంటే, పూర్ణాంకానికి 4 బైట్లు, డబుల్ 8 బైట్లు మరియు చార్ (చార్) బహుశా 2 బైట్లు కావచ్చు.
 కాబట్టి, ప్యాకెట్ యొక్క పరిమాణం 8 బైట్లు అవుతుంది, ఇది అతిపెద్ద అక్షరానికి రెండు రెట్లు ఎక్కువ.
 కాబట్టి, ఆసక్తికరమైన అంశం ఏమిటంటే, ఒక వైపు మొత్తం రికార్డ్ యొక్క పరిమాణాన్ని, మొత్తం కంటైనర్ యొక్క పరిమాణాన్ని తగ్గించడానికి ఇది మిమ్మల్ని అనుమతిస్తుంది, మీకు ఒకే సమయంలో అన్ని భాగాలు అవసరం లేదని మీకు తెలిస్తే.
 కాబట్టి దాని యొక్క మరొక వైపు ఏమిటంటే, మీరు ప్రారంభించినప్పుడు మీరు మొదటి భాగం యొక్క విలువను మాత్రమే ప్రారంభిస్తున్నారు ఎందుకంటే ఇక్కడ మీరు ఒక భాగాన్ని మాత్రమే కలిగి ఉంటారు, మాకు ఒక భాగానికి మాత్రమే స్థలం ఉంటుంది.
 ప్రారంభంలో ఉన్న భాగాల జాబితా వ్యక్తిగత డేటా సభ్యుల జాబితాను ప్రారంభించదు.
 ప్రారంభించడం పాక్షికంగా అందించబడుతుందని మేము చూశాము, మొదటి ఒకటి లేదా మొదటి రెండు లేదా మొదటి మూడు ఇక్కడ ప్రారంభించాను ఎందుకంటే ఒకే డేటా సభ్యుడు మాత్రమే ఉన్నాడు.మీరు ప్రారంభించగలిగేది ఒక్క విలువ మాత్రమే. మరియు దాని రకం మొదటి విలువ .
 లేకపోతే, మీరు ప్రారంభించాల్సిన అవసరం లేదని మీరు చేయాలి, బదులుగా మీరు పాత్రను తీసుకొని కేటాయించండి.
 కాబట్టి, యాక్సెస్ పరంగా, ఒకే డాట్ సంజ్ఞామానం డాట్ ఆపరేటర్ వేర్వేరు భాగాలను యాక్సెస్ చేయడానికి ఉపయోగపడుతుంది, కాని విషయం ఏమిటంటే, మనకు మూడు అక్షరాలు ఉన్నప్పటికీ, ఒక విలువ మాత్రమే నిర్వహించబడుతుందని మీరు గుర్తుంచుకోవాలి. (అక్షరం) ఒక విలువ మాత్రమే .
 అందువల్ల, మీరు ఆ పాత్ర యొక్క విలువను చేరుకున్నప్పుడు మీరు పేర్కొన్న అక్షరం (అక్షరం) చెల్లుబాటు అవుతుంది.
 మీరు వేరే అక్షరాన్ని ఉపయోగిస్తే, చివరిగా కేటాయించిన దాని నుండి మీరు unexpected హించని ఫలితాలను పొందుతారు.
 కాబట్టి, మీరు ఈ యాక్సెస్ కోడ్‌లో కొంచెం జాగ్రత్తగా చూస్తే, మేము ఐడాటాను మాకు కేటాయించిన కోడ్ యొక్క మొదటి భాగంలో మీరు చూస్తారు, ఆపై మేము ఐడాటాను యాక్సెస్ చేస్తాము, కాబట్టి 2 ముద్రించబడుతుంది.
 డబుల్ డేటాలో, మేము 2.2 నుండి 2.5 డేటాను డబుల్ యాక్సెస్ చేస్తాము, కాబట్టి మనం 2.2 ని యాక్సెస్ చేసే డబుల్ డేటా ముద్రించబడుతుంది.
 చార్ (డేటా) లో, మేము స్థిరమైన అక్షరాన్ని అందిస్తాము, మేము దానిని ప్రింట్ చేస్తాము a.
 అందువల్ల, మీరు చివరిగా ఉపయోగించిన వాటిని మేము ప్రింట్ చేస్తాము.
 ఇప్పుడు, తరువాతి కాలంలో, మేము ఒక ఆసక్తికరమైన విషయాన్ని చూపిస్తాము, ఇది మేము 97 కి కేటాయించిన iData లో పూర్ణాంక భాగాన్ని ఇచ్చాము, ఆపై మనకు పూర్ణాంక డేటాకు ప్రాప్యత ఉంది; స్పష్టంగా, 97 చివరిగా ముద్రించబడింది.
 మేము ఏమీ మాట్లాడకుండా దానిని dData గా యాక్సెస్ చేస్తే, మీకు 2.1999 లభిస్తుంది, అది చాలా అర్ధవంతం కాదు.
 కాబట్టి, ఇది జరుగుతోంది ఎందుకంటే dData డబుల్ డేటాలో 8 బైట్ల పరిమాణం రెట్టింపు; మీరు iData ని కేటాయించినప్పుడు మీరు 4 బైట్లు మాత్రమే కేటాయించారు; మిగిలిన 4 బైట్లు కొన్ని పాత చెత్త విలువలను కలిగి ఉన్నాయి.
 కాబట్టి, మీరు dData గా పొందేది పూర్తిగా తప్పు.
 చివరి ఆసక్తికరమైన విషయం ఏమిటంటే, మీరు దానిని సి డేటాగా యాక్సెస్ చేస్తే, మీరు నిజంగా 97 ను సి డేటాగా యాక్సెస్ చేస్తున్నారు మరియు మీకు 'ఎ' ఎందుకు లభిస్తుందో చూస్తున్నారు, 'ఎ' 97 ASCII కోడ్‌ను పొందుతోంది.
 ఇప్పుడు ఆసక్తికరమైన విషయం ఏమిటంటే, సి డేటా బహుశా ఇక్కడ 1 బైట్, అంటే మీరు 4 బైట్ పూర్ణాంకానికి ఇచ్చిన 255 విలువ కలయికలను 255 కన్నా తక్కువ కలిగి ఉండవచ్చు.
 కాబట్టి, ఈ పూర్ణాంకంలో అధిక మూడు బైట్లు అన్నీ సున్నాలు అని మనం సులభంగా అర్థం చేసుకోవచ్చు.
 కాబట్టి, నేను దానిని ఒక పాత్రగా యాక్సెస్ చేసినప్పుడు నేను అక్కడ నిల్వ చేసిన 97 మాత్రమే పొందుతాను.
 కాబట్టి, నేను ఒక కోడ్ యొక్క సరైన విలువను పొందినట్లు అనిపిస్తుంది.
 నేను షెడ్ చేయడానికి ప్రయత్నిస్తున్న విషయం ఏమిటంటే ఇది నివసించే విలువ, ఎందుకంటే ఒకే మెమరీ స్థలం మాత్రమే ఉంది; మీరు యూనియన్ ఉపయోగిస్తున్నప్పుడు దీని గురించి చాలా జాగ్రత్తగా ఉండాలి.
 మీరు ఒక సమితిని సృష్టించాలనుకుంటే, మీరు వివిధ రకాల డేటాతో వ్యవహరించగల కంటైనర్‌ను సృష్టించాలనుకుంటే, మీరు సాధారణంగా ఆ రకమైన సూచనను ఇవ్వాలి, ఇక్కడ యూనియన్ ఉపయోగించబడుతుంది. మీరు నెట్‌వర్క్ కనెక్షన్ గురించి ఆలోచిస్తే, మరియు మీకు వివిధ రకాల డేటా వస్తున్న నెట్‌వర్క్ పోర్ట్ ఉంటే, వివిధ రకాల డేటా ప్యాకెట్లు వస్తున్నాయి., మరియు సాధ్యమైన ప్యాకెట్ నుండి ఎలాంటి డేటా ప్యాకెట్ వస్తుందో మీకు తెలియదు.
 ఏ సమయంలోనైనా ఒక రకమైన డేటా ప్యాకెట్ మాత్రమే వస్తుందని మీకు తెలుసు, ఒక డేటా ప్యాకెట్ మాత్రమే వస్తుంది, అప్పుడు ఈ డేటా ప్యాకెట్‌ను నిల్వ చేయడానికి ప్రోగ్రామింగ్ నిర్మాణాన్ని మీరు ఎలా పొందుతారు? నిర్వచించండి.
 ఇప్పుడు, మీరు ఈ 10 రకాల డేటా ప్యాకెట్లను నిల్వ చేసే అవకాశం ఉన్న నిర్మాణాన్ని సృష్టించడం ఇష్టం లేదు, ఎందుకంటే ఇది అనవసరంగా ఎక్కువ స్థలాన్ని తీసుకుంటుంది.
 అదే సమయంలో, ఒక రకమైన ప్యాకెట్ 1.0 సమయానికి మాత్రమే వస్తుందనే వాస్తవాన్ని ఉపయోగించి మీరు ఈ యూనియన్ నిర్మాణాన్ని ఒక సేకరణగా ఉపయోగించవచ్చు, ఇది సి లో ఎలా ఉపయోగించబడుతుందో కూడా.
 ఈ సందర్భంలో సి ++ లోని ఈ అసోసియేషన్ భావన చాలా చిక్కులను కలిగి ఉంటుంది. సి ++ మాకు వారసత్వం మరియు స్పెషలైజేషన్ అని పిలువబడే ఆబ్జెక్ట్ ఓరియంటేషన్ ఆధారంగా చాలా బలమైన లక్షణాన్ని ఇస్తుంది.
 యూనియన్‌ను ఉపయోగించకుండా C ++ లో ఇలాంటి ప్రభావాలను ఎలా సృష్టించవచ్చో మేము చూస్తాము, కాబట్టి ఇది మీ వ్యాఖ్యల కోసం మాత్రమే, మేము C ++ స్థాయికి వెళ్ళినప్పుడు వివరాలతో ముందుకు వస్తాము.
 (ఇప్పుడు సి అనేది ప్రోగ్రామింగ్ యొక్క అత్యంత ఆసక్తికరమైన మరియు శక్తివంతమైన లక్షణాలలో ఒకటి.
 సి ప్రోగ్రామింగ్, మీరు భాష యొక్క చరిత్ర గురించి కొంచెం తెలిసి ఉంటే, మరియు దానిని మీకు పరిచయం చేయడానికి నేను తగిన పాయింట్ కావాలనుకుంటే, సి మొదట కంప్యూటర్ శాస్త్రవేత్తల బృందం, విశ్వవిద్యాలయంలోని ప్రొఫెసర్లు, మరియు ఒక నిపుణుల సమూహం, మేము ఒక ఆపరేటింగ్ సిస్టమ్‌ను వ్రాయడానికి ప్రయత్నిస్తున్నాము, ఇది తరువాత యునిక్స్ వలె ప్రాచుర్యం పొందింది, మీరందరూ లైనక్స్‌ను ఉపయోగిస్తున్నారు, ఇది చాలా తరువాతి తరం.
 అందువల్ల, వారు యునిక్స్ రాయడానికి ప్రయత్నిస్తున్నప్పుడు, వారు యునిక్స్ కోసం కోడ్ రాయడానికి ప్రయత్నిస్తున్నారు, వారికి ప్రోగ్రామింగ్ లాంగ్వేజ్ అవసరం, లేకపోతే మీరు ఎలా స్పెల్లింగ్ చేయాలో కోడ్ (కోడ్) రాయాలనుకుంటున్నారు.
 ఇప్పుడు యునిక్స్కు ముందు, మీరు సి లేదా సి ++ లేదా జావా లేదా పైథాన్‌లో చూసే ఉన్నత-స్థాయి ప్రోగ్రామింగ్ భాష లేదు, ఇక్కడ మీరు ఆపరేటింగ్ సిస్టమ్‌ను వ్రాయగలరు, ఎందుకంటే మీరు ఆపరేటింగ్ చేసేటప్పుడు మీరు సిస్టమ్ రాయాలనుకుంటే, మీరు డాన్ విలువలతో వ్యవహరించాల్సిన అవసరం లేదు, కానీ మీరు మెమరీతో కూడా వ్యవహరించాలి.
 ఎందుకంటే ప్రోగ్రామ్‌లు చివరికి మెమరీలో నిల్వ చేయబడతాయి, ఇక్కడ డేటా మెమరీలో ఉంటుంది.
 కాబట్టి, మేము ఒక ప్రోగ్రామ్ వ్రాసేటప్పుడు, మేము వేరియబుల్స్‌తో మాత్రమే పని చేస్తున్నాము, మనకు విలువల గురించి మాత్రమే ఆసక్తి ఉంది.
 ఈ ఆలోచనలు జ్ఞాపకశక్తిలో నిల్వ చేయబడటం గురించి ఆలోచించకుండా మేము పైథాన్ లేదా జావాలో మొత్తం ప్రోగ్రామ్‌ను వ్రాయగలము, కాని మీరు ఆపరేటింగ్ సిస్టమ్‌ను వ్రాయలేరని అనుకుందాం.
 మీరు ప్రోగ్రామింగ్ భాష యొక్క మెమరీ లేదా విలువ నిల్వ చేయబడిన చిరునామాను తెలుసుకోవాలి.
 కాబట్టి ఇది వివిధ కారణాలలో ఒకటి, దీనికి కెర్నింగ్, రిట్చీ, మోరిస్ హిర్ మరియు ఇతరుల బృందం, మేము యునిక్స్ బృందంలో ఉన్నాము, ఇది ప్రోగ్రామింగ్ భాష చేయడానికి ఉపయోగించాల్సిన అవసరం ఉంది, మరియు వారు త్వరగా సి , తరువాత ఇది వారికి డిఫాల్ట్ భాషగా మారింది.
 మనమందరం, వారు చెప్పినట్లుగా, చరిత్ర, కానీ సి మొదట చిరునామాలను డేటాగా నిర్వహించడం మరియు మనం పాయింటర్ అని పిలిచే బలమైన భావనను ప్రవేశపెట్టింది. (పాయింటర్).
 మీకు ఇది ఎందుకు అవసరమో నేను మీకు చెప్పాలనుకుంటున్నాను, కానీ చిరునామాలతో వ్యవహరించే ఈ లక్షణం మీకు ఉన్నప్పుడు, సి చాలా బలమైన నేపథ్యాన్ని ఇస్తుంది; దీనిలో మీరు ఇప్పటికే చేసిన విధంగా సి వివిధ రకాల డేటా నిర్మాణాలను సృష్టించగలదు.
 మీరు పాయింటర్లు లేకుండా జాబితా చేయడం గురించి కూడా ఆలోచించలేరు; ఇది సాధ్యమే, మీరు రెండు శ్రేణులను ఉపయోగించి లింక్డ్ జాబితాను సృష్టించే అవకాశం ఉంది.
 మీరు తదుపరి మూలకాన్ని పొందే సూచికను ఉంచడానికి శ్రేణి; వాస్తవానికి విలువలకు మరొక శ్రేణి ఉంది, కానీ ఇది ఏమీ కాదు, ఇది సమర్థవంతంగా ఉంటుంది, ఇది ప్రజలు ఏమి చేయగలదో కొలవగలది; అందువల్ల, మీరు ఎల్లప్పుడూ పాయింటర్లను ఉపయోగిస్తారు.
 అందువల్ల, మీ అందరికీ తెలిసినట్లుగా పాయింటర్లు తదుపరి ఉత్పన్నమైన రకం.
 కాబట్టి, ఇది వేరియబుల్, దీని విలువ మెమరీ చిరునామా.
 మరియు పాయింటర్ రకం పాయింటర్ చేత నిర్ణయించబడుతుంది, అన్ని పాయింటర్లు చిరునామాలు.
 కాబట్టి, ఒకే రకాన్ని కలిగి ఉన్న చిరునామా సూచించిన రకం, కానీ అవి వాస్తవానికి ఏ రకమైన విలువను సూచిస్తున్నాయో వాటి ఆధారంగా నిర్ణయించబడుతుంది.
 కాబట్టి, నాకు int * ip ఉంటే అది పూర్ణాంక రకం విలువను సూచిస్తుంది.
 కాబట్టి, ఇది int int అని టైప్ చేస్తాం.
 ఇప్పుడు, పాయింటర్‌ను ఉపయోగించడానికి, మీకు బాగా తెలిసి ఉంటుంది, అప్పుడు నేను 20 కి ప్రారంభించే వేరియబుల్ కలిగి ఉండవచ్చు, నేను సూచించడానికి ఉపయోగించే పాయింట్ ఐపి ఉంది, ఇది Int * IP మరియు ఒక నిర్దిష్ట ఆపరేటర్ ఆంపర్సండ్. మీరు ఈ వేరియబుల్ నిల్వ చేయబడే మెమరీ స్థానం యొక్క చిరునామాను పొందడానికి నేను ఏదైనా వేరియబుల్ను ఉపయోగించవచ్చని తెలుసు.
 కాబట్టి, నేను ఆ చిరునామాను తీసుకొని ఆ చిరునామాను పాయింటర్ వేరియబుల్ IP లో నిల్వ చేయగలను.
 నేను ఆ పని చేసిన తర్వాత, నేను వేరియబుల్ i లేదా i యొక్క చిరునామాను ప్రింట్ చేయడానికి ప్రయత్నిస్తే, నేను చిరునామా లేదా IP యొక్క విలువను ప్రింట్ చేస్తాను, ఇది వాస్తవానికి నేను ఇక్కడ నిల్వ చేసిన చిరునామా, అవి ఖచ్చితంగా మనతో సమానంగా ఉంటాయి ఇక్కడ చూపిస్తుంది.
 ఇప్పుడు ఆ చిరునామాను చూస్తే, నక్షత్రం లేదా ఆపరేటర్ యొక్క విషయాలను ఉపయోగించి సూచించిన ప్రదేశంలో ఏ విలువ ఉందో నేను నిజంగా తెలుసుకోగలను.
 అందువల్ల, ఇక్కడ పాయింటర్‌తో, మేము ఎల్లప్పుడూ ఆపరేటర్ల విషయాలను అలాగే చిరునామాను ఉపయోగిస్తాము.
 ఇప్పుడు పాయింటర్లను అనేక రకాలుగా ఉపయోగించవచ్చు; ప్రోగ్రామింగ్ భాషలో వివిధ ఇడియమ్స్‌ను రూపొందించడంలో ఆయన చాలా శక్తివంతుడు.
 మొదటి మరియు సర్వసాధారణం పాయింటర్ మరియు శ్రేణి మధ్య ద్వంద్వత్వం; మరియు ఒక డైమెన్షనల్ అర్రే సందర్భంలో చాలా సులభంగా కనిపిస్తుంది.
 కాబట్టి, శ్రేణి అనేది స్థలాల శ్రేణి; మరియు పాయింటర్ అనేది శ్రేణి యొక్క ప్రారంభ స్థానం యొక్క చిరునామా.
 అందువల్ల, నేను శ్రేణిని తీసుకొని దానిని పాయింటర్ వేరియబుల్‌కు కేటాయించగలను.
 ఆపై నేను * p చేస్తే, అది శ్రేణి యొక్క ప్రారంభ స్థలంలో 0 గా ఉండే కంటెంట్‌ను ఇస్తుంది, అది 0 అవుతుంది.
 నేను ఒక పాయింటర్‌ను పెంచగలను మరియు ఇది చాలా ఆసక్తికరమైన అంశం, నేను ఒక పాయింటర్‌ను పెంచుకుంటే, అది పెరిగిన మొత్తం 1 కాదు, అది పెంచిన మొత్తం ఇది సూచించే మూలకం యొక్క ఆకారం అది సూచించే విలువ రకానికి.
 కాబట్టి, ఇది ఒక పూర్ణాంకానికి సూచిస్తుంటే మరియు సిస్టమ్‌లోని సైజుఆఫ్ (పూర్ణాంకానికి) 4 అయితే, పాయింటర్ విలువ వాస్తవానికి 4 పెరుగుతుంది, తద్వారా శ్రేణి పరంగా మీరు ఇప్పుడు మరొక ప్రదేశానికి గురిపెడుతున్నారు.
 కాబట్టి, నేను * + + p చేస్తే, అది మొదట పెరుగుతుందని మీరు చూడవచ్చు.
 కాబట్టి, ఇది ఇప్పుడు 1 మూలకానికి గురిపెట్టి, ఆపై 1 మూలకాన్ని తీసుకుంటుంది, ఇది ప్రాథమికంగా 2.
 అదేవిధంగా, నేను p + 1 ను వ్యక్తీకరణగా తీసుకోవచ్చు, p + 1; అదేవిధంగా, పాయింటర్ యొక్క ప్రస్తుత స్థానం ప్లస్ 1 మూలకం పరిమాణం కావచ్చు.
 పాయింటర్లను నిర్మాణాలతో ఉపయోగించవచ్చు, మనం దానిని ఉపయోగిస్తే * p ద్వారా మూలకాలను యాక్సెస్ చేయవచ్చు, ఆపై * p అనేది డాట్ రికి సూచించే ఒక నిర్మాణం, ఇది ఆ నిర్మాణం యొక్క పాత్ర.
 ఇది D రిఫరెన్స్ ఆపరేటర్ చేత కత్తిరించబడుతుంది ఎందుకంటే ఇది C లో ఇవ్వబడింది, మీకు ఇవన్నీ తెలుసు.
 అందువల్ల, మేము దానిని వదిలివేస్తే, డైనమిక్ కేటాయింపు సందర్భంలో కూడా పాయింటర్లను ఉపయోగించవచ్చు.
 అందువల్ల, నేను మాలోక్ ఉపయోగించి డైనమిక్‌గా కేటాయించగలను, మరియు పేర్కొన్న రకం లేని సూచికను నేను పొందుతాను.అది సున్నా నక్షత్రం అని మేము చెప్పగలను.
 మరియు ఆ పూర్ణాంక రకం విలువ కోసం ప్రోగ్రామర్ బలవంతంగా ఉపయోగించాల్సిన కాస్టింగ్‌ను మనం ఉపయోగించవచ్చు.
 ఇది ఇక్కడ ఇచ్చిన ఆసక్తికరమైన కోడ్, నేను వివరాల ద్వారా వెళ్ళను; పాయింటర్లను మార్చటానికి ఈ కోడ్ ఎలా పనిచేస్తుందో అర్థం చేసుకోవడానికి ప్రయత్నించండి.
 మీకు ఏవైనా ప్రశ్నలు ఉంటే, మీరు బ్లాగులో మమ్మల్ని అడగవచ్చు.
 మరియు శ్రేణులను డైనమిక్‌గా కేటాయించడానికి మేము పాయింటర్లను ఉపయోగించవచ్చు.
 దీనితో, రీక్యాప్ యొక్క ఈ భాగంలో, మేము ప్రధానంగా వేర్వేరు ఉత్పన్న రకాలను గురించి మాట్లాడాము.
 మొదట, మేము కంటైనర్లు, శ్రేణులు, నిర్మాణాలు మరియు సంఘాల గురించి మాట్లాడాము; సి అందించే మూడు ప్రధాన రకాల కంటైనర్లు; మరియు మేము పాయింటర్ల ద్వారా వివిధ వేరియబుల్స్ మరియు చిరునామాలను నిర్వహించడం గురించి మాట్లాడాము.
 తరువాత, మేము ఫంక్షన్ల గురించి మాట్లాడుతాము.