C ++ में आपके स्थानीय कार्य नहीं हो सकते। हालाँकि, C ++ 11 में लैम्ब्डा है । लैम्ब्डा मूल रूप से वैरिएबल होते हैं जो फ़ंक्शंस की तरह काम करते हैं।
एक लैम्ब्डा का प्रकार होता है std::function( वास्तव में यह बिल्कुल सच नहीं है , लेकिन ज्यादातर मामलों में आप मान सकते हैं कि यह है)। इस प्रकार का उपयोग करने के लिए, आपको करने की आवश्यकता है #include <functional>। std::functionएक टेम्पलेट है, जो टेम्पलेट तर्क के रूप में रिटर्न प्रकार और तर्क प्रकार को सिंटैक्स के साथ लेता है std::function<ReturnType(ArgumentTypes)। उदाहरण के लिए, std::function<int(std::string, float)>एक लंबोदर एक लौट रहा है intऔर दो तर्क ले रहा है, एक std::stringऔर एक float। सबसे आम एक है std::function<void()>, जो कुछ भी नहीं लौटाता है और कोई तर्क नहीं लेता है।
एक बार एक लंबोदर घोषित होने के बाद, इसे सिंटैक्स का उपयोग करके सामान्य फ़ंक्शन की तरह कहा जाता है lambda(arguments)।
एक लैम्ब्डा को परिभाषित करने के लिए, सिंटैक्स का उपयोग करें [captures](arguments){code}(इसे करने के अन्य तरीके हैं, लेकिन मैं यहां उनका उल्लेख नहीं करूंगा)। argumentsलैम्ब्डा क्या तर्क देता है, और codeवह कोड है जिसे लैम्ब्डा कहे जाने पर चलाया जाना चाहिए। आमतौर पर आप [=]या [&]कब्जा के रूप में डालते हैं । [=]इसका मतलब है कि आप उस मूल्य के दायरे में सभी चरों पर कब्जा कर लेते हैं, जिसका अर्थ मूल्य द्वारा परिभाषित किया गया है, जिसका अर्थ है कि वे उस मूल्य को रखेंगे जो उनके पास था जब लंबोदर घोषित किया गया था। [&]इसका मतलब है कि आप संदर्भ द्वारा सभी चर को दायरे में कैद कर लेते हैं, जिसका अर्थ है कि उनका हमेशा उनका वर्तमान मूल्य होगा, लेकिन यदि वे स्मृति से मिटा दिए जाते हैं, तो प्रोग्राम क्रैश हो जाएगा। यहाँ कुछ उदाहरण हैं:
#include <functional>
#include <iostream>
int main(){
int x = 1;
std::function<void()> lambda1 = [=](){
std::cout << x << std::endl;
};
std::function<void()> lambda2 = [&](){
std::cout << x << std::endl;
};
x = 2;
lambda1(); //Prints 1 since that was the value of x when it was captured and x was captured by value with [=]
lambda2(); //Prints 2 since that's the current value of x and x was captured by value with [&]
std::function<void()> lambda3 = [](){}, lambda4 = [](){}; //I prefer to initialize these since calling an uninitialized lambda is undefined behavior.
//[](){} is the empty lambda.
{
int y = 3; //y will be deleted from the memory at the end of this scope
lambda3 = [=](){
std::cout << y << endl;
};
lambda4 = [&](){
std::cout << y << endl;
};
}
lambda3(); //Prints 3, since that's the value y had when it was captured
lambda4(); //Causes the program to crash, since y was captured by reference and y doesn't exist anymore.
//This is a bit like if you had a pointer to y which now points nowhere because y has been deleted from the memory.
//This is why you should be careful when capturing by reference.
return 0;
}
आप उनके नामों को निर्दिष्ट करके विशिष्ट चर भी पकड़ सकते हैं। केवल उनके नाम को निर्दिष्ट करने से वे मूल्य पर कब्जा कर लेंगे, उनके नाम को &पहले से निर्दिष्ट करके उन्हें संदर्भ द्वारा कैप्चर करेंगे। उदाहरण के लिए, [=, &foo]मूल्य के अलावा सभी चर पर कब्जा कर लेंगे , fooजिसे छोड़कर संदर्भ द्वारा कब्जा कर लिया [&, foo]जाएगा , और संदर्भ द्वारा सभी चर को पकड़ लेंगे , fooजिसके अलावा मूल्य पर कब्जा कर लिया जाएगा। तुम भी केवल विशिष्ट चरों पर कब्जा कर सकते हैं, उदाहरण के लिए [&foo]कब्जा fooसंदर्भ द्वारा और कोई अन्य चर पर कब्जा होगा। तुम भी उपयोग करके कोई चर पर कब्जा कर सकते हैं []। यदि आप एक लैम्ब्डा में वैरिएबल का उपयोग करने का प्रयास करते हैं जिसे आपने कैप्चर नहीं किया है, तो यह संकलित नहीं होगा। यहाँ एक उदाहरण है:
#include <functional>
int main(){
int x = 4, y = 5;
std::function<void(int)> myLambda = [y](int z){
int xSquare = x * x; //Compiler error because x wasn't captured
int ySquare = y * y; //OK because y was captured
int zSquare = z * z; //OK because z is an argument of the lambda
};
return 0;
}
आप एक वैरिएबल का मान नहीं बदल सकते हैं जो लैम्बडा के अंदर वैल्यू द्वारा कैप्चर किया गया था (वैल्यू द्वारा कैप्चर किए गए वेरिएबल constलैम्ब्डा के अंदर एक प्रकार है)। ऐसा करने के लिए, आपको संदर्भ द्वारा चर को पकड़ने की आवश्यकता है। यहाँ एक परीक्षा है:
#include <functional>
int main(){
int x = 3, y = 5;
std::function<void()> myLambda = [x, &y](){
x = 2; //Compiler error because x is captured by value and so it's of type const int inside the lambda
y = 2; //OK because y is captured by reference
};
x = 2; //This is of course OK because we're not inside the lambda
return 0;
}
इसके अलावा, बिन बुलाए लैम्ब्डा को कॉल करना अपरिभाषित व्यवहार है और आमतौर पर इस कार्यक्रम के दुर्घटनाग्रस्त होने का कारण होगा। उदाहरण के लिए, ऐसा कभी न करें:
std::function<void()> lambda;
lambda(); //Undefined behavior because lambda is uninitialized
उदाहरण
यहाँ लैम्बदास का उपयोग करके आप अपने प्रश्न में क्या करना चाहते हैं, इसके लिए कोड दिया गया है:
#include <functional> //Don't forget this, otherwise you won't be able to use the std::function type
int main(){
std::function<void()> a = [](){
// code
}
a();
return 0;
}
यहाँ एक मेमने का एक और अधिक उन्नत उदाहरण दिया गया है:
#include <functional> //For std::function
#include <iostream> //For std::cout
int main(){
int x = 4;
std::function<float(int)> divideByX = [x](int y){
return (float)y / (float)x; //x is a captured variable, y is an argument
}
std::cout << divideByX(3) << std::endl; //Prints 0.75
return 0;
}