डी प्रोग्रामिंग - कार्य

यह अध्याय डी प्रोग्रामिंग में उपयोग किए गए कार्यों का वर्णन करता है।

डी में कार्य की परिभाषा

एक बेसिक फंक्शन डेफिनिशन में एक फंक्शन हेडर और एक फंक्शन बॉडी होती है।

वाक्य - विन्यास

return_type function_name( parameter list ) { 
   body of the function 
}

यहाँ एक समारोह के सभी भागों हैं -

• Return Type- कोई फ़ंक्शन मान वापस कर सकता है। return_typeफ़ंक्शन रिटर्न का मान का डेटा प्रकार है। कुछ फ़ंक्शन मान को वापस किए बिना वांछित संचालन करते हैं। इस मामले में, return_type कीवर्ड हैvoid।

• Function Name- यह फ़ंक्शन का वास्तविक नाम है। फ़ंक्शन नाम और पैरामीटर सूची एक साथ फ़ंक्शन हस्ताक्षर का गठन करते हैं।

• Parameters- एक पैरामीटर एक प्लेसहोल्डर की तरह है। जब किसी फ़ंक्शन को आमंत्रित किया जाता है, तो आप पैरामीटर को एक मान देते हैं। इस मान को वास्तविक पैरामीटर या तर्क के रूप में जाना जाता है। पैरामीटर सूची फ़ंक्शन के मापदंडों के प्रकार, आदेश और संख्या को संदर्भित करती है। पैरामीटर वैकल्पिक हैं; अर्थात्, एक फ़ंक्शन में कोई पैरामीटर नहीं हो सकता है।

• Function Body - फंक्शन बॉडी में स्टेटमेंट्स का एक संग्रह होता है जो परिभाषित करता है कि फ़ंक्शन क्या करता है।

एक समारोह बुला रहा है

आप एक फ़ंक्शन को निम्नानुसार कॉल कर सकते हैं -

function_name(parameter_values)

डी में समारोह के प्रकार

डी प्रोग्रामिंग कार्यों की एक विस्तृत श्रृंखला का समर्थन करता है और वे नीचे सूचीबद्ध हैं।

• शुद्ध कार्य
• Nothrow कार्य
• रेफरी कार्य
• ऑटो कार्य
• वैराडिक कार्य
• इनआउट फंक्शंस
• संपत्ति के कार्य

नीचे विभिन्न कार्यों को समझाया गया है।

शुद्ध कार्य

शुद्ध कार्य वे कार्य हैं जो वैश्विक या स्थिर, परस्पर स्थिति को उनके तर्कों के माध्यम से नहीं बचा सकते हैं। यह इस तथ्य के आधार पर अनुकूलन को सक्षम कर सकता है कि एक शुद्ध फ़ंक्शन को कुछ भी नहीं बदलने की गारंटी दी जाती है जो इसे पारित नहीं किया जाता है, और ऐसे मामलों में जहां कंपाइलर गारंटी दे सकता है कि शुद्ध फ़ंक्शन अपने तर्कों को बदल नहीं सकता है, यह पूर्ण, कार्यात्मक शुद्धता को सक्षम कर सकता है, यह गारंटी है कि फ़ंक्शन हमेशा समान तर्कों के लिए एक ही परिणाम लौटाएगा)।

import std.stdio; 

int x = 10; 
immutable int y = 30; 
const int* p;  

pure int purefunc(int i,const char* q,immutable int* s) { 
   //writeln("Simple print"); //cannot call impure function 'writeln'
   
   debug writeln("in foo()"); // ok, impure code allowed in debug statement 
   // x = i;  // error, modifying global state 
   // i = x;  // error, reading mutable global state 
   // i = *p; // error, reading const global state
   i = y;     // ok, reading immutable global state 
   auto myvar = new int;     // Can use the new expression: 
   return i; 
}

void main() { 
   writeln("Value returned from pure function : ",purefunc(x,null,null)); 
}

जब उपरोक्त कोड संकलित और निष्पादित किया जाता है, तो यह निम्नलिखित परिणाम उत्पन्न करता है -

Value returned from pure function : 30

Nothrow कार्य

नथ्रो कार्य कक्षा अपवाद से प्राप्त किसी भी अपवाद को नहीं फेंकते हैं। नोथ्रो कार्य फेंकने के साथ सहसंयोजक हैं।

नोथ्रो गारंटी देता है कि एक फ़ंक्शन किसी भी अपवाद का उत्सर्जन नहीं करता है।

import std.stdio; 

int add(int a, int b) nothrow { 
   //writeln("adding"); This will fail because writeln may throw 
   int result; 
   
   try { 
      writeln("adding"); // compiles 
      result = a + b; 
   } catch (Exception error) { // catches all exceptions 
   }

   return result; 
} 
 
void main() { 
   writeln("Added value is ", add(10,20)); 
}

जब उपरोक्त कोड संकलित और निष्पादित किया जाता है, तो यह निम्नलिखित परिणाम उत्पन्न करता है -

adding 
Added value is 30

रेफरी कार्य

Ref फ़ंक्शन फ़ंक्शन को संदर्भ द्वारा लौटने की अनुमति देते हैं। यह फ़ंक्शन मापदंडों को रेफ करने के लिए अनुरूप है।

