లంబ్డా వ్యక్తీకరణ ఎందుకు?
కింది ప్రకటనను పరిగణించండి:
intmyInt= 52;ఇక్కడ, myInt ఒక ఐడెంటిఫైయర్, ఒక విలువ. 52 అనేది అక్షరార్థం, విలువ. ఈ రోజు, ఒక ఫంక్షన్‌ను ప్రత్యేకంగా కోడ్ చేయడం మరియు దానిని 52 స్థానంలో ఉంచడం సాధ్యమవుతుంది. అలాంటి ఫంక్షన్‌ను లాంబ్డా ఎక్స్‌ప్రెషన్ అంటారు. కింది చిన్న ప్రోగ్రామ్‌ని కూడా పరిగణించండి:
#చేర్చండి
ఉపయోగించి నేమ్‌స్పేస్గంటలు;
intfn(intద్వారా)
{
intసమాధానం=ద్వారా+ 3;
తిరిగిసమాధానం;
}
intప్రధాన()
{
fn(5);
తిరిగి 0;
}
ఈ రోజు, ఒక ఫంక్షన్‌ను ప్రత్యేకంగా కోడ్ చేయడం మరియు దానిని 5 యొక్క ఆర్గ్యుమెంట్ స్థానంలో ఉంచడం సాధ్యమవుతుంది, ఫంక్షన్ కాల్, fn (5). అలాంటి ఫంక్షన్‌ను లాంబ్డా ఎక్స్‌ప్రెషన్ అంటారు. ఆ స్థితిలో ఉన్న లాంబ్డా వ్యక్తీకరణ (ఫంక్షన్) ఒక విలువ.
స్ట్రింగ్ లిటరల్ తప్ప ఏదైనా సాహిత్యం అనేది ఒక ప్రావాల్యూ. లాంబ్డా వ్యక్తీకరణ అనేది ఒక ప్రత్యేక ఫంక్షన్ డిజైన్, ఇది కోడ్‌లో అక్షరాలా సరిపోతుంది. ఇది అనామక (పేరులేని) ఫంక్షన్. ఈ వ్యాసం లాంబ్డా ఎక్స్‌ప్రెషన్ అని పిలువబడే కొత్త C ++ ప్రాథమిక వ్యక్తీకరణను వివరిస్తుంది. ఈ కథనాన్ని అర్థం చేసుకోవడానికి C ++ లో ప్రాథమిక పరిజ్ఞానం అవసరం.
వ్యాసం కంటెంట్
- లాంబ్డా వ్యక్తీకరణ యొక్క ఉదాహరణ
- లంబ్డా వ్యక్తీకరణ భాగాలు
- స్వాధీనం
- లాంబ్డా ఎక్స్‌ప్రెషన్‌తో క్లాసికల్ కాల్‌బ్యాక్ ఫంక్షన్ స్కీమ్
- వెనుకంజ-తిరిగి-రకం
- మూసివేత
- ముగింపు
లాంబ్డా వ్యక్తీకరణ యొక్క ఉదాహరణ
కింది ప్రోగ్రామ్‌లో, లాంబ్డా ఎక్స్‌ప్రెషన్ అయిన ఫంక్షన్ వేరియబుల్‌కు కేటాయించబడుతుంది:
#చేర్చండి
ఉపయోగించి నేమ్‌స్పేస్గంటలు;
దానంతట అదేfn= [](intఆపు)
{
intసమాధానం=ఆపు+ 3;
తిరిగిసమాధానం;
};
intప్రధాన()
{
దానంతట అదేవేరియబ్=fn(2);
ఖరీదు <<వేరియబ్<< ' n';
తిరిగి 0;
}
అవుట్‌పుట్:
5ప్రధాన () ఫంక్షన్ వెలుపల, వేరియబుల్, fn ఉంది. దాని రకం ఆటో. ఈ పరిస్థితిలో ఆటో అంటే అసైన్‌మెంట్ ఆపరేటర్ (=) యొక్క కుడి ఒపెరాండ్ ద్వారా int లేదా float వంటి వాస్తవ రకం నిర్ణయించబడుతుంది. అసైన్‌మెంట్ ఆపరేటర్ యొక్క కుడి వైపున లాంబ్డా వ్యక్తీకరణ ఉంది. లాంబ్డా వ్యక్తీకరణ అనేది మునుపటి రిటర్న్ రకం లేని ఫంక్షన్. చదరపు బ్రాకెట్ల ఉపయోగం మరియు స్థానాన్ని గమనించండి, []. ఫంక్షన్ 5, int ని అందిస్తుంది, ఇది fn కోసం రకాన్ని నిర్ణయిస్తుంది.
ప్రధాన () ఫంక్షన్‌లో, స్టేట్‌మెంట్ ఉంది:
దానంతట అదేవేరియబ్=fn(2);దీని అర్థం, fn మెయిన్ () వెలుపల, ఫంక్షన్ కోసం ఐడెంటిఫైయర్‌గా ముగుస్తుంది. దీని అవ్యక్త పారామితులు లాంబ్డా వ్యక్తీకరణకు సంబంధించినవి. వేరియబ్ కోసం రకం ఆటో.
లాంబ్డా ఎక్స్‌ప్రెషన్ క్లాస్ లేదా స్ట్రక్ట్ నిర్వచనం వలె సెమికోలన్‌తో ముగుస్తుందని గమనించండి.
కింది ప్రోగ్రామ్‌లో, 5 విలువను తిరిగి ఇచ్చే లాంబ్డా ఎక్స్‌ప్రెషన్ అయిన ఫంక్షన్, మరొక ఫంక్షన్‌కు వాదన:
#చేర్చండిఉపయోగించి నేమ్‌స్పేస్గంటలు;
శూన్యంotherfn(intనెం 1,int (*ptr)(int))
{
intనం 2= (*ptr)(2);
ఖరీదు <<సంఖ్య 1<< '' <<నం 2<< ' n';
}
intప్రధాన()
{
otherfn(4,[](intఆపు)
{
intసమాధానం=ఆపు+ 3;
తిరిగిసమాధానం;
});
తిరిగి 0;
}
అవుట్‌పుట్:
నాలుగు ఐదుఇక్కడ రెండు విధులు ఉన్నాయి, లాంబ్డా వ్యక్తీకరణ మరియు ఇతర fn () ఫంక్షన్. లాంబ్డా వ్యక్తీకరణ అనేది ప్రధాన () అని పిలువబడే ఇతర ఎఫ్ఎన్ () యొక్క రెండవ వాదన. లాంబ్డా ఫంక్షన్ (వ్యక్తీకరణ) ఈ కాల్‌లో సెమికోలన్‌తో ముగియదని గమనించండి, ఎందుకంటే, ఇక్కడ ఇది ఒక వాదన (స్టాండ్-ఒంటరి ఫంక్షన్ కాదు).
ఇతర ఎఫ్ఎన్ () ఫంక్షన్ యొక్క నిర్వచనంలో లాంబ్డా ఫంక్షన్ పరామితి ఒక ఫంక్షన్‌కు సూచిక. పాయింటర్‌కు ptr అనే పేరు ఉంది. లాంబ్డా ఫంక్షన్‌ను పిలవడానికి ఇతర పిఎఫ్‌ఆర్ () నిర్వచనంలో పిటిఆర్ అనే పేరు ఉపయోగించబడింది.
ప్రకటన,
intనం 2= (*ptr)(2);ఇతర ఎఫ్ఎన్ () నిర్వచనంలో, లాంబ్డా ఫంక్షన్‌ను 2. ఆర్గ్యుమెంట్‌తో పిలుస్తుంది, కాల్ రిటర్న్ విలువ, '(**పిటిఆర్) (2)' లాంబ్డా ఫంక్షన్ నుండి, no2 కి కేటాయించబడుతుంది.
C ++ కాల్‌బ్యాక్ ఫంక్షన్ స్కీమ్‌లో లాంబ్డా ఫంక్షన్‌ను ఎలా ఉపయోగించవచ్చో కూడా పై ప్రోగ్రామ్ చూపుతుంది.
లంబ్డా వ్యక్తీకరణ భాగాలు
సాధారణ లాంబ్డా ఫంక్షన్ యొక్క భాగాలు క్రింది విధంగా ఉన్నాయి:
[] () {}- [] క్యాప్చర్ క్లాజ్. ఇది అంశాలను కలిగి ఉండవచ్చు.
- () పరామితి జాబితా కోసం.
- {} ఫంక్షన్ బాడీ కోసం. ఫంక్షన్ ఒంటరిగా నిలబడి ఉంటే, అది సెమికోలన్‌తో ముగుస్తుంది.
స్వాధీనం
లాంబ్డా ఫంక్షన్ నిర్వచనాన్ని వేరియబుల్‌కు కేటాయించవచ్చు లేదా వేరే ఫంక్షన్ కాల్‌కు వాదనగా ఉపయోగించవచ్చు. అటువంటి ఫంక్షన్ కాల్ కోసం నిర్వచనం లాంబ్డా ఫంక్షన్ నిర్వచనానికి అనుగుణమైన పరామితి, ఫంక్షన్‌కు పాయింటర్‌గా ఉండాలి.
లాంబ్డా ఫంక్షన్ నిర్వచనం సాధారణ ఫంక్షన్ నిర్వచనం నుండి భిన్నంగా ఉంటుంది. ఇది ప్రపంచ పరిధిలోని వేరియబుల్‌కు కేటాయించవచ్చు; ఈ ఫంక్షన్-అసైన్డ్-టు-వేరియబుల్ మరొక ఫంక్షన్ లోపల కూడా కోడ్ చేయవచ్చు. గ్లోబల్ స్కోప్ వేరియబుల్‌కు కేటాయించినప్పుడు, దాని శరీరం గ్లోబల్ స్కోప్‌లో ఇతర వేరియబుల్స్ చూడగలదు. సాధారణ ఫంక్షన్ నిర్వచనం లోపల వేరియబుల్‌కు కేటాయించినప్పుడు, దాని శరీరం ఫంక్షన్ పరిధిలో ఇతర వేరియబుల్స్‌ను క్యాప్చర్ క్లాజ్ సహాయంతో మాత్రమే చూడగలదు, [].
లాంబ్డా-ఇంట్రూసర్ అని కూడా పిలువబడే క్యాప్చర్ క్లాజ్, పరిసర (ఫంక్షన్) స్కోప్ నుండి లాంబ్డా ఎక్స్‌ప్రెషన్ ఫంక్షన్ బాడీకి వేరియబుల్స్ పంపడానికి అనుమతిస్తుంది. లాంబ్డా ఎక్స్‌ప్రెషన్ యొక్క ఫంక్షన్ బాడీ ఆబ్జెక్ట్‌ను అందుకున్నప్పుడు వేరియబుల్‌ను సంగ్రహిస్తుందని చెప్పబడింది. క్యాప్చర్ క్లాజ్ [] లేకుండా, పరిసర పరిధి నుండి లాంబ్డా ఎక్స్‌ప్రెషన్ ఫంక్షన్ బాడీకి వేరియబుల్ పంపబడదు. కింది కార్యక్రమం ప్రధాన () ఫంక్షన్ స్కోప్‌తో, పరిసర స్కోప్‌తో దీనిని వివరిస్తుంది:
#చేర్చండిఉపయోగించి నేమ్‌స్పేస్గంటలు;
intప్రధాన()
{
intid= 5;
దానంతట అదేfn= [id]()
{
ఖరీదు <<id<< ' n';
};
fn();
తిరిగి 0;
}
అవుట్‌పుట్ ఉంది 5 . పేరు, ఐడి, లోపల [] లేకుండా, లాంబ్డా వ్యక్తీకరణ ప్రధాన () ఫంక్షన్ స్కోప్ యొక్క వేరియబుల్ ఐడిని చూడలేదు.
సూచన ద్వారా సంగ్రహించడం
క్యాప్చర్ క్లాజ్ యొక్క పై ఉదాహరణ ఉపయోగం విలువ ద్వారా సంగ్రహించడం (దిగువ వివరాలను చూడండి). సూచన ద్వారా సంగ్రహించడంలో, వేరియబుల్ యొక్క స్థానం (నిల్వ), ఉదా., పైన ఉన్న ఐడి, పరిసర స్కోప్, లాంబ్డా ఫంక్షన్ బాడీ లోపల అందుబాటులో ఉంచబడింది. కాబట్టి, లాంబ్డా ఫంక్షన్ బాడీ లోపల వేరియబుల్ విలువను మార్చడం వల్ల పరిసర పరిధిలో అదే వేరియబుల్ విలువ మారుతుంది. క్యాప్చర్ క్లాజ్‌లో పునరావృతమయ్యే ప్రతి వేరియబుల్ దీనిని సాధించడానికి ఆంపర్‌సాండ్ (&) ముందు ఉంటుంది. కింది కార్యక్రమం దీనిని వివరిస్తుంది:
#చేర్చండిఉపయోగించి నేమ్‌స్పేస్గంటలు;
intప్రధాన()
{
intid= 5; తేలుతాయిఅడుగు= 2.3; చార్చ= 'TO';
దానంతట అదేfn= [&id,&అడుగు,&చ]()
{
id= 6;అడుగు= 3.4;చ= 'B';
};
fn();
ఖరీదు <<id<< ',' <<అడుగు<< ',' <<చ<< ' n';
తిరిగి 0;
}
అవుట్‌పుట్:
6, 3.4, బిలాంబ్డా ఎక్స్‌ప్రెషన్ యొక్క ఫంక్షన్ బాడీ లోపల వేరియబుల్ పేర్లు లాంబ్డా ఎక్స్‌ప్రెషన్ వెలుపల ఒకే వేరియబుల్స్ కోసం అని నిర్ధారించడం.
విలువ ద్వారా సంగ్రహించడం
విలువ ద్వారా సంగ్రహించడంలో, లంబ్డా ఫంక్షన్ బాడీ లోపల వేరియబుల్ లొకేషన్, పరిసర స్కోప్ యొక్క కాపీ అందుబాటులో ఉంది. లాంబ్డా ఫంక్షన్ బాడీ లోపల వేరియబుల్ కాపీ అయినప్పటికీ, దాని విలువను ఇప్పటి వరకు శరీరం లోపల మార్చలేము. విలువ ద్వారా సంగ్రహాన్ని సాధించడానికి, క్యాప్చర్ నిబంధనలో పునరావృతమయ్యే ప్రతి వేరియబుల్ దేనికీ ముందు ఉండదు. కింది కార్యక్రమం దీనిని వివరిస్తుంది:
#చేర్చండిఉపయోగించి నేమ్‌స్పేస్గంటలు;
intప్రధాన()
{
intid= 5; తేలుతాయిఅడుగు= 2.3; చార్చ= 'TO';
దానంతట అదేfn= [id, ft, ch]()
{
// id = 6; అడుగు = 3.4; ch = 'B';
ఖరీదు <<id<< ',' <<అడుగు<< ',' <<చ<< ' n';
};
fn();
id= 6;అడుగు= 3.4;చ= 'B';
ఖరీదు <<id<< ',' <<అడుగు<< ',' <<చ<< ' n';
తిరిగి 0;
}
అవుట్‌పుట్:
5, 2.3, ఎ6, 3.4, బి
వ్యాఖ్య సూచిక తీసివేయబడితే, ప్రోగ్రామ్ కంపైల్ చేయబడదు. లాంబ్డా వ్యక్తీకరణ యొక్క ఫంక్షన్ బాడీ యొక్క నిర్వచనం లోపల వేరియబుల్స్ మార్చలేము అనే కంపైలర్ ఒక దోష సందేశాన్ని జారీ చేస్తుంది. లాంబ్డా ఫంక్షన్ లోపల వేరియబుల్స్ మార్చలేనప్పటికీ, పై ప్రోగ్రామ్ యొక్క అవుట్‌పుట్ చూపినట్లుగా, వాటిని లాంబ్డా ఫంక్షన్ వెలుపల మార్చవచ్చు.
మిక్సింగ్ క్యాప్చర్స్
సూచన ద్వారా సంగ్రహించడం మరియు విలువ ద్వారా సంగ్రహించడం కలపవచ్చు, కింది ప్రోగ్రామ్ చూపినట్లుగా:
#చేర్చండిఉపయోగించి నేమ్‌స్పేస్గంటలు;
intప్రధాన()
{
intid= 5; తేలుతాయిఅడుగు= 2.3; చార్చ= 'TO'; బూల్bl= నిజం;
దానంతట అదేfn= [id, ft,&ch,&bl]()
{
చ= 'B';bl= తప్పుడు;
ఖరీదు <<id<< ',' <<అడుగు<< ',' <<చ<< ',' <<bl<< ' n';
};
fn();
తిరిగి 0;
}
అవుట్‌పుట్:
5, 2.3, B, 0అన్ని స్వాధీనం చేసుకున్నప్పుడు, సూచన ద్వారా:
క్యాప్చర్ చేయాల్సిన అన్ని వేరియబుల్స్ రిఫరెన్స్ ద్వారా క్యాప్చర్ చేయబడితే, క్యాప్చర్ క్లాజ్‌లో కేవలం ఒకటి & సరిపోతుంది. కింది కార్యక్రమం దీనిని వివరిస్తుంది:
#చేర్చండిఉపయోగించి నేమ్‌స్పేస్గంటలు;
intప్రధాన()
{
intid= 5; తేలుతాయిఅడుగు= 2.3; చార్చ= 'TO'; బూల్bl= నిజం;
దానంతట అదేfn= [&]()
{
id= 6;అడుగు= 3.4;చ= 'B';bl= తప్పుడు;
};
fn();
ఖరీదు <<id<< ',' <<అడుగు<< ',' <<చ<< ',' <<bl<< ' n';
తిరిగి 0;
}
అవుట్‌పుట్:
6, 3.4, B, 0కొన్ని వేరియబుల్స్ రిఫరెన్స్ ద్వారా మరియు ఇతరులు విలువ ద్వారా క్యాప్చర్ చేయబడితే, అప్పుడు ఒకటి & అన్ని రిఫరెన్స్‌లను సూచిస్తాయి, మరియు మిగిలినవి ఈ క్రింది ప్రోగ్రామ్ చూపినట్లుగా ఏదైనా ముందు ఉండవు:
ఉపయోగించి నేమ్‌స్పేస్గంటలు;intప్రధాన()
{
intid= 5; తేలుతాయిఅడుగు= 2.3; చార్చ= 'TO'; బూల్bl= నిజం;
దానంతట అదేfn= [&, id, ft]()
{
చ= 'B';bl= తప్పుడు;
ఖరీదు <<id<< ',' <<అడుగు<< ',' <<చ<< ',' <<bl<< ' n';
};
fn();
తిరిగి 0;
}
అవుట్‌పుట్:
5, 2.3, B, 0క్యాప్చర్ క్లాజ్‌లో & ఒంటరిగా (అంటే, & ఒక ఐడెంటిఫైయర్ అనుసరించబడదు) మొదటి అక్షరం అని గమనించండి.
అన్ని స్వాధీనం చేసుకున్నప్పుడు, విలువ ప్రకారం:
క్యాప్చర్ చేయాల్సిన అన్ని వేరియబుల్స్ విలువ ద్వారా క్యాప్చర్ చేయబడితే, క్యాప్చర్ క్లాజ్‌లో కేవలం ఒక = సరిపోతుంది. కింది కార్యక్రమం దీనిని వివరిస్తుంది:
#చేర్చండిఉపయోగించి నేమ్‌స్పేస్గంటలు;
intప్రధాన()
{
intid= 5; తేలుతాయిఅడుగు= 2.3; చార్చ= 'TO'; బూల్bl= నిజం;
దానంతట అదేfn= [=]()
{
ఖరీదు <<id<< ',' <<అడుగు<< ',' <<చ<< ',' <<bl<< ' n';
};
fn();
తిరిగి 0;
}
అవుట్‌పుట్:
5, 2.3, A, 1గమనిక : = ఇప్పటి వరకు చదవడానికి మాత్రమే.
కొన్ని వేరియబుల్స్ విలువ ద్వారా మరియు మరికొన్ని రిఫరెన్స్ ద్వారా క్యాప్చర్ చేయబడితే, ఒకటి = అన్ని రీడ్-ఓన్లీ కాపీ చేసిన వేరియబుల్స్‌ని సూచిస్తాయి, మరియు మిగిలిన వాటిలో క్రింది ప్రోగ్రామ్ చూపిన విధంగా ఉంటుంది &:
#చేర్చండిఉపయోగించి నేమ్‌స్పేస్గంటలు;
intప్రధాన()
{
intid= 5; తేలుతాయిఅడుగు= 2.3; చార్చ= 'TO'; బూల్bl= నిజం;
దానంతట అదేfn= [=,&ch,&bl]()
{
చ= 'B';bl= తప్పుడు;
ఖరీదు <<id<< ',' <<అడుగు<< ',' <<చ<< ',' <<bl<< ' n';
};
fn();
తిరిగి 0;
}
అవుట్‌పుట్:
5, 2.3, B, 0క్యాప్చర్ క్లాజ్‌లో = ఒంటరిగా మొదటి అక్షరం ఉండాలి.
లాంబ్డా ఎక్స్‌ప్రెషన్‌తో క్లాసికల్ కాల్‌బ్యాక్ ఫంక్షన్ స్కీమ్
లాంబ్డా ఎక్స్‌ప్రెషన్‌తో క్లాసికల్ కాల్‌బ్యాక్ ఫంక్షన్ స్కీమ్ ఎలా చేయవచ్చో కింది ప్రోగ్రామ్ చూపుతుంది:
#చేర్చండిఉపయోగించి నేమ్‌స్పేస్గంటలు;
చార్ *అవుట్‌పుట్;
దానంతట అదేcba= [](చార్బయటకు[])
{
అవుట్‌పుట్=బయటకు;
};
శూన్యంమెయిన్ ఫంక్(చార్ఇన్పుట్[],శూన్యం (*కోసం)(చార్[]))
{
(*కోసం)(ఇన్పుట్);
ఖరీదు<<'ప్రధాన పని కోసం'<<' n';
}
శూన్యంfn()
{
ఖరీదు<<'ఇప్పుడు'<<' n';
}
intప్రధాన()
{
చార్ఇన్పుట్[] = 'కాల్‌బ్యాక్ ఫంక్షన్ కోసం';
మెయిన్ ఫంక్(ఇన్పుట్, cba);
fn();
ఖరీదు<<అవుట్‌పుట్<<' n';
తిరిగి 0;
}
అవుట్‌పుట్:
ప్రధాన ఫంక్షన్ కోసంఇప్పుడు
కాల్‌బ్యాక్ ఫంక్షన్ కోసం
లాంబ్డా ఎక్స్‌ప్రెషన్ నిర్వచనం గ్లోబల్ స్కోప్‌లోని వేరియబుల్‌కు కేటాయించినప్పుడు, దాని ఫంక్షన్ బాడీ క్యాప్చర్ క్లాజ్‌ని ఉపయోగించకుండా గ్లోబల్ వేరియబుల్స్‌ని చూడగలదని గుర్తుంచుకోండి.
వెనుకంజ-తిరిగి-రకం
లాంబ్డా ఎక్స్‌ప్రెషన్ యొక్క రిటర్న్ రకం ఆటో, అంటే కంపైలర్ రిటర్న్ ఎక్స్‌ప్రెషన్ నుండి రిటర్న్ రకాన్ని నిర్ణయిస్తుంది (ఉన్నట్లయితే). ప్రోగ్రామర్ నిజంగా రిటర్న్ రకాన్ని సూచించాలనుకుంటే, ఈ క్రింది ప్రోగ్రామ్‌లో వలె అతను దీన్ని చేస్తాడు:
#చేర్చండిఉపయోగించి నేమ్‌స్పేస్గంటలు;
దానంతట అదేfn= [](intఆపు) -> int
{
intసమాధానం=ఆపు+ 3;
తిరిగిసమాధానం;
};
intప్రధాన()
{
దానంతట అదేవేరియబ్=fn(2);
ఖరీదు <<వేరియబ్<< ' n';
తిరిగి 0;
}
అవుట్‌పుట్ 5. పరామితి జాబితా తరువాత, బాణం ఆపరేటర్ టైప్ చేయబడుతుంది. దీని తరువాత తిరిగి వచ్చే రకం (ఈ సందర్భంలో int).
మూసివేత
కింది కోడ్ విభాగాన్ని పరిగణించండి:
నిర్మాణాత్మకక్లా{
intid= 5;
చార్చ= 'కు';
}ఆబ్జెక్ట్ 1, ఆబ్జెక్ట్ 2;
ఇక్కడ, క్లా అనేది స్ట్రక్ట్ క్లాస్ పేరు. ఆబ్జెక్ 1 మరియు ఆబ్జెక్ట్ 2 అనేది స్ట్రక్ట్ క్లాస్ నుండి తక్షణం అందించబడే రెండు వస్తువులు. లాంబ్డా వ్యక్తీకరణ అమలులో సమానంగా ఉంటుంది. లాంబ్డా ఫంక్షన్ నిర్వచనం ఒక రకమైన తరగతి. లాంబ్డా ఫంక్షన్‌ను పిలిచినప్పుడు (ఆవాహన), ఒక వస్తువు దాని నిర్వచనం నుండి తక్షణం చేయబడుతుంది. ఈ వస్తువును మూసివేత అంటారు. ఇది లాంబ్డా చేయాల్సిన పనిని మూసివేస్తుంది.
ఏదేమైనా, లాంబ్డా ఎక్స్‌ప్రెషన్‌ని పైన ఉన్న స్ట్రక్ట్ లాగా కోడింగ్ చేయడం వల్ల ఆబ్జెక్ట్ 1 మరియు ఆబ్జెక్ట్ 2 సంబంధిత పారామితుల వాదనలతో భర్తీ చేయబడతాయి. కింది కార్యక్రమం దీనిని వివరిస్తుంది:
#చేర్చండిఉపయోగించి నేమ్‌స్పేస్గంటలు;
దానంతట అదేfn= [](intపారామ్ 1,intపారామ్ 2)
{
intసమాధానం=పారామ్ 1+పారామ్ 2;
తిరిగిసమాధానం;
} (2,3);
intప్రధాన()
{
దానంతట అదేఎక్కడ=fn;
ఖరీదు <<ఎక్కడ<< ' n';
తిరిగి 0;
}
అవుట్‌పుట్ 5. కుండలీకరణాల్లో వాదనలు 2 మరియు 3. లాంబ్డా ఎక్స్‌ప్రెషన్ ఫంక్షన్ కాల్, fn, లాంబ్డా ఫంక్షన్ డెఫినిషన్ చివరన వాదనలు ఇప్పటికే కోడ్ చేయబడినందున, ఏ ఆర్గ్యుమెంట్ తీసుకోదని గమనించండి.
ముగింపు
లాంబ్డా వ్యక్తీకరణ అనామక ఫంక్షన్. ఇది రెండు భాగాలుగా ఉంటుంది: తరగతి మరియు వస్తువు. దీని నిర్వచనం ఒక రకమైన తరగతి. వ్యక్తీకరణను పిలిచినప్పుడు, ఒక వస్తువు నిర్వచనం నుండి ఏర్పడుతుంది. ఈ వస్తువును మూసివేత అంటారు. ఇది లాంబ్డా చేయాల్సిన పనిని మూసివేస్తుంది.
లాంబ్డా ఎక్స్‌ప్రెషన్ బాహ్య ఫంక్షన్ స్కోప్ నుండి వేరియబుల్‌ను అందుకోవడానికి, దాని ఫంక్షన్ బాడీలో ఖాళీ కాని క్యాప్చర్ క్లాజ్ అవసరం.