పైన చూపిన ఉదాహరణలో, స్ట్రింగ్ యొక్క పొడవు p 6 ఉంది.
ఈ ట్యుటోరియల్‌లో, ముందుగా, a ని ఎలా ఉపయోగించాలో మేము చూపుతాము వినియోగదారు నిర్వచించిన ఫంక్షన్ స్ట్రింగ్ యొక్క పొడవును లెక్కించడానికి, ఆపై మేము మీకు అంతర్నిర్మిత లైబ్రరీ ఫంక్షన్‌ను చూపుతాము strlen () . దీని ఉపయోగాలను కూడా మేము మీకు చూపుతాము పరిమాణం స్ట్రింగ్ లిటరల్స్ కోసం ఆపరేటర్.
వినియోగదారు నిర్వచించిన ఫంక్షన్ ఉపయోగించి స్ట్రింగ్ పొడవు
స్ట్రింగ్‌లోని అక్షరాల సంఖ్యను అందించే యూజర్ నిర్వచించిన ఫంక్షన్‌ను మీరు వ్రాయవచ్చు.
// ఉదాహరణ 1..సి
#చేర్చండి
intస్ట్రింగ్ పొడవు(చార్ *p)
{
inti=0;
అయితే(p[i] ! = ' 0')i++;
తిరిగిi;
}
intప్రధాన()
{
చార్p[30]= 'STRING';
printf (స్ట్రింగ్ స్ట్రింగ్ పొడవు => %d n',స్ట్రింగ్ పొడవు(p));
తిరిగి 0;
}
ఇక్కడ, మేము నుండి లూప్‌ను పునరుద్ఘాటిస్తాము i = 0 మేము ఎదుర్కోనంత వరకు ‘ 0’ పాత్ర. యొక్క విలువ i ద్వారా పెరుగుతుంది 1 అయితే లూప్ యొక్క ప్రతి పునరుక్తిలో. లూప్ ముగిసినప్పుడు, విలువ i స్ట్రింగ్ యొక్క పొడవు.
అంతర్నిర్మిత లైబ్రరీ ఫంక్షన్ ఉపయోగించి స్ట్రింగ్ పొడవు
అంతర్నిర్మిత లైబ్రరీ ఫంక్షన్ strlen () స్ట్రింగ్ పొడవును గుర్తించడానికి కూడా ఉపయోగించవచ్చు.
strlen () ఫంక్షన్:
హెడర్ ఫైల్:
స్ట్రింగ్.hవాక్యనిర్మాణం:
పరిమాణం_టి strlen (కానిస్టేట్ చార్ *p)వాదన: ఈ ఫంక్షన్ చార్ టైప్ పాయింటర్ యొక్క వాదనను తీసుకుంటుంది.
రిటర్న్ విలువ: ఈ ఫంక్షన్ స్ట్రింగ్ పొడవును అందిస్తుంది p . అది గమనించండి పరిమాణం_టి కేవలం సంతకం చేయని పూర్ణాంకం యొక్క మారుపేరు.
// ఉదాహరణ 2.సి#చేర్చండి
#చేర్చండి
intప్రధాన()
{
చార్str1[30]='స్ట్రింగ్ అర్రే';
చార్ *str2;
చార్ *str3;
str2=str1;
str3= 'స్ట్రింగ్ పాయింటర్';
printf (స్ట్రింగ్ str1 యొక్క పొడవు => %ld n', strlen (str1));
printf (స్ట్రింగ్ str2 యొక్క పొడవు => %ld n', strlen (str2));
printf (స్ట్రింగ్ str3 యొక్క పొడవు => %ld n', strlen (str3));
printf ('స్ట్రింగ్ పొడవు'స్ట్రింగ్ సాహిత్యాలు'is => %ld n', strlen ('స్ట్రింగ్ లిటరల్స్'));
తిరిగి 0;
}
ఇక్కడ, మేము స్ట్రింగ్ అర్రే, స్ట్రింగ్ పాయింటర్ మరియు స్ట్రింగ్ ఫంక్షన్‌కు స్ట్రింగ్ అక్షరాలను పాస్ చేస్తాము మరియు ఫంక్షన్ స్ట్రింగ్ పొడవును అందిస్తుంది.
సైజ్ ఆఫ్ ఆపరేటర్ ఉపయోగించి స్ట్రింగ్ పొడవు
మేము కూడా ఉపయోగించవచ్చు పరిమాణం స్ట్రింగ్ పొడవు కోసం ఆపరేటర్ (స్ట్రింగ్ సాహిత్యానికి మాత్రమే). కానీ, ఈ ఆపరేటర్ తిరిగి ఇచ్చే విలువ నుండి మనం 1 ని తీసివేయాలి, ఎందుకంటే ఇది ' 0' అక్షరాన్ని కూడా లెక్కిస్తుంది. శ్రేణి మరియు పాయింటర్ కోసం, సైజ్ ఆఫ్ ఆపరేటర్ వరుసగా కేటాయించిన పరిమాణ శ్రేణి మరియు పాయింటర్‌ను అందిస్తుంది.
// ఉదాహరణ 3. సి#చేర్చండి
intప్రధాన()
{
చార్str1[30] = 'STRING';
చార్ *str2=str1;
printf ('పొడవు'STRING'= = %d n',(పరిమాణం('STRING') - 1));
printf ('Str1 శ్రేణి యొక్క కేటాయించిన పరిమాణం => %d n',పరిమాణం(str1));
printf ('Str2 పాయింటర్ పరిమాణం => %d n',పరిమాణం(str2));
తిరిగి 0;
}
ఇక్కడ, లైన్ నం 9 లో, మేము స్ట్రింగ్ అక్షర STRING ని పాస్ చేసి, ' 0' అక్షరంతో సహా పరిమాణాన్ని పొందుతాము. కాబట్టి, మేము 1 ని తీసివేసి, స్ట్రింగ్ యొక్క వాస్తవ పరిమాణాన్ని పొందుతాము.
మేము సైజ్ ఆఫ్ ఆపరేటర్‌కు ఒక శ్రేణిని పాస్ చేసినప్పుడు, అది కేటాయించిన శ్రేణి పరిమాణాన్ని అందిస్తుంది, ఇది 30, మరియు క్యారెక్టర్ పాయింటర్‌ను పాస్ చేసేటప్పుడు, అది పాయింటర్ పరిమాణాన్ని అందిస్తుంది.
ముగింపు
కాబట్టి, ఈ ట్యుటోరియల్‌లో, స్ట్రింగ్ పొడవును వివిధ మార్గాల్లో ఎలా లెక్కించవచ్చో మేము మీకు చూపించాము. మీ కోడ్‌లో మీకు ఏ పద్ధతి బాగా సరిపోతుందో మీరు ఉపయోగించవచ్చు.