import std.stdio;

ref int greater(ref int first, ref int second) { 
   return (first > second) ? first : second; 
} 
 
void main() {
   int a = 1; 
   int b = 2;  
   
   greater(a, b) += 10;   
   writefln("a: %s, b: %s", a, b);   
}

जब उपरोक्त कोड संकलित और निष्पादित किया जाता है, तो यह निम्नलिखित परिणाम उत्पन्न करता है -

a: 1, b: 12

ऑटो कार्य

ऑटो फ़ंक्शंस किसी भी प्रकार का मान लौटा सकते हैं। किस प्रकार की वापसी की जाए, इस पर कोई प्रतिबंध नहीं है। ऑटो प्रकार फ़ंक्शन के लिए एक सरल उदाहरण नीचे दिया गया है।

import std.stdio;

auto add(int first, double second) { 
   double result = first + second; 
   return result; 
} 

void main() { 
   int a = 1; 
   double b = 2.5; 
   
   writeln("add(a,b) = ", add(a, b)); 
}

जब उपरोक्त कोड संकलित और निष्पादित किया जाता है, तो यह निम्नलिखित परिणाम उत्पन्न करता है -

add(a,b) = 3.5

वैराडिक कार्य

वैरिएडिक फ़ंक्शंस वे फ़ंक्शंस हैं जिनमें किसी फ़ंक्शन के मापदंडों की संख्या रनटाइम में निर्धारित की जाती है। सी में, कम से कम एक पैरामीटर होने की सीमा है। लेकिन डी प्रोग्रामिंग में, ऐसी कोई सीमा नहीं है। एक सरल उदाहरण नीचे दिखाया गया है।

import std.stdio;
import core.vararg;

void printargs(int x, ...) {  
   for (int i = 0; i < _arguments.length; i++) {  
      write(_arguments[i]);  
   
      if (_arguments[i] == typeid(int)) { 
         int j = va_arg!(int)(_argptr); 
         writefln("\t%d", j); 
      } else if (_arguments[i] == typeid(long)) { 
         long j = va_arg!(long)(_argptr); 
         writefln("\t%d", j); 
      } else if (_arguments[i] == typeid(double)) { 
         double d = va_arg!(double)(_argptr); 
         writefln("\t%g", d); 
      } 
   } 
}
  
void main() { 
   printargs(1, 2, 3L, 4.5); 
}

जब उपरोक्त कोड संकलित और निष्पादित किया जाता है, तो यह निम्नलिखित परिणाम उत्पन्न करता है -

int 2 
long 3 
double 4.5

इनआउट फंक्शंस

इनऑउट का उपयोग पैरामीटर और रिटर्न प्रकार के कार्यों के लिए किया जा सकता है। यह परिवर्तनशील, कास्ट और अपरिवर्तनीय के लिए एक टेम्पलेट की तरह है। परिवर्तनशीलता विशेषता पैरामीटर से काट ली जाती है। मीन्स, इनटाउट घटे हुए परिवर्तनशीलता विशेषता को रिटर्न प्रकार में स्थानांतरित करता है। परिवर्तनशीलता कैसे बदल जाती है, इसका एक सरल उदाहरण नीचे दिखाया गया है।

import std.stdio;

inout(char)[] qoutedWord(inout(char)[] phrase) { 
   return '"' ~ phrase ~ '"';
}

void main() { 
   char[] a = "test a".dup; 

   a = qoutedWord(a); 
   writeln(typeof(qoutedWord(a)).stringof," ", a);  

   const(char)[] b = "test b"; 
   b = qoutedWord(b); 
   writeln(typeof(qoutedWord(b)).stringof," ", b); 

   immutable(char)[] c = "test c"; 
   c = qoutedWord(c); 
   writeln(typeof(qoutedWord(c)).stringof," ", c); 
}

जब उपरोक्त कोड संकलित और निष्पादित किया जाता है, तो यह निम्नलिखित परिणाम उत्पन्न करता है -

char[] "test a" 
const(char)[] "test b" 
string "test c"

संपत्ति के कार्य

गुण सदस्य चर जैसे सदस्य कार्यों का उपयोग करने की अनुमति देते हैं। यह @property कीवर्ड का उपयोग करता है। गुण संबंधित फ़ंक्शन से जुड़े होते हैं जो आवश्यकता के आधार पर मान लौटाते हैं। संपत्ति के लिए एक सरल उदाहरण नीचे दिखाया गया है।

import std.stdio;

struct Rectangle { 
   double width; 
   double height;  

   double area() const @property {  
      return width*height;  
   } 

   void area(double newArea) @property {  
      auto multiplier = newArea / area; 
      width *= multiplier; 
      writeln("Value set!");  
   } 
}

void main() { 
   auto rectangle = Rectangle(20,10); 
   writeln("The area is ", rectangle.area);  
   
   rectangle.area(300); 
   writeln("Modified width is ", rectangle.width); 
}

जब उपरोक्त कोड संकलित और निष्पादित किया जाता है, तो यह निम्नलिखित परिणाम उत्पन्न करता है -

The area is 200 
Value set! 
Modified width is 30