నిర్దిష్ట సేవను ఉపయోగించే వినియోగదారుల గురించి మేము సమాచారాన్ని నిల్వ చేయాలనుకుంటున్నాము. అలాంటి సమాచారం యూజర్ పేరు, ఇమెయిల్, చిరునామా, సర్వీస్ మోడ్ మరియు వంటి వాటిని కలిగి ఉంటుంది. అటువంటి సమాచారాన్ని నిల్వ చేయడానికి, మేము ప్రతి లక్షణాన్ని స్వతంత్ర చరరాశిగా సృష్టించడం గురించి వెళ్ళవచ్చు. అయితే, మాకు పదిమంది కంటే ఎక్కువ మంది వినియోగదారులు ఉన్నప్పుడు, కోడ్ అదుపు తప్పి, చదవడానికి చాలా కష్టంగా మరియు అలసిపోతుంది.
దీనిని పరిష్కరించడానికి, మేము ఒక నిర్మాణాన్ని సృష్టించవచ్చు. నిర్మాణం లోపల, మేము వినియోగదారులందరూ పంచుకున్న అన్ని లక్షణాలను నిల్వ చేయవచ్చు మరియు ప్రతి వినియోగదారుకు ప్రత్యేకమైన వేరియబుల్స్ జోడించవచ్చు.
దీన్ని ఎలా అమలు చేయాలో చూడటానికి వివిధ ఉదాహరణలను చూద్దాం.
C లో నిర్మాణాన్ని ఎలా నిర్వచించాలి
C లోని నిర్మాణాన్ని నిర్వచించడానికి, మేము స్ట్రక్చర్ పేరు తర్వాత స్ట్రక్ట్ కీవర్డ్‌ని ఉపయోగిస్తాము. పేరు తర్వాత, మేము సభ్యులను జోడించే ఒక జత గిరజాల జంట కలుపులు ఉన్నాయి.
దిగువ వాక్యనిర్మాణాన్ని పరిగణించండి:
నిర్మాణాత్మకనిర్మాణాత్మక_పేరు{
/* సమాచారం */
సభ్యుడు_ పేరు టైప్ చేయండి;
సభ్యుడు_పేరు 2 అని టైప్ చేయండి;
సభ్యుడు_పేరు 3 అని టైప్ చేయండి;
...
రకంసభ్యుడు_పేరు ఎన్;
};
సి ప్రోగ్రామింగ్ లాంగ్వేజ్ యొక్క నామకరణ సంప్రదాయానికి కట్టుబడి ఉన్నంత వరకు నిర్మాణం పేరు మీకు కావలసినది ఏదైనా కావచ్చు.
మేము వినియోగదారు సారూప్యత యొక్క ఉదాహరణ నిర్మాణాన్ని ఇలా అమలు చేయవచ్చు:
నిర్మాణాత్మకవినియోగదారులు{
చార్వినియోగదారు పేరు[ఇరవై];
చార్ఇమెయిల్[225];
చార్చిరునామా[యాభై];
intవయస్సు;
బూల్ నమోదు చేయబడింది;
};
స్ట్రక్చర్ వేరియబుల్స్ ఎలా సృష్టించాలి
స్ట్రక్చర్ వేరియబుల్స్ సృష్టించడానికి రెండు ప్రధాన మార్గాలు ఉన్నాయి. మొదటిది వాటిని సాధారణ వేరియబుల్స్ లాగా ప్రకటించడం, మరొకటి గిరజాల బ్రేస్‌లను ఉపయోగించి వాటిని సెట్ చేయడం.
కింది ఉదాహరణ స్ట్రక్చర్ వేరియబుల్స్‌ను స్టాండర్డ్ సి వేరియబుల్స్‌గా ఎలా డిక్లేర్ చేయాలో చూపుతుంది.
నిర్మాణాత్మకవినియోగదారులు{
చార్వినియోగదారు పేరు[ఇరవై];
చార్ఇమెయిల్[225];
చార్చిరునామా[యాభై];
intవయస్సు;
బూల్ నమోదు చేయబడింది;
};
intప్రధాన(intargc, చార్ కానిస్టేట్ *argv[])
{
నిర్మాణాత్మకవినియోగదారులు వినియోగదారు 1,వినియోగదారు 2,వినియోగదారు 3
తిరిగి 0;
}
స్ట్రక్చర్ వేరియబుల్స్ సృష్టించే ఇతర పద్ధతి క్రింద చూపిన విధంగా ఉంది:
నిర్మాణాత్మకవినియోగదారులు{
చార్వినియోగదారు పేరు[ఇరవై];
చార్ఇమెయిల్[225];
చార్చిరునామా[యాభై];
intవయస్సు;
బూల్ నమోదు చేయబడింది;
}వినియోగదారు 1,వినియోగదారు 2,వినియోగదారు 3;
ఈ ఉదాహరణలో, నిర్మాణ ప్రకటన సమయంలో మేము వాటిని సృష్టిస్తాము.
స్ట్రక్చర్ మెంబర్ ఇనిస్ట్
రకానికి మెమరీ కేటాయించబడనందున మీరు సృష్టి సమయంలో నిర్మాణ సభ్యులను ప్రారంభించలేరు.
స్ట్రక్చర్ సభ్యులను ప్రారంభించడానికి, క్రింద చూపిన విధంగా మీరు గిరజాల బ్రేస్‌లను ఉపయోగిస్తారు:
నిర్మాణాత్మకవినియోగదారులు{
చార్వినియోగదారు పేరు[ఇరవై];
చార్ఇమెయిల్[225];
చార్చిరునామా[యాభై];
intవయస్సు;
బూల్ నమోదు చేయబడింది;
};
intప్రధాన(intargc, చార్ కానిస్టేట్ *argv[])
{
నిర్మాణాత్మకవినియోగదారులు వినియోగదారు 1= {'myusername', '[ఇమెయిల్ రక్షించబడింది]', 35, నిజం}
తిరిగి 0;
}
స్ట్రక్చర్ సభ్యులను యాక్సెస్ చేయండి
ఒక స్ట్రక్చర్ సభ్యులను యాక్సెస్ చేయడానికి, మేము స్టోక్చర్ పేరు, డాట్ మరియు మెంబర్ పేరుతో మొదలుపెట్టి డాట్ ఆపరేటర్‌ను ఉపయోగిస్తాము.
నిర్మాణాత్మకవినియోగదారులు{
చార్వినియోగదారు పేరు[ఇరవై];
చార్ఇమెయిల్[225];
చార్చిరునామా[యాభై];
intవయస్సు;
బూల్ నమోదు చేయబడింది;
};
intప్రధాన(intargc, చార్ కానిస్టేట్ *argv[])
{
నిర్మాణాత్మకవినియోగదారులు వినియోగదారు 1= {'myusername', '[ఇమెయిల్ రక్షించబడింది]', 35, నిజం}
వినియోగదారు 1ఇమెయిల్ = '[ఇమెయిల్ రక్షించబడింది]'
తిరిగి 0;
}
ఈ ఉదాహరణలో, మేము యూజర్ 1 సభ్యులను యాక్సెస్ చేస్తాము.
Typedef కీవర్డ్
డేటా రకాల కోసం మారుపేరు సృష్టించడానికి మేము టైప్‌డెఫ్ కీవర్డ్‌ని ఉపయోగిస్తాము, కోడ్‌ని మరింత చదవగలిగేలా చేస్తుంది.
ఉదాహరణకి:
typedef నిర్మాణాత్మకవినియోగదారులు{
చార్వినియోగదారు పేరు[ఇరవై];
చార్ఇమెయిల్[225];
చార్చిరునామా[యాభై];
intవయస్సు;
బూల్ నమోదు చేయబడింది;
}u;
intప్రధాన(intargc, చార్ కానిస్టేట్ *argv[])
{
యూజర్ 1= {'myusername', '[ఇమెయిల్ రక్షించబడింది]', 35, నిజం}
వినియోగదారు 1నమోదు = తప్పుడు
తిరిగి 0;
}
పై ఉదాహరణలో, మేము వినియోగదారుల నిర్మాణం కోసం మారుపేరు u ని సృష్టించాము. అందువల్ల, మేము ప్రతిసారీ స్ట్రక్ట్ వినియోగదారులను పిలవాల్సిన అవసరం లేదు. పైన నిర్వచించిన విధంగా మేము మిమ్మల్ని ఉపయోగించవచ్చు.
నిర్మాణ సూచికలు
మీరు స్ట్రక్చర్‌కి పాయింటర్‌ను కూడా కలిగి ఉండవచ్చు. ఇలా చేయడం వలన మీరు -> ఆపరేటర్‌ని ఉపయోగించి సభ్యులను యాక్సెస్ చేయవచ్చు.
ఉదాహరణకి:
typedef నిర్మాణాత్మకవినియోగదారులు{
చార్వినియోగదారు పేరు[ఇరవై];
చార్ఇమెయిల్[225];
చార్చిరునామా[యాభై];
intవయస్సు;
బూల్ నమోదు చేయబడింది;
}u;
intప్రధాన(intargc, చార్ కానిస్టేట్ *argv[])
{
యూజర్ 1= {'myusername', '[ఇమెయిల్ రక్షించబడింది]', 35, నిజం}
// మరొక నిర్మాణానికి సూచిక
u*user_ptr= &వినియోగదారు 1
user_ptr->వినియోగదారు పేరు= 'ptrusername'
తిరిగి 0;
}
ముగింపు
ఈ గైడ్ సి ప్రోగ్రామింగ్ లాంగ్వేజ్‌లోని స్ట్రక్చర్‌లతో పనిచేసే ప్రాథమికాలను కవర్ చేస్తుంది.
చదివినందుకు ధన్యవాదములు!