ప్రోగ్రామింగ్ లో, శూన్యం అనేది C, C++ మరియు C#లలో ఉపయోగించే కీలక పదం, ఇది విలువ లేకపోవడాన్ని సూచిస్తుంది. ఇది ఏ విలువ లేదా మెమరీ కేటాయింపును కలిగి లేని డేటా రకం. బదులుగా, ఇది విలువను అందించని లేదా ప్రోగ్రామ్‌ను ముగించడానికి రూపొందించబడిన ఫంక్షన్‌ల కోసం ప్లేస్‌హోల్డర్‌గా లేదా మార్కర్‌గా ఉపయోగించబడుతుంది.
C, C++ మరియు C#లలో శూన్య వినియోగం గురించి తెలుసుకోవడానికి ఈ కథనం యొక్క మార్గదర్శకాలను అనుసరించండి.
C, C++ మరియు C#లో శూన్యం అంటే ఏమిటి
ది శూన్యం C, C++ మరియు C# లలో అర్థం ఒకటే కానీ మీరు ఉపయోగించే ప్రోగ్రామింగ్ భాషను బట్టి దాని ఉపయోగం మారవచ్చు.
C లో శూన్యం
C లో, మీరు ఉపయోగించండి శూన్యం ఏ విలువను అందించని ఫంక్షన్‌ను ప్రకటించడానికి (రిటర్న్ ఆర్గ్యుమెంట్ లేదు). ఉదాహరణకు, ఒక సందేశాన్ని ప్రదర్శించే లేదా ఫలితాన్ని అందించకుండా విధిని ప్రదర్శించే ఫంక్షన్ సాధారణంగా ప్రకటించబడుతుంది శూన్యం . C లో అటువంటి ఫంక్షన్ యొక్క ఉదాహరణ క్రింద చూపబడింది:
#include
శూన్యం మొత్తం ( int a , int బి ) {
printf ( 'ఇది రిటర్న్ రకం లేని ఫంక్షన్ \n ' ) ;
printf ( 'a మరియు b మొత్తాన్ని ముద్రించడం: %d' , a + బి ) ;
}
int ప్రధాన ( ) {
మొత్తం ( 5 , 1 ) ;
తిరిగి 0 ;
}
పై కోడ్‌లో, మేము a ఉపయోగిస్తున్నాము శూన్యం ఫంక్షన్ sum() ఒక సందేశాన్ని ప్రింట్ చేయడానికి మరియు రెండు వేరియబుల్స్ మొత్తాన్ని, మరియు sum()ని ప్రధాన() ఫంక్షన్‌లో పిలుస్తారు.
అవుట్‌పుట్
కొన్ని సందర్భాల్లో, పాయింటర్‌కు సూచించడానికి ఎటువంటి మెమరీ లొకేషన్ ఉండకపోవచ్చు మరియు అలాంటి సందర్భాలలో, మేము దీనిని ఉపయోగిస్తాము శూన్యం పాయింటర్. ఎ శూన్యం పాయింటర్ అనేది దాని రకం లేదా పరిమాణంతో సంబంధం లేకుండా ఏదైనా డేటా రకం లేదా వస్తువు యొక్క చిరునామాను కలిగి ఉండే ప్రత్యేక రకం పాయింటర్. అయితే, ది శూన్యం పాయింటర్ ఏదైనా నిర్దిష్ట డేటా రకం లేదా ఆబ్జెక్ట్‌ని సూచించనందున నేరుగా సూచించబడదు.
#includeint ప్రధాన ( ) {
int a = 4 ;
చార్ బి = 'ఎ' ;
శూన్యం * ptr = & a ;
int * a2 = ( int * ) ptr ;
printf ( 'పూర్ణాంకం: %d \n ' , * a2 ) ;
ptr = & బి ;
చార్ * b2 = ( చార్ * ) ptr ;
printf ( 'పాత్ర: %c \n ' , * b2 ) ;
తిరిగి 0 ;
}
పైన ఉన్న C కోడ్‌లో, మేము a ఉపయోగిస్తున్నాము శూన్యం మెయిన్() ఫంక్షన్‌లోని పాయింటర్ మరియు పాయింటర్ పూర్ణాంకం అయిన వేరియబుల్ a వైపు చూపబడుతుంది మరియు దాని విలువను ముద్రిస్తుంది. పాయింటర్ అప్పుడు ఒక అక్షరం అయిన వేరియబుల్ bకి సూచించబడుతుంది మరియు విలువ ముద్రించబడుతుంది.
అవుట్‌పుట్
C++లో శూన్యమైన కీవర్డ్
C++లో, ఉపయోగం శూన్యం C లో ఫంక్షన్‌లు మరియు పాయింటర్‌లకు మాత్రమే పరిమితం కాదు. ఇది ఫంక్షన్ పారామితుల కోసం ఒక రకంగా కూడా ఉపయోగించబడుతుంది, ఇది ఫంక్షన్‌కు పంపబడిన నిర్దిష్ట ఆర్గ్యుమెంట్‌కు నిర్దిష్ట డేటా రకం లేదా విలువ లేదని సూచిస్తుంది. ఉదాహరణకు, C++లోని మెయిన్() ఫంక్షన్‌కు ఎటువంటి వాదనలు అవసరం లేదు మరియు ప్రకటించవచ్చు శూన్యం . ఒక ఉదాహరణ క్రింద చూపబడింది:
#ఉపయోగించి నేమ్‌స్పేస్ std ;
శూన్యం సందేశం ( శూన్యం )
{
కోట్ << 'నేను ఒక ఫంక్షన్!' ;
}
int ప్రధాన ( శూన్యం )
{
సందేశం ( ) ;
}
పైన ఉన్న C++ కోడ్‌లో, మేము ఉపయోగిస్తున్నాము శూన్యం ఫంక్షన్ సందేశం() కోసం ఫంక్షన్ పారామీటర్‌గా ఫంక్షన్ సందేశం() నుండి కాల్ చేసినప్పుడు అవుట్‌పుట్ ముద్రించబడుతుంది శూన్యం ప్రధాన () ఫంక్షన్.
అవుట్‌పుట్
C#లో శూన్యమైన కీవర్డ్
C#లో శూన్యం దేన్నీ తిరిగి ఇవ్వని పద్ధతుల కోసం రిటర్న్ రకంగా ఉపయోగించబడుతుంది. ఇందులో ఎటువంటి విలువను అందించని ఫంక్షన్‌లు, అలాగే కన్‌స్ట్రక్టర్‌లు, డిస్ట్రక్టర్‌లు మరియు ఈవెంట్ హ్యాండ్లర్‌లు ఉంటాయి. ఒక పద్ధతి ఉన్నప్పుడు a శూన్యం రిటర్న్ రకం, ఇది వేరియబుల్‌కు కేటాయించబడదు లేదా వ్యక్తీకరణలో ఉపయోగించబడదు. ఒక ఉదాహరణ శూన్యం C#లో పద్ధతి క్రింద చూపబడింది:
ఉపయోగించి వ్యవస్థ ;తరగతి GFG {
ప్రజా శూన్యం వచనం ( )
{
కన్సోల్ . రైట్ లైన్ ( 'Linux' ) ;
}
ప్రజా శూన్యం మొత్తం ( int a, int బి )
{
కన్సోల్ . రైట్ లైన్ ( 'బహుళ =' + ( a * బి ) ) ;
}
} ;
తరగతి ప్రోగ్ {
స్థిరమైన శూన్యం ప్రధాన ( స్ట్రింగ్ [ ] ఆర్గ్స్ )
{
GFG మాజీ = కొత్త GFG ( ) ;
ఉదా . వచనం ( ) ;
ఉదా . మొత్తం ( 5 , ఇరవై ) ;
}
}
పైన ఉన్న C# కోడ్‌లో, రెండు శూన్యం టెక్స్ట్() మరియు సమ్() అనే ఫంక్షన్‌లు ప్రకటించబడ్డాయి, ఆపై ఈ ఫంక్షన్‌లు దీని నుండి పిలువబడతాయి శూన్యం ప్రధాన () ఫంక్షన్.
అవుట్‌పుట్
ముగింపు
శూన్యం విలువ లేకపోవడాన్ని సూచించడానికి C, C++ మరియు C# వంటి ప్రోగ్రామింగ్ భాషలలో ఉపయోగించే కీవర్డ్. ఇది ఏదైనా తిరిగి ఇవ్వని విధులు మరియు పద్ధతులను ప్రకటించడానికి మరియు ప్రత్యేకంగా C++లో ఫంక్షన్ పారామీటర్‌గా ఉపయోగించబడుతుంది. ఎలా ఉపయోగించాలో అర్థం చేసుకోవడం శూన్యం సమర్థవంతమైన మరియు ఫంక్షనల్ కోడ్ రాయడానికి సరిగ్గా అవసరం.