डी में पहले से दिए गए मानकों के साथ तर्क के रूप में पारित फ़ंक्शन को कैसे कॉल करें?

Question

मुझे किसी अन्य फ़ंक्शन पर तर्क के रूप में पारित फ़ंक्शन को कॉल करने की आवश्यकता है और इसे पहले इसके आवश्यक तर्कों को पारित किया जाना चाहिए।

#include <iostream> 

#define CALL(x) x; \ 
       std::cout << "Called!" << std::endl; 

void foo(int a, int b) 
{ 
    std::cout << a * b << std::endl; 
} 

int main() 
{ 
    CALL(foo(9, 8)); // I want to pass 2 int parameters inside 'foo' function call 
    system("PAUSE"); 
} 

यह उत्पादन सकता था: C++ में, इस समस्या किसी मैक्रो के साथ हल किया जाता है

> 72 
> Called! 

है कि वास्तव में कैसे मैं डी में कोई भी विचार फ़ंक्शन को कॉल करने की जरूरत है?

संपादित करें: मैं इस डी में किया जा करने की जरूरत है मैं की तरह कॉल अंदर "foo" कॉल करना चाहते हैं:

CALL(foo(9, 8)) // and not like: CALL(foo, 9, 8) 

लेकिन मैं नहीं जानता कि यह कैसे एक साथ शायद डी में हासिल की है Mixin?

Answer 1

डी में, आप इसके लिए lazy फ़ंक्शन पैरामीटर का उपयोग कर सकते हैं।

import std.stdio; 

void CALL(lazy void x) { 
     writeln("before called"); 
     x; 
     writeln("after called"); 
} 

void foo(int x, int y) { 
     writeln(x, " ", y); 
} 

void main() { 
     CALL(foo(3, 5)); 
} 

D के lazy पैरामीटर भंडारण वर्ग रैप करने के लिए जो कुछ भी आप एक छोटे से गुमनाम समारोह में इसे देने के संकलक का कारण बनता है। उपर्युक्त जैसा है कि आपने लिखा था:

import std.stdio; 

void CALL(void delegate() x) { // note delegate here in long-form syntax 
     writeln("before called"); 
     x(); 
     writeln("after called"); 
} 

void foo(int x, int y) { 
     writeln(x, " ", y); 
} 

void main() { 
     // and this delegate too 
     CALL(delegate() { return foo(3, 5); }); 
} 

लेकिन संकलक इसे आपके लिए फिर से लिखता है। यही कारण है कि मैंने कहा lazy void - void आपके द्वारा पास किए गए छिपे हुए कार्य का रिटर्न प्रकार है। अगर यह int लौटा, तो आप इसके बजाय lazy int का उपयोग कर सकते हैं।

ध्यान दें कि xCALL समारोह के अंदर के बाद से एक छिपे हुए समारोह हो सकता है, वास्तव में दो बार बहस का मूल्यांकन करेंगे पुनः लिखा जाता है दो बार यह बुला:

void CALL(lazy void x) { 
     writeln("before called"); 
     x; 
     writeln("after called"); 
     x; 
     writeln("after called again"); 
} 

करना होगा:

before called 
3 5 
after called 
3 5 
after called again 

सूचना है कि यह कैसे तर्क दो बार मुद्रित किया। वास्तव में सी मैक्रो की तरह। लेकिन यदि आप यह नहीं चाहते हैं, तो बस इसे अस्थायी रूप से असाइन करें:

void CALL(lazy int x) { 
    auto tmp = x; 
    // you can now use tmp as a plain int 
}