वैरिएडिक फ़ंक्शन: Difference between revisions

From Vigyanwiki
No edit summary
No edit summary
Line 22: Line 22:


<syntaxhighlight lang="c">
<syntaxhighlight lang="c">
#सम्मिलित <stdarg.h>
#include <stdarg.h>
#सम्मिलित <stdio.h>
#include<stdio.h>


दोगुना औसत(int count, ...) {
double average(int count, ...) {
     va_list ap;
     va_list ap;
     int j;
     int j;
     double sum = 0;
     double sum = 0;


     va_start(ap, count); /* पहले C23: अंतिम निश्चित प्राचल की आवश्यकता है (पता प्राप्त करने के लिए)*/
     va_start(ap, count); /* Before C23: Requires the last fixed parameter (to get the address)*/
     for (j = 0; j < count; j++) {
     for (j = 0; j < count; j++) {
         sum += va_arg(ap, int); /* ap अगले तर्क में वृद्धि करता है. */
         sum += va_arg(ap, int); /* Increments ap to the next argument. */
     }
     }
     va_end(ap);
     va_end(ap);


     वापसी राशि / गणना;
     return sum / count;
}
}


मुख्य प्रवेश बिंदु(int argc, char const *argv[]) {
int main(int argc, char const *argv[]) {
     मुद्रण("%f\n", average(3, 1, 2, 3));
     printf("%f\n", average(3, 1, 2, 3));
     वापसी 0;
     return 0;
}
}
</syntaxhighlight>
</syntaxhighlight>
Line 56: Line 56:


सी पार्श्व संकेतशब्द का उपयोग करके विविध प्रकार्यों का वर्णन करता है।, तर्कों के लिए एक प्रकार प्रदान किया जाना चाहिए हालांकि {{code|object[]}} का उपयोग अर्थबोधक के रूप में उपयोग किया जा सकता है। आजीविका स्थान पर, आप या तो तर्कों को एक-एक करके सूचीबद्ध कर सकते हैं, या आवश्यक तत्व प्रकार वाले पहले से मौजूद सरणी को सौंप सकते हैं। विविध रूप का उपयोग बाद के लिए [[वाक्यात्मक शर्करा]] है।
सी पार्श्व संकेतशब्द का उपयोग करके विविध प्रकार्यों का वर्णन करता है।, तर्कों के लिए एक प्रकार प्रदान किया जाना चाहिए हालांकि {{code|object[]}} का उपयोग अर्थबोधक के रूप में उपयोग किया जा सकता है। आजीविका स्थान पर, आप या तो तर्कों को एक-एक करके सूचीबद्ध कर सकते हैं, या आवश्यक तत्व प्रकार वाले पहले से मौजूद सरणी को सौंप सकते हैं। विविध रूप का उपयोग बाद के लिए [[वाक्यात्मक शर्करा]] है।




Line 63: Line 64:


{
{
     स्थिर int Foo(int a, int b, पैरामीटर्स int[] args)
     static int Foo(int a, int b, params int[] args)
     {
     {
         // a और b को अनदेखा करते हुए, तर्कों में पूर्णांकों का योग लौटाएँ।
         // Return the sum of the integers in args, ignoring a and b.          int sum = 0;
        इंट योग = 0;
         foreach (int i in args)
         foreach (int i in args)
             योग + = मैं;
             sum + = मैं;
         वापसी राशि;
         return sum;
     }
     }
          
          
     स्थिर शून्य मुख्य(स्ट्रिंग[] तर्क)
     static void Main(string[] args)
     {
     {
         कंसोल.राइटलाइन(फू(1,2)); // 0
         Console.WriteLine(Foo(1,2)); // 0
         कंसोल.राइटलाइन(फू(1, 2, 3, 10, 20)); //33
         Console.WriteLine(Foo(1, 2, 3, 10, 20)); //33
         int[] कई वैल्यूज़ = नया int[] {13, 14, 15 };
         int[] manyValues = new int[] {13, 14, 15 };
         कंसोल.राइटलाइन(फू(1,2, अनेक वैल्यूज़)); //42
         Console.WriteLine(Foo(1,2, manyValues)); //42
     }  
     }  
}
}
Line 83: Line 83:
===सी++ में===
===सी++ में===
C++ में बुनियादी विविधतापूर्ण सुविधा बहुत हद तक C के समान है। एकमात्र अंतर वाक्य रचना में है, जहां दीर्घवृत्त से पहले अल्पविराम को छोड़ा जा सकता है। C++ नामित मापदंडों के बिना विविध प्रकार्यों की अनुमति देता है लेकिन तब से उन तर्कों तक पहुंचने का कोई तरीका प्रदान नहीं करता है <code>va_start</code> कार्य के अंतिम निश्चित तर्क के नाम की आवश्यकता है। <!-- When C23 is released the text should be updated to reflect that this is a difference between the languages. When C++26 ports the one argument va_start to C++ (https://wg21.link/p2537) this should be updated again. See also the C section of the article. -->
C++ में बुनियादी विविधतापूर्ण सुविधा बहुत हद तक C के समान है। एकमात्र अंतर वाक्य रचना में है, जहां दीर्घवृत्त से पहले अल्पविराम को छोड़ा जा सकता है। C++ नामित मापदंडों के बिना विविध प्रकार्यों की अनुमति देता है लेकिन तब से उन तर्कों तक पहुंचने का कोई तरीका प्रदान नहीं करता है <code>va_start</code> कार्य के अंतिम निश्चित तर्क के नाम की आवश्यकता है। <!-- When C23 is released the text should be updated to reflect that this is a difference between the languages. When C++26 ports the one argument va_start to C++ (https://wg21.link/p2537) this should be updated again. See also the C section of the article. -->
<सिंटैक्सहाइलाइट लैंग= सी++ >
#सम्मिलित <iostream>
#सम्मिलित <cstdarg>


शून्य सरल_मुद्रण(const char* fmt...) // C-style const char* fmt, ... भी मान्य है
#include  <iostream>
#include  <cstdarg>
 
void simple_printf(const char* fmt...) // C-style const char* fmt, ... is also valid
 
{
{
     va_list तर्क;
     va_list args;
     va_start(args, fmt);
     va_start(args, fmt);
   
   
     जबकि (*fmt != '\0') {
     while (*fmt != '\0') {
         यदि (*fmt == 'd') {
         if (*fmt == 'd') {
             int i = va_arg(args, int);
             int i = va_arg(args, int);
             std::cout << i << '\n';
             std::cout << i << '\n';
         } अन्यथा यदि (*fmt == 'c') {
         } else if (*fmt == 'c') {
             // इंटीग्रल प्रकार में स्वचालित रूपांतरण पर ध्यान दें
             // note automatic conversion to integral type
             int c = va_arg(args, int);
             int c = va_arg(args, int);
             std::cout << static_cast<char>(c) << '\n';
             std::cout << static_cast<char>(c) << '\n';
         } अन्यथा यदि (*fmt == 'f') {
         } else if (*fmt == 'f') {
             डबल डी = va_arg(args, डबल);
             double d  = va_arg(args, double);
             std::cout << d << '\n';
             std::cout << d << '\n';
         }
         }
         ++ एफएमटी;
         ++ fmt;
     }
     }
   
   
Line 110: Line 111:
}
}


मुख्य प्रवेश बिंदु()
int main()


{
{
     सरल_मुद्रण(dcff, 3, 'ए', 1.999, 42.5);
     simple_printf(dcff, 3, 'a', 1.999, 42.5);
}
}


[[विविध टेम्पलेट्स|विविध नमूना]] (पैरामीटर पैक) का उपयोग C++ में अंतर्निहित भाषा (उच्च-क्रम कार्य) के साथ भी किया जा सकता है।
[[विविध टेम्पलेट्स|विविध नमूना]] (पैरामीटर पैक) का उपयोग C++ में अंतर्निहित भाषा (उच्च-क्रम कार्य) के साथ भी किया जा सकता है।


#सम्मिलित <iostream>
#include <iostream>


[[विविध टेम्पलेट्स|नमूना]] <नाम टाइप करें... Ts>
template <typename... Ts>


शून्य foo_print(Ts... args)
void foo_print(Ts... args)


{
{
Line 128: Line 129:
}
}


मुख्य प्रवेश बिंदु()
int main()


{
{
     std::cout << std::boolalpha;
     std::cout << std::boolalpha;
     foo_print(1, 3.14f); // 1 3.14
     foo_print(1, 3.14f); // 1 3.14
     foo_print(Foo, 'b', true, nullptr); // फू बी सच nullptr
     foo_print(Foo, 'b', true, nullptr); // Foo b true  nullptr
}
}


Line 143: Line 144:


<syntaxhighlight lang="go">
<syntaxhighlight lang="go">
पैकेज मुख्य
package main


आयात "fmt"
import "fmt"


// यह विविध कार्य एक मनमाना संख्या लेता है ints तर्क के रूप में।
// This variadic function takes an arbitrary number of ints as arguments.
func sum(nums ...int) {
func sum(nums ...int) {
fmt.Print("कुल मिलाकर ", अंक) // यह एक विविध कार्य भी है।
fmt.Print("The sum of ", nums) // Also a variadic function.
.
.
कुल := 0
sum := 0
for _, अंक := श्रेणी अंक {
for _, num := range nums {
कुल += अंक
total += num
}
}
fmt.Println(" is", कुल) // यह एक विविध कार्य भी है।
fmt.Println(" is", total) // Also a variadic function.
}
}


मुख्य कार्य() {
func main() {
// विविध कार्य को व्यक्तिगत रूप से सामान्य तरीके से बुलाया जा सकता है
// Variadic functions can be called in the usual way with individual
// तर्क।
// arguments.
जोड़(1, 2)  // "कुल मिलाकर [1 2] is 3"
sum(1, 2)  // "The sum of [1 2] is 3"
जोड़(1, 2, 3) // "कुल मिलाकर [1 2 3] is 6"
sum(1, 2, 3) // "The sum of [1 2 3] is 6"


// यदि आपके पास पहले से ही एकाधिक हैं args एक स्लाइस में, उन्हें एक विविध
// If you already have multiple args in a slice, apply them to a variadic
// कार्य का उपयोग करके func(स्लाइस...) इस तरह.
// function using func(slice...) like this.
अंक := []int{1, 2, 3, 4}
nums := []int{1, 2, 3, 4}
कुल(अंक...) // "कुल मिलाकर [1 2 3 4] हैं 10"
sum(nums...) // "The sum of [1 2 3 4] is 10"
}
}


Line 182: Line 183:
C# की तरह, [[जावा (प्रोग्रामिंग भाषा)]] में } प्रकार कैच-ऑल के रूप में उपलब्ध है।
C# की तरह, [[जावा (प्रोग्रामिंग भाषा)]] में } प्रकार कैच-ऑल के रूप में उपलब्ध है।
<syntaxhighlight lang="java">
<syntaxhighlight lang="java">
सार्वजनिक वर्ग कार्यक्रम {
public class Program {
     // विविध विधियाँ प्राप्त होने वाले किसी भी अतिरिक्त तर्क को एक सरणी में संग्रहीत करती हैं।
     // Variadic methods store any additional arguments they receive in an array.
     // परिणामस्वरूप, `printArgs` वास्तव में एक पैरामीटर वाली एक विधि है: ए
     // Consequentially, `printArgs` is actually a method with one parameter: a
     // चर-लंबाई सरणी `तार`s.
     // variable-length array of `String`s.
     निजी स्थैतिक शून्य printArgs(तार... तार s) {
     private static void printArgs(String... strings) {
         के लिए (तार तार : तार s) {
         for (String string : strings) {
             प्रणाली.बाहर.println(तार);
             System.out.println(string);
         }
         }
     }
     }


     सार्वजनिक स्थैतिक शून्य मुख्य (तार[] args) {
     public static void main(String[] args) {
         printArgs("hello");          // कम के लिए printArgs(["hello"])
         printArgs("hello");          // short for printArgs(["hello"])
         printArgs("hello", "world"); // कम के लिए printArgs(["hello", "world"])
         printArgs("hello", "world"); // short for printArgs(["hello", "world"])
     }
     }
}
}
Line 204: Line 205:


<syntaxhighlight lang="javascript">
<syntaxhighlight lang="javascript">
फ़ंक्शन योग(...संख्याएं) {
function sum(...numbers) {
     वापसी संख्या.कम करना((a, b) => a + b, 0);
     return numbers.reduce((a, b) => a + b, 0);
}
}


कंसोल.लॉग(योग(1, 2, 3)); // 6
console.log(sum(1, 2, 3)); // 6
कंसोल.लॉग(योग(3, 2));    // 5
console.log(sum(3, 2));    // 5
कंसोल.लॉग(योग());        // 0
console.log(sum());        // 0
</syntaxhighlight>
</syntaxhighlight>
तर्क ऑब्जेक्ट का उपयोग करके एक विविध प्रकार्य बनाना भी संभव है, हालांकि यह केवल प्रकार्य संकेतशब्द के साथ बनाए गए प्रकार्य के साथ प्रयोग करने योग्य है।
तर्क ऑब्जेक्ट का उपयोग करके एक विविध प्रकार्य बनाना भी संभव है, हालांकि यह केवल प्रकार्य संकेतशब्द के साथ बनाए गए प्रकार्य के साथ प्रयोग करने योग्य है।


<syntaxhighlight lang="javascript">
<syntaxhighlight lang="javascript">
प्रकार्य योग() {
function sum() {
     वापसी सरणी.मूलरूप.क्रम में लेना.कॉल(बहस, (a, b) => a + b, 0);
     return Array.prototype.reduce.call(arguments, (a, b) => a + b, 0);
}
}


कंसोल.लॉग(योग(1, 2, 3)); // 6
console.log(sum(1, 2, 3)); // 6
कंसोल.लॉग(योग(3, 2));    // 5
console.log(sum(3, 2));    // 5
कंसोल.लॉग(योग());        // 0
console.log(sum());        // 0
</syntaxhighlight>
</syntaxhighlight>




=== [[लुआ (प्रोग्रामिंग भाषा)]] में ===
=== [[लुआ (प्रोग्रामिंग भाषा)]] में ===
लुआ (प्रोग्रामिंग भाषा) फ़ंक्शंस अन्य फ़ंक्शंस में वैरार्ग को उसी तरह से पास कर सकते हैं जैसे अन्य मानों का उपयोग करते हुए {{Code|return}} कीवर्ड. लूआ संस्करण 5.2 या उच्चतर का उपयोग करके तालिकाओं को विविध प्रकार्यों में पारित किया जा सकता है<ref>{{Cite web |title=Lua 5.2 Reference Manual |url=https://www.lua.org/manual/5.2/manual.html#pdf-table.unpack |access-date=2023-02-05 |website=www.lua.org}}</ref> {{Code|table.unpack}}, या लुआ 5.1 या उससे कम<ref>{{Cite web |title=Lua 5.1 Reference Manual |url=https://www.lua.org/manual/5.1/manual.html#pdf-unpack |access-date=2023-02-05 |website=www.lua.org}}</ref> {{Code|unpack}}. vararg को एक मान के रूप में vararg के साथ एक तालिका बनाकर उपयोग किया जा सकता है।<syntaxhighlight lang="lua">
लुआ (प्रोग्रामिंग भाषा) प्रकार्य वापसी संकेतशब्द का उपयोग करके अन्य मानों की तरह ही अन्य प्रकार्य में वेरार्ग पास कर सकते हैं। लूआ संस्करण 5.2 या उच्चतर का उपयोग करके तालिकाओं को विविध प्रकार्यों में पारित किया जा सकता है<ref>{{Cite web |title=Lua 5.2 Reference Manual |url=https://www.lua.org/manual/5.2/manual.html#pdf-table.unpack |access-date=2023-02-05 |website=www.lua.org}}</ref> {{Code|table.unpack}}, या लुआ 5.1 या उससे कम<ref>{{Cite web |title=Lua 5.1 Reference Manual |url=https://www.lua.org/manual/5.1/manual.html#pdf-unpack |access-date=2023-02-05 |website=www.lua.org}}</ref> {{Code|unpack}}. वेरार्ग को एक मान के रूप में वेरार्ग के साथ एक तालिका बनाकर उपयोग किया जा सकता है।<syntaxhighlight lang="lua">
function sum(...) --... designates varargs
function sum(...) --... designates varargs
   local sum=0
   local sum=0
   for _,v in pairs({...}) do --creating a table with a varargs is the same as creating one with standard values
   for _,v in pairs({...}) do --creating a table with a varargs is the same as creating one with standard values
Line 249: Line 251:
   end
   end
   return table.unpack(processed) --returns all entries in a way that can be used as a vararg
   return table.unpack(processed) --returns all entries in a way that can be used as a vararg
end
end


Line 257: Line 260:
===[[पास्कल (प्रोग्रामिंग भाषा)]] में===
===[[पास्कल (प्रोग्रामिंग भाषा)]] में===
{{cleanup section|reason=Default and polymorphism is not variadic. I/O example is too long.|date=April 2021}}
{{cleanup section|reason=Default and polymorphism is not variadic. I/O example is too long.|date=April 2021}}
पास्कल (प्रोग्रामिंग भाषा) में चार अंतर्निहित प्रक्रियाएं हैं जिन्हें वैरिएडिक के रूप में परिभाषित किया गया है, जो इस विशेष स्थिति के कारण, कंपाइलर के लिए आंतरिक हैं। ये हैं {{code|read}}, {{code|readln}}, {{code|write}}, और {{code|writeln}} प्रक्रियाएं. हालाँकि, प्रक्रियाओं या कार्यों के लिए डिफ़ॉल्ट तर्क की अनुमति देने वाले वैकल्पिक विनिर्देश हैं जो उन्हें विविध रूप से काम करते हैं, साथ ही [[बहुरूपता (कंप्यूटर विज्ञान)]] जो एक प्रक्रिया या फ़ंक्शन को अलग-अलग पैरामीटर रखने की अनुमति देता है। वह {{code|read[ln]}} और {{code|write[ln]}} सभी प्रक्रियाओं का प्रारूप समान है:
पास्कल (प्रोग्रामिंग भाषा) में चार अंतर्निहित प्रक्रियाएं हैं जिन्हें विविध के रूप में परिभाषित किया गया है, जो इस विशेष स्थिति के कारण, संकलक के लिए आंतरिक हैं। ये हैं पढ़ें, {{code|readln}}, लिखें, और {{code|writeln}} प्रक्रियाएं. हालाँकि, प्रक्रियाओं या कार्यों के लिए डिफ़ॉल्ट तर्क की अनुमति देने वाले वैकल्पिक विनिर्देश हैं जो उन्हें विविध रूप से काम करते हैं, साथ ही [[बहुरूपता (कंप्यूटर विज्ञान)|बहुरूपता (कंप्यूटर विज्ञान)भी है]] जो एक प्रक्रिया या प्रकार्य को अलग-अलग पैरामीटर रखने की अनुमति देता है। वह {{code|read[ln]}} और {{code|write[ln]}} सभी प्रक्रियाओं का प्रारूप समान है:
 
 
पढ़ें[एलएन] [( [फ़ाइल ,] चर [, चर ...] )] ;


<पूर्व>
पढ़ें[एलएन] [( [फ़ाइल ,] वेरिएबल [, वेरिएबल ...] )] ;
लिखें[एलएन] [( [फ़ाइल][, मूल्य [, मूल्य ...] )] ;
लिखें[एलएन] [( [फ़ाइल][, मूल्य [, मूल्य ...] )] ;
</पूर्व>


कहाँ
कहाँ


* {{code|file}} एक वैकल्पिक फ़ाइल चर है, जिसे यदि छोड़ दिया जाए तो यह डिफ़ॉल्ट हो जाता है {{code|input}} के लिए {{code|read}} और {{code|readln}}, या डिफ़ॉल्ट {{code|output}} के लिए {{code|write}} और {{code|writeln}};
* {{code|file}} एक वैकल्पिक फ़ाइल चर है, जिसे यदि छोड़ दिया जाए तो यह डिफ़ॉल्ट हो जाता है {{code|input}} के लिए {{code|read}} और {{code|readln}}, या डिफ़ॉल्ट {{code|output}} के लिए {{code|write}} और {{code|writeln}};
* {{code|variable}} एक अदिश राशि है जैसे कि चार (वर्ण), पूर्णांक, या वास्तविक (या कुछ कंपाइलरों के लिए, कुछ रिकॉर्ड प्रकार या सरणी प्रकार जैसे स्ट्रिंग); और
* {{code|variable}} एक अदिश राशि है जैसे कि चार (वर्ण), पूर्णांक, या वास्तविक (या कुछ संकलक के लिए, कुछ रिकॉर्ड प्रकार या सरणी प्रकार जैसे स्ट्रिंग); और
* {{code|value}} एक चर या स्थिरांक है।
* {{code|value}} एक चर या स्थिरांक है।


उदाहरण:
उदाहरण:


<syntaxhighlight lang="pascal" line>
<syntaxhighlight lang="pascal" line="1">
var  
var  
   f: text;
   f: text;
   ch: char;
   ch: ;char
   n,a,I,B: Integer;
   n,a,I,B: Integer;
   S: String;
   S: String;
Line 303: Line 306:
end.
end.
</syntaxhighlight>
</syntaxhighlight>
उपरोक्त उदाहरण में, जहां तक ​​कंपाइलर का सवाल है, लाइनें 9 और 13 समान हैं, क्योंकि यदि {{code|input}} फ़ाइल वेरिएबल है जिसे a द्वारा पढ़ा जा रहा है {{code|read}} या {{code|readln}} कथन, फ़ाइल चर छोड़ा जा सकता है। साथ ही, कंपाइलर पंक्ति 15 और 20 को समान मानता है, क्योंकि यदि फ़ाइल वेरिएबल को लिखा जा रहा है {{code|output}}, इसे छोड़ा जा सकता है, जिसका अर्थ है (पंक्ति 20 पर) चूंकि प्रक्रिया में कोई तर्क पारित नहीं किया जा रहा है, इसलिए तर्कों को सूचीबद्ध करने वाले कोष्ठक को छोड़ा जा सकता है। पंक्ति 26 दर्शाती है {{code|writeln}} कथन में किसी भी संख्या में तर्क हो सकते हैं, और वे एक उद्धृत स्ट्रिंग, एक चर, या यहां तक ​​कि एक सूत्र परिणाम भी हो सकते हैं।
उपरोक्त उदाहरण में, जहां तक ​​संकलक का सवाल है, लाइनें 9 और 13 समान हैं, क्योंकि यदि {{code|input}} फ़ाइल चर को {{code|read}} या {{code|readln}} कथन द्वारा पढ़ा जा रहा है तो फ़ाइल चर को छोड़ा जा सकता है। साथ ही, संकलक पंक्ति 15 और 20 को समान मानता है, क्योंकि यदि फ़ाइल चर को {{code|output}}में लिखा जा रहा है ,तो इसे छोड़ा जा सकता है, जिसका अर्थ है (पंक्ति 20 पर) क्योंकि प्रक्रिया में कोई तर्क पारित नहीं किया जा रहा है, कोष्ठक तर्कों को सूचीबद्ध करते हैं मिटाया जा सकता है। पंक्ति 26 से पता चलता है कि {{code|writeln}} कथन में किसी भी संख्या में तर्क हो सकते हैं, और वे एक उद्धृत स्ट्रिंग, एक चर, या यहां तक ​​कि एक सूत्र परिणाम भी हो सकते हैं।


ऑब्जेक्ट पास्कल बहुरूपी प्रक्रियाओं और कार्यों का समर्थन करता है, जहां विभिन्न प्रक्रियाओं या कार्यों का एक ही नाम हो सकता है लेकिन उन्हें दिए गए तर्कों से अलग किया जा सकता है।
ऑब्जेक्ट पास्कल बहुरूपी प्रक्रियाओं और कार्यों का समर्थन करता है, जहां विभिन्न प्रक्रियाओं या कार्यों का एक ही नाम हो सकता है लेकिन उन्हें दिए गए तर्कों से अलग किया जा सकता है।


पास्कल डिफ़ॉल्ट तर्कों का भी समर्थन करता है, जहां तर्क का मान, यदि प्रदान नहीं किया गया है, तो एक डिफ़ॉल्ट मान दिया जाता है।
पास्कल अनुपस्थिति तर्कों का भी समर्थन करता है, जहां तर्क का मान, यदि प्रदान नहीं किया गया है, तो एक अनुपस्थिति मान दिया जाता है।


पहले उदाहरण के लिए, बहुरूपता, निम्नलिखित पर विचार करें:
पहले उदाहरण के लिए, बहुरूपता, निम्नलिखित पर विचार करें:
Line 317: Line 320:
function add(r1:real,a2:integer):real;  begin add := a1+real(a2) end;                                 
function add(r1:real,a2:integer):real;  begin add := a1+real(a2) end;                                 
</syntaxhighlight>
</syntaxhighlight>
उपरोक्त उदाहरण में, यदि {{code|add}} जैसा कि दो पूर्णांक मानों के साथ कहा जाता है, पंक्ति 1 पर घोषित फ़ंक्शन को बुलाया जाएगा; यदि तर्कों में से एक पूर्णांक है और एक वास्तविक है, तो पंक्ति 3 या 4 पर फ़ंक्शन को कॉल किया जाता है, जो इस पर निर्भर करता है कि कौन सा पूर्णांक है। यदि दोनों वास्तविक हैं, तो पंक्ति 2 पर फ़ंक्शन को कॉल किया जाता है।
उपरोक्त उदाहरण में, यदि दो पूर्णांक मानों के साथ को{{code|add}} कहा जाता है, पंक्ति 1 पर घोषित प्रकार्य को बुलाया जाएगा; यदि तर्कों में से एक पूर्णांक है और एक वास्तविक है, तो पंक्ति 3 या 4 पर प्रकार्य को कॉल किया जाता है, जो इस पर निर्भर करता है कि कौन सा पूर्णांक है। यदि दोनों वास्तविक हैं, तो पंक्ति 2 पर प्रकार्य को कॉल किया जाता है।


डिफ़ॉल्ट पैरामीटर के लिए, निम्नलिखित पर विचार करें:
अनुपस्थिति पैरामीटर के लिए, निम्नलिखित पर विचार करें:


<syntaxhighlight lang="pascal" line>
<syntaxhighlight lang="pascal" line>
Line 346: Line 349:
end.
end.
</syntaxhighlight>
</syntaxhighlight>
पंक्ति 6 ​​पर, (और नीचे की पंक्तियाँ) पैरामीटर {{code|1== 0}} कंपाइलर को बताता है, यदि कोई तर्क प्रदान नहीं किया गया है, तो तर्क को शून्य मान लें। पंक्ति 19 पर, कोई तर्क नहीं दिया गया, इसलिए फ़ंक्शन वापस आ जाता है {{code|0}}. लाइन 20 पर, किसी भी तर्क के लिए एक संख्या या एक चर प्रदान किया जा सकता है, और जैसा कि लाइन 22 पर दिखाया गया है, एक स्थिरांक।
पंक्ति 6 ​​पर, (और नीचे की पंक्तियाँ में) पैरामीटर {{code|1== 0}} संकलक को बताता है, "यदि कोई तर्क प्रदान नहीं किया गया है, तो तर्क को शून्य मानें"। पंक्ति 19 पर, कोई तर्क नहीं दिया गया, इसलिए प्रकार्य {{code|0}} लौटाता है। लाइन 20 पर, किसी भी तर्क के लिए या तो एक संख्या या एक चर प्रदान किया जा सकता है, और जैसा कि लाइन 22 पर दिखाया गया है, एक स्थिरांक।


===[[पीएचपी]] में===
===[[पीएचपी]] में===
Line 385: Line 388:


===रकु में===
===रकु में===
[[राकू (प्रोग्रामिंग भाषा)]] में, विभिन्न प्रकार के फ़ंक्शन बनाने वाले पैरामीटर के प्रकार को स्लर्पी एरे पैरामीटर के रूप में जाना जाता है और उन्हें तीन समूहों में वर्गीकृत किया जाता है:
[[राकू (प्रोग्रामिंग भाषा)]] में, विभिन्न प्रकार के प्रकार्य बनाने वाले पैरामीटर के प्रकार को स्लर्पी एरे पैरामीटर के रूप में जाना जाता है और उन्हें तीन समूहों में वर्गीकृत किया जाता है:


====चपटा घोल====
====चपटा घोल====
ये पैरामीटर एकल तारांकन के साथ घोषित किए गए हैं (<code>*</code>) और वे तत्वों की एक या अधिक परतों को भंग करके तर्कों को समतल करते हैं जिन्हें पुनरावृत्त किया जा सकता है (यानी, [https://docs.perl6.org/type/Iterable Iterables])।
इन मापदंडों को एक एकल तारांकन (*) के साथ घोषित किया जाता है और वे तत्वों की एक या अधिक परतों को भंग करके तर्कों को समतल करते हैं जिन्हें पुनरावृत्त किया जा सकता है (यानी, Iterables))।


<सिंटैक्सहाइलाइट लैंग= पर्ल6 >
 
उप foo($a, $b, *@args) {
sub foo($a, $b, *@args) {
    @args.perl कहें;
  say @args.perl;
}
}


फू(1,2) # []
foo(1,2) # []
फू(1,2,3) # [3]
 
फू(1, 2, 3, हैलो ) # [3 हैलो ]
foo(1,2,3) # [3]
फू(1, 2, 3, [4, 5], [6]); # [3, 4, 5, 6]
 
</सिंटैक्सहाइलाइट>
foo(1, 2, 3, "hello" ) # [3 "hello" ]
 
foo(1, 2, 3, [4, 5], [6]); # [3, 4, 5, 6]


====बिना चपटा घोल====
====बिना चपटा घोल====
ये पैरामीटर दो तारांकन () के साथ घोषित किए गए हैं और वे सूची के भीतर किसी भी पुनरावृत्त तर्क को समतल नहीं करते हैं, लेकिन तर्क को कमोबेश वैसे ही रखते हैं:
ये पैरामीटर दो तारांकन () के साथ घोषित किए गए हैं और वे सूची के अंदर किसी भी पुनरावृत्त तर्क को समतल नहीं करते हैं, लेकिन तर्क को कमोबेश वैसे ही रखते हैं:


<सिंटैक्सहाइलाइट लैंग= पर्ल6 >
 
सब बार($a, $b, **@args) {
sub bar($a, $b, **@args) {
    @args.perl कहें;
  say @args.perl;
}
}


बार(1,2); # []
bar(1,2); # []
बार(1, 2, 3); #[3]
 
बार(1, 2, 3, हैलो ); # [3 नमस्ते ]
bar(1, 2, 3); #[3]
बार(1, 2, 3, [4, 5], [6]); # [3, [4, 5], [6
 
</सिंटैक्सहाइलाइट>
bar(1, 2, 3, "hello" ); # [3 "hello" ]


====प्रासंगिक गंदी बात====
bar(1, 2, 3, [4, 5], [6]); # [3, [4, 5], [6]]
इन मापदंडों को प्लस के साथ घोषित किया गया है (<code>+</code>) पर हस्ताक्षर करते हैं और वे [https://docs.perl6.org/langage/functions#Slurpy_conventions एकल तर्क नियम] लागू करते हैं, जो यह तय करता है कि संदर्भ के आधार पर गंदे तर्क को कैसे संभालना है। सीधे शब्दों में कहें, यदि केवल एक ही तर्क पारित किया जाता है और वह तर्क पुनरावर्तनीय है, तो उस तर्क का उपयोग स्लरी पैरामीटर सरणी को भरने के लिए किया जाता है। किसी अन्य मामले में, <code>+@</code> जैसे काम करता है <code>**@</code> (अर्थात, बिना चपटा घोल)।


<सिंटैक्सहाइलाइट लैंग= पर्ल6 >
====प्रासंगिक घिनौना====
सब ज़ज़($a, $b, +@args) {
इन मापदंडों को प्लस (+) चिह्न के साथ घोषित किया जाता है और वे "एकल तर्क नियम लागू करते हैं जो यह तय करता है कि संदर्भ के आधार पर गंदे तर्क को कैसे संभालना है। सीधे शब्दों में कहें, यदि केवल एक ही तर्क पारित किया जाता है और वह तर्क पुनरावृत्त होता है, तो वह तर्क है स्लरी पैरामीटर सरणी को भरने के लिए उपयोग किया जाता है।  किसी अन्य मामले में, <code>+@</code> जैसे काम करता है <code>**@</code> (अर्थात, बिना चपटा घोल)।
     @args.perl कहें;
 
 
sub zaz($a, $b, +@args) {
     say @args.perl;
}
}


ज़ज़(1, 2); # []
zaz(1, 2); # []
ज़ज़(1, 2, 3); #[3]
 
ज़ज़(1, 2, 3, हैलो ); # [3 नमस्ते ]
zaz(1, 2, 3); #[3]
ज़ज़(1, 2, [4, 5]); # [4, 5], एकल तर्क सरणी भरता है
 
ज़ज़(1, 2, 3, [4, 5]); # [3, [4, 5, **@ के रूप में व्यवहार करना
zaz(1, 2, 3, "hello"); # [3 "hello" ]
ज़ज़(1, 2, 3, [4, 5], [6]); # [3, [4, 5], [6, **@ के रूप में व्यवहार करना
 
</सिंटैक्सहाइलाइट>
zaz(1, 2, [4, 5]); # [4, 5], single argument fills up array
 
zaz(1, 2, 3, [4, 5]); # [3, [4, 5, **behaving as **@
 
zaz(1, 2, 3, [4, 5], [6]); # [3, [4, 5], [6, **behaving as **@


===रूबी में===
===रूबी में===
Line 448: Line 459:


=== जंग में ===
=== जंग में ===
रस्ट (प्रोग्रामिंग भाषा) फ़ंक्शंस में विविध तर्कों का समर्थन नहीं करता है। इसके बजाय, यह [[मैक्रो (कंप्यूटर विज्ञान)]] का उपयोग करता है।<ref>{{cite web |title=विविधता|url=https://doc.rust-lang.org/rust-by-example/macros/variadics.html |website=Rust By Example}}</ref>
ज़ंग (प्रोग्रामिंग भाषा) प्रकार्य में विविध तर्कों का समर्थन नहीं करता है। इसके अतिरिक्त, यह [[मैक्रो (कंप्यूटर विज्ञान)]] का उपयोग करता है।<ref>{{cite web |title=विविधता|url=https://doc.rust-lang.org/rust-by-example/macros/variadics.html |website=Rust By Example}}</ref>


<syntaxhighlight lang="rust">
<syntaxhighlight lang="rust">
Line 475: Line 486:
}
}
</syntaxhighlight>
</syntaxhighlight>
जंग ए के माध्यम से सी की विविध प्रणाली के साथ बातचीत करने में सक्षम है {{code|c_variadic}} सुविधा स्विच. अन्य सी इंटरफेस की तरह, सिस्टम पर विचार किया जाता है {{code|unsafe}} जंग लगना।<ref>{{cite web |title=2137-variadic |url=https://rust-lang.github.io/rfcs/2137-variadic.html |website=The Rust RFC Book}}</ref>
जंग एक {{code|c_variadic}} फीचर स्विच के माध्यम से C के विविध प्रणाली के साथ बातचीत करने में सक्षम है। अन्य C इंटरफेस की तरह, सिस्टम को जंग के लिए {{code|unsafe}} माना जाता है।<ref>{{cite web |title=2137-variadic |url=https://rust-lang.github.io/rfcs/2137-variadic.html |website=The Rust RFC Book}}</ref>




Line 522: Line 533:


===[[ टी.सी.एल ]] में===
===[[ टी.सी.एल ]] में===
एक टीसीएल प्रक्रिया या लैम्ब्डा तब विविध होती है जब इसका अंतिम तर्क होता है {{code|args}}: इसमें शेष सभी तर्कों की एक सूची (संभवतः खाली) होगी। यह पैटर्न कई अन्य प्रक्रिया-जैसी विधियों में आम है।<ref>{{cite web |title=प्रोक मैनुअल पेज|url=https://www.tcl.tk/man/tcl/TclCmd/proc.html |website=Tcl/Tk Documentation}}</ref><ref>{{cite web |title=तर्क|url=https://wiki.tcl-lang.org/page/तर्क|website=Tcler's Wiki}}</ref>
एक टीसीएल प्रक्रिया या लैम्ब्डा तब विविध होती है जब इसका अंतिम तर्क {{code|args}}होता है : इसमें शेष सभी तर्कों की एक सूची (संभवतः खाली) होगी। यह पैटर्न कई अन्य प्रक्रिया-जैसी विधियों में आम है।<ref>{{cite web |title=प्रोक मैनुअल पेज|url=https://www.tcl.tk/man/tcl/TclCmd/proc.html |website=Tcl/Tk Documentation}}</ref><ref>{{cite web |title=तर्क|url=https://wiki.tcl-lang.org/page/तर्क|website=Tcler's Wiki}}</ref>


<syntaxhighlight lang="tcl">
<syntaxhighlight lang="tcl">

Revision as of 13:51, 11 July 2023

"Varargs" redirects here. For the varargs.h library in C, see varargs.h.

गणित और कंप्यूटर प्रोग्रामिंग में, एक विविध प्रकार्य अनिश्चितकालीन कार्य होता है, अर्थात, जो तर्कों की एक परिवर्तनीय संख्या को स्वीकार करता है। विविध प्रकार्यों के लिए समर्थन विभिन्न प्रोग्रामिंग भाषाओं में व्यापक रूप से भिन्न होता है।

परिवर्तनशील शब्द एक नवविज्ञानवाद है, जो 1936-1937 तक चला।[1] 1970 के दशक तक इस शब्द का व्यापक रूप से उपयोग नहीं किया गया था।

अवलोकन

ऐसे कई गणितीय और तार्किक संचालन हैं जो स्वाभाविक रूप से विविध प्रकार्यों के रूप में सामने आते हैं। उदाहरण के लिए, संख्याओं का योग या तार या अन्य अनुक्रमों का संयोजन ऐसे संचालन हैं जिन्हें किसी भी संख्या में संकार्य पर लागू माना जा सकता है (भले ही इन मामलों में औपचारिक रूप से सहयोगी संपत्ति लागू होती है)।

एक अन्य संचालन जिसे कई भाषाओं में विविध प्रकार्य के रूप में कार्यान्वित किया गया है वह है आउटपुट संरूपण। सी (प्रोग्रामिंग भाषा) कार्य मुद्रण और समान लिस्प कार्य प्रारूप ऐसे दो उदाहरण हैं। दोनों एक तर्क लेते हैं जो आउटपुट के स्वरूपण को निर्दिष्ट करता है, और किसी भी संख्या में तर्क जो स्वरूपित किए जाने वाले मान प्रदान करते हैं।

विविध प्रकार्य कुछ भाषाओं में प्रकार-सुरक्षा समस्याओं को उजागर कर सकते हैं। उदाहरण के लिए, सी कामुद्रण, यदि सावधानी से उपयोग किया जाता है, तो सुरक्षा छिद्रों के एक वर्ग को जन्म दे सकता है जिसे प्रारूप तार हमलों के रूप में जाना जाता है। हमला संभव है क्योंकि विविध प्रकार्य के लिए भाषा समर्थन प्रकार-सुरक्षित नहीं है: यह कार्य को ढेर से अधिक तर्कों को लोकप्रिय करने का प्रयास करने की अनुमति देता है, जिससे ढेर दूषित हो जाता है और अप्रत्याशित व्यवहार होता है। इसके परिणामस्वरूप, सीईआरटी समन्वय केंद्र सी में विविध प्रकार्यों को उच्च-गंभीर सुरक्षा जोखिम मानता है।[2]

कार्यात्मक भाषाओं में परिवर्तनशील को आवेदन करना कार्य का पूरक माना जा सकता है, जो एक कार्य और एक सूची/अनुक्रम/सरणी को तर्क के रूप में लेता है, और उस सूची में दिए गए तर्कों के साथ कार्य को कॉल करता है, इस प्रकार कार्य में तर्कों की एक चर संख्या पारित करता है।[citation needed] कार्यात्मक भाषा हास्केल (प्रोग्रामिंग भाषा) में, प्रकार वर्ग T का मान लौटाकर विविध प्रकार्यों को कार्यान्वित किया जा सकता है ; यदि के उदाहरण T अंतिम वापसी मान हैं r और एक कार्य (T t) => x -> t, यह किसी भी संख्या में अतिरिक्त तर्क की अनुमति देता है x.[further explanation needed]

शब्द पुनर्लेखन शोध में संबंधित विषय को बचाव या बचाव चर कहा जाता है।[3] विविधता के विपरीत, जो तर्कों के साथ कार्य हैं, बचाव स्वयं तर्कों के अनुक्रम हैं। उनके पास उस बिंदु तक बाधाएं भी हो सकती हैं (उदाहरण के लिए, 4 से अधिक तर्क न लें') जहां वे परिवर्तनीय-लंबाई नहीं हैं (जैसे कि 'बिल्कुल 4 तर्क लें') - इस प्रकार उन्हें विविधता कहना भ्रामक हो सकता है। हालाँकि, वे एक ही घटना का उल्लेख कर रहे हैं, और कभी-कभी वाक्यांशों को मिश्रित किया जाता है, जिसके परिणामस्वरूप विविध चर (बचाव का पर्याय) जैसे नाम सामने आते हैं। कार्यात्मक प्रोग्रामिंग और शब्द पुनर्लेखन में चर शब्द के दोहरे अर्थ और तर्कों और चर के बीच अंतर पर ध्यान दें। उदाहरण के लिए, एक शब्द (कार्य) में तीन चर हो सकते हैं, उनमें से एक बचाव है, इस प्रकार शब्द को तीन या अधिक तर्क लेने की अनुमति मिलती है (या यदि बचाव को खाली होने की अनुमति दी जाती है तो दो या अधिक)।

उदाहरण

सी में

C (प्रोग्रामिंग भाषा) में विविध प्रकार्यों को सुवाह्य रूप से लागू करने के लिए, मानक stdarg.h|stdarg.h हेडर पंक्ति का उपयोग किया जाता है. पुराने varargs.h|varargs.h हेडर के पक्ष में अस्वीकृत कर दिया गया है stdarg.h. C++ में, हेडर पंक्ति cstdarg प्रयोग किया जाता है।[4] 

#include <stdarg.h>
#include<stdio.h>

double average(int count, ...) {
    va_list ap;
    int j;
    double sum = 0;

    va_start(ap, count); /* Before C23: Requires the last fixed parameter (to get the address)*/
    for (j = 0; j < count; j++) {
        sum += va_arg(ap, int); /* Increments ap to the next argument. */
    }
    va_end(ap);

    return sum / count;
}

int main(int argc, char const *argv[]) {
    printf("%f\n", average(3, 1, 2, 3));
    return 0;
}

यह तर्कों की मनमानी संख्या के औसत की गणना करेगा। ध्यान दें कि कार्यों तर्कों की संख्या या उनके प्रकारों को नहीं जानता है। उपरोक्त कार्य अपेक्षा करता है कि प्रकार int होंगे , और तर्कों की संख्या पहले तर्क में पारित की जाएगी (यह एक लगातार उपयोग है लेकिन भाषा या संकलनकर्ता द्वारा किसी भी तरह से लागू नहीं किया गया है)। कुछ अन्य मामलों में, उदाहरण के लिए मुद्रण , एक प्रारूप तार से तर्कों की संख्या और प्रकार का पता लगाया जाता है। दोनों ही मामलों में, यह प्रोग्रामर पर निर्भर करता है कि वह सही जानकारी प्रदान करे। (वैकल्पिक रूप से, संख्या इंगित करने के लिए NULL जैसे प्रहरी मान का उपयोग किया जा सकता है।) यदि कार्य की अपेक्षा से कम तर्क पारित किए जाते हैं, या तर्क के प्रकार गलत हैं, तो यह इसे मेमोरी के अमान्य क्षेत्रों में पढ़ने का कारण बन सकता है और प्रारूप तार हमले जैसी कमजोरियों को जन्म दे सकता है। .

stdarg.h एक प्रकार घोषित करता है, va_list, और चार मैक्रोज़ को परिभाषित करता है:va_start, va_arg,va_copy, औरva_end. प्रत्येक मंगलाचरण va_start और va_copy के अनुरूप मंगलाचरण से मेल खाना चाहिए va_end. परिवर्तनीय तर्कों के साथ काम करते समय, एक कार्य सामान्यता एक प्रकार का चर घोषित करता है va_list (ap उदाहरण में) जिसे वृहत् द्वारा कुशलतापूर्वक किया जाएगा।

  1. va_start दो तर्क लेता है, a va_list ऑब्जेक्ट और कार्य के अंतिम प्राचल का संदर्भ (अध्याहार से पहले वाला; बहुत बड़ा इसका उपयोग अपने चाल प्राप्त करने के लिए करता है)। C23 में, दूसरे तर्क की अब आवश्यकता नहीं होगी और विविध प्रकार्यों को दीर्घवृत्त से पहले नामित प्राचल की आवश्यकता नहीं होगी।[note 1][6] यह आरंभ करता है va_list द्वारा उपयोग के लिए वस्तु va_arg या va_copy. यदि संदर्भ गलत है तो संकलनकर्ता सामान्यता एक चेतावनी जारी करेगा (उदाहरण के लिए पिछले प्राचल से भिन्न प्राचल का संदर्भ, या पूरी तरह से अलग ऑब्जेक्ट का संदर्भ), लेकिन संकलन को सामान्य रूप से पूरा होने से नहीं रोकेगा।
  2. va_arg दो तर्क लेता है, एक va_list ऑब्जेक्ट (पहले प्रारंभ किया गया) और एक प्रकार का वर्णनकर्ता। यह अगले चर तर्क तक विस्तारित होता है, और इसमें निर्दिष्ट प्रकार होता है। का क्रमिक आह्वान va_arg प्रत्येक परिवर्तनीय तर्क को बारी-बारी से संसाधित करने की अनुमति दें। अनिर्दिष्ट व्यवहार तब होता है जब प्रकार गलत है या कोई अगला चर तर्क नहीं है।
  3. va_end एक तर्क लेता है, एक va_list वस्तु। यह साफ़ करने का काम करता है. उदाहरण के लिए, यदि कोई चर तर्कों को एक से अधिक बार अवलोकन करना चाहता है, तो प्रोग्रामर आपका पुनः आरंभ करेगा va_list आह्वान द्वारा वस्तु va_end और तब va_start फिर से उस पर.
  4. va_copy दो तर्क लेता है, दोनों va_list वस्तुएं। यह दूसरे को (जिसे प्रारंभ किया गया होगा) पहले में प्रतिरूप करता है। एक से अधिक उदाहरणों में परिवर्तनीय तर्कों को अवलोकन करने पर वापस जाकर, इसे लागू करके प्राप्त किया जा सकता है va_start पहले पर va_list, फिर उपयोग करना va_copy इसे एक सेकंड में प्रतिरूप करने के लिए va_list. परिवर्तनीय तर्कों को पहली बार अवलोकन करने के बाद va_arg और पहला va_list (इसके साथ इसका निपटान va_end), प्रोग्रामर चर तर्कों को दूसरी बार अवलोकन कर सकता है va_arg और दूसरा va_list. va_end को प्रतिरूप पर भी कॉल करने की आवश्यकता है va_list युक्त कार्य के वापस आने से पहले।

सी# में

सी पार्श्व संकेतशब्द का उपयोग करके विविध प्रकार्यों का वर्णन करता है।, तर्कों के लिए एक प्रकार प्रदान किया जाना चाहिए हालांकि object[] का उपयोग अर्थबोधक के रूप में उपयोग किया जा सकता है। आजीविका स्थान पर, आप या तो तर्कों को एक-एक करके सूचीबद्ध कर सकते हैं, या आवश्यक तत्व प्रकार वाले पहले से मौजूद सरणी को सौंप सकते हैं। विविध रूप का उपयोग बाद के लिए वाक्यात्मक शर्करा है।


प्रणाली का उपयोग करना;

कक्षा कार्यक्रम

{ 

   static int Foo(int a, int b, params int[] args)
   {
       // Return the sum of the integers in args, ignoring a and b.          int sum = 0;
       foreach (int i in args)
           sum + = मैं;
       return sum;
   }
       
   static void Main(string[] args)
   {
       Console.WriteLine(Foo(1,2)); // 0
       Console.WriteLine(Foo(1, 2, 3, 10, 20)); //33
       int[] manyValues = new int[] {13, 14, 15 };
       Console.WriteLine(Foo(1,2, manyValues)); //42
   }

}

सी++ में

C++ में बुनियादी विविधतापूर्ण सुविधा बहुत हद तक C के समान है। एकमात्र अंतर वाक्य रचना में है, जहां दीर्घवृत्त से पहले अल्पविराम को छोड़ा जा सकता है। C++ नामित मापदंडों के बिना विविध प्रकार्यों की अनुमति देता है लेकिन तब से उन तर्कों तक पहुंचने का कोई तरीका प्रदान नहीं करता है va_start कार्य के अंतिम निश्चित तर्क के नाम की आवश्यकता है।

  1. include <iostream>
  2. include <cstdarg>

void simple_printf(const char* fmt...) // C-style const char* fmt, ... is also valid

{ 

   va_list args;
   va_start(args, fmt);

   while (*fmt != '\0') {
       if (*fmt == 'd') {
           int i = va_arg(args, int);
           std::cout << i << '\n';
       } else if (*fmt == 'c') {
           // note automatic conversion to integral type
           int c = va_arg(args, int);
           std::cout << static_cast<char>(c) << '\n';
       } else if (*fmt == 'f') {
           double d  = va_arg(args, double);
           std::cout << d << '\n';
       }
       ++ fmt;
   }

   va_end(args);

}

int main()

{ 

   simple_printf(dcff, 3, 'a', 1.999, 42.5);

}

विविध नमूना (पैरामीटर पैक) का उपयोग C++ में अंतर्निहित भाषा (उच्च-क्रम कार्य) के साथ भी किया जा सकता है।

  1. include <iostream>

template <typename... Ts>

void foo_print(Ts... args)

{ 

   ((std::cout << args << ), ...);

}

int main()

{ 

   std::cout << std::boolalpha;
   foo_print(1, 3.14f); // 1 3.14
   foo_print(Foo, 'b', true, nullptr); // Foo b true  nullptr

}

सी++ के लिए सीईआरटी कोडिंग मानक दुरुपयोग के कम जोखिम के कारण सी-स्टाइल विविध प्रकार्य की तुलना में सी++ में विविध नमूना (पैरामीटर पैक) के उपयोग को दृढ़ता से प्राथमिकता देते हैं।[7]


गो में

गो (प्रोग्रामिंग भाषा) में विविध प्रकार्य को किसी भी संख्या में अनुगामी तर्कों के साथ बुलाया जा सकता है।[8] fmt.Println एक सामान्य विविध प्रकार्य है; यह कैच-ऑल प्रकार के रूप में एक खाली अंतराफलक का उपयोग करता है। 

package main

import "fmt"

// This variadic function takes an arbitrary number of ints as arguments.
func sum(nums ...int) {
	fmt.Print("The sum of ", nums) // Also a variadic function.
.
	sum := 0
	for _, num := range nums {
		total += num
	}
	fmt.Println(" is", total) // Also a variadic function.
}

func main() {
	// Variadic functions can be called in the usual way with individual
// arguments.
	sum(1, 2)  // "The sum of [1 2] is 3"
	sum(1, 2, 3) // "The sum of [1 2 3] is 6"

	// If you already have multiple args in a slice, apply them to a variadic
	// function using func(slice...) like this.
	nums := []int{1, 2, 3, 4}
	sum(nums...) // "The sum of [1 2 3 4] is 10"
}

आउटपुट:

कुल मिलाकर [1 2] का योग 3 है

कुल मिलाकर [1 2 3] का योग 6 है

कुल मिलाकर [1 2 3 4] का योग 10 है

जावा में

C# की तरह, जावा (प्रोग्रामिंग भाषा) में } प्रकार कैच-ऑल के रूप में उपलब्ध है। 

public class Program {
    // Variadic methods store any additional arguments they receive in an array.
    // Consequentially, `printArgs` is actually a method with one parameter: a
    // variable-length array of `String`s.
    private static void printArgs(String... strings) {
        for (String string : strings) {
            System.out.println(string);
        }
    }

    public static void main(String[] args) {
        printArgs("hello");          // short for printArgs(["hello"])
        printArgs("hello", "world"); // short for printArgs(["hello", "world"])
    }
}


जावास्क्रिप्ट में

जावास्क्रिप्ट विभिन्न प्रकार के तर्कों की परवाह नहीं करता है। 

function sum(...numbers) {
    return numbers.reduce((a, b) => a + b, 0);
}

console.log(sum(1, 2, 3)); // 6
console.log(sum(3, 2));    // 5
console.log(sum());        // 0

तर्क ऑब्जेक्ट का उपयोग करके एक विविध प्रकार्य बनाना भी संभव है, हालांकि यह केवल प्रकार्य संकेतशब्द के साथ बनाए गए प्रकार्य के साथ प्रयोग करने योग्य है। 

function sum() {
    return Array.prototype.reduce.call(arguments, (a, b) => a + b, 0);
}

console.log(sum(1, 2, 3)); // 6
console.log(sum(3, 2));    // 5
console.log(sum());        // 0


लुआ (प्रोग्रामिंग भाषा) में

लुआ (प्रोग्रामिंग भाषा) प्रकार्य वापसी संकेतशब्द का उपयोग करके अन्य मानों की तरह ही अन्य प्रकार्य में वेरार्ग पास कर सकते हैं। लूआ संस्करण 5.2 या उच्चतर का उपयोग करके तालिकाओं को विविध प्रकार्यों में पारित किया जा सकता है[9] table.unpack, या लुआ 5.1 या उससे कम[10] unpack. वेरार्ग को एक मान के रूप में वेरार्ग के साथ एक तालिका बनाकर उपयोग किया जा सकता है।

function sum(...) --... designates varargs

   local sum=0
   for _,v in pairs({...}) do --creating a table with a varargs is the same as creating one with standard values
      sum=sum+v
   end
   return sum
end

values={1,2,3,4}
sum(5,table.unpack(values)) --returns 15. table.unpack should go after any other arguments, otherwise not all values will be passed into the function.

function add5(...)
  return ...+5 --this is incorrect usage of varargs, and will only return the first value provided
end

entries={}
function process_entries()
   local processed={}
   for i,v in pairs(entries) do
      processed[i]=v --placeholder processing code
   end
   return table.unpack(processed) --returns all entries in a way that can be used as a vararg

end

print(process_entries()) --the print function takes all varargs and writes them to stdout separated by newlines


पास्कल (प्रोग्रामिंग भाषा) में

पास्कल (प्रोग्रामिंग भाषा) में चार अंतर्निहित प्रक्रियाएं हैं जिन्हें विविध के रूप में परिभाषित किया गया है, जो इस विशेष स्थिति के कारण, संकलक के लिए आंतरिक हैं। ये हैं पढ़ें, readln, लिखें, और writeln प्रक्रियाएं. हालाँकि, प्रक्रियाओं या कार्यों के लिए डिफ़ॉल्ट तर्क की अनुमति देने वाले वैकल्पिक विनिर्देश हैं जो उन्हें विविध रूप से काम करते हैं, साथ ही बहुरूपता (कंप्यूटर विज्ञान)भी है जो एक प्रक्रिया या प्रकार्य को अलग-अलग पैरामीटर रखने की अनुमति देता है। वह read[ln] और write[ln] सभी प्रक्रियाओं का प्रारूप समान है:


पढ़ें[एलएन] [( [फ़ाइल ,] चर [, चर ...] )] ;

लिखें[एलएन] [( [फ़ाइल][, मूल्य [, मूल्य ...] )] ;

कहाँ

  • file एक वैकल्पिक फ़ाइल चर है, जिसे यदि छोड़ दिया जाए तो यह डिफ़ॉल्ट हो जाता है input के लिए read और readln, या डिफ़ॉल्ट output के लिए write और writeln;
  • variable एक अदिश राशि है जैसे कि चार (वर्ण), पूर्णांक, या वास्तविक (या कुछ संकलक के लिए, कुछ रिकॉर्ड प्रकार या सरणी प्रकार जैसे स्ट्रिंग); और
  • value एक चर या स्थिरांक है।

उदाहरण: 

var 
   f: text;
   ch: ;char
   n,a,I,B: Integer;
   S: String;

begin
    Write('Enter name of file to write results: ');
    readln(s);    
    assign(f,S);
    rewrite(f);
    Write('What is your name? ');
    readln(Input,S);        
    Write('Hello, ',S,'! Enter the number of calculations you want to do:');
    writeln(output);
    Write('? ');
    readln(N);
    Write('For each of the ',n,' formulas, enter ');
    write('two integers separated by one or more spaces');
    writeln;
    for i := 1 to N do
    begin   
       Write('Enter pair #',i,'? ');
       read(a,b);
       READLN;
       WRITELN(Out,'A [',a,'] + B [',B,'] =',A+B);
    end;
    close(OUT);
end.

उपरोक्त उदाहरण में, जहां तक ​​संकलक का सवाल है, लाइनें 9 और 13 समान हैं, क्योंकि यदि input फ़ाइल चर को read या readln कथन द्वारा पढ़ा जा रहा है तो फ़ाइल चर को छोड़ा जा सकता है। साथ ही, संकलक पंक्ति 15 और 20 को समान मानता है, क्योंकि यदि फ़ाइल चर को outputमें लिखा जा रहा है ,तो इसे छोड़ा जा सकता है, जिसका अर्थ है (पंक्ति 20 पर) क्योंकि प्रक्रिया में कोई तर्क पारित नहीं किया जा रहा है, कोष्ठक तर्कों को सूचीबद्ध करते हैं मिटाया जा सकता है। पंक्ति 26 से पता चलता है कि writeln कथन में किसी भी संख्या में तर्क हो सकते हैं, और वे एक उद्धृत स्ट्रिंग, एक चर, या यहां तक ​​कि एक सूत्र परिणाम भी हो सकते हैं।

ऑब्जेक्ट पास्कल बहुरूपी प्रक्रियाओं और कार्यों का समर्थन करता है, जहां विभिन्न प्रक्रियाओं या कार्यों का एक ही नाम हो सकता है लेकिन उन्हें दिए गए तर्कों से अलग किया जा सकता है।

पास्कल अनुपस्थिति तर्कों का भी समर्थन करता है, जहां तर्क का मान, यदि प्रदान नहीं किया गया है, तो एक अनुपस्थिति मान दिया जाता है।

पहले उदाहरण के लिए, बहुरूपता, निम्नलिखित पर विचार करें: 

function add(a1,a2:integer):Integer; begin add := a1+a2 end;                                
function add(r1,r2:real):real;  begin add := a1+a2 end;                                 
function add(a1:integer;r2:real):real;  begin add := real(a1)+a2 end;                                
function add(r1:real,a2:integer):real;  begin add := a1+real(a2) end;

उपरोक्त उदाहरण में, यदि दो पूर्णांक मानों के साथ कोadd कहा जाता है, पंक्ति 1 पर घोषित प्रकार्य को बुलाया जाएगा; यदि तर्कों में से एक पूर्णांक है और एक वास्तविक है, तो पंक्ति 3 या 4 पर प्रकार्य को कॉल किया जाता है, जो इस पर निर्भर करता है कि कौन सा पूर्णांक है। यदि दोनों वास्तविक हैं, तो पंक्ति 2 पर प्रकार्य को कॉल किया जाता है।

अनुपस्थिति पैरामीटर के लिए, निम्नलिखित पर विचार करें: 

const
   Three = 3;
var 
   K: Integer;

function add(i1: integer = 0; 
             i2: integer = 0;
             i3: integer = 0; 
             i4: integer = 0; 
             i5: integer = 0; 
             i6: integer = 0;  
             i7: integer = 0;  
             i8: integer = 0): integer;
begin
   add := i1+i2+i3+I4+I5+i6+I7+I8;
end;

begin
   K := add; { K is 0}
   K := add(K,1); { K is 1}
   K := add(1,2); { K is 3}
   K := add(1,2,Three); { K is 6, etc.}
end.

पंक्ति 6 ​​पर, (और नीचे की पंक्तियाँ में) पैरामीटर = 0 संकलक को बताता है, "यदि कोई तर्क प्रदान नहीं किया गया है, तो तर्क को शून्य मानें"। पंक्ति 19 पर, कोई तर्क नहीं दिया गया, इसलिए प्रकार्य 0 लौटाता है। लाइन 20 पर, किसी भी तर्क के लिए या तो एक संख्या या एक चर प्रदान किया जा सकता है, और जैसा कि लाइन 22 पर दिखाया गया है, एक स्थिरांक।

पीएचपी में

जब तक तर्क टाइप नहीं किया जाता है तब तक PHP विभिन्न प्रकार के तर्कों की परवाह नहीं करता है। 

function sum(...$nums): int
{
    return array_sum($nums);
}

echo sum(1, 2, 3); // 6

और विविध तर्क टाइप किए: 

function sum(int ...$nums): int
{
    return array_sum($nums);
}

echo sum(1, 'a', 3); // TypeError: Argument 2 passed to sum() must be of the type int (since PHP 7.3)


पायथन में

पायथन (प्रोग्रामिंग भाषा) विभिन्न प्रकार के तर्कों की परवाह नहीं करता है। 

def foo(a, b, *args):
    print(args)  # args is a tuple (immutable sequence).

foo(1, 2) # ()
foo(1, 2, 3) # (3,)
foo(1, 2, 3, "hello") # (3, "hello")

कीवर्ड तर्कों को शब्दकोश में संग्रहित किया जा सकता है, उदा. def bar(*args, **kwargs).

रकु में

राकू (प्रोग्रामिंग भाषा) में, विभिन्न प्रकार के प्रकार्य बनाने वाले पैरामीटर के प्रकार को स्लर्पी एरे पैरामीटर के रूप में जाना जाता है और उन्हें तीन समूहों में वर्गीकृत किया जाता है:

चपटा घोल

इन मापदंडों को एक एकल तारांकन (*) के साथ घोषित किया जाता है और वे तत्वों की एक या अधिक परतों को भंग करके तर्कों को समतल करते हैं जिन्हें पुनरावृत्त किया जा सकता है (यानी, Iterables))।


sub foo($a, $b, *@args) { 

  say @args.perl;

}

foo(1,2) # []

foo(1,2,3) # [3]

foo(1, 2, 3, "hello" ) # [3 "hello" ]

foo(1, 2, 3, [4, 5], [6]); # [3, 4, 5, 6]

बिना चपटा घोल

ये पैरामीटर दो तारांकन () के साथ घोषित किए गए हैं और वे सूची के अंदर किसी भी पुनरावृत्त तर्क को समतल नहीं करते हैं, लेकिन तर्क को कमोबेश वैसे ही रखते हैं:


sub bar($a, $b, **@args) { 

  say @args.perl;

}

bar(1,2); # []

bar(1, 2, 3); #[3]

bar(1, 2, 3, "hello" ); # [3 "hello" ]

bar(1, 2, 3, [4, 5], [6]); # [3, [4, 5], [6]]

प्रासंगिक घिनौना

इन मापदंडों को प्लस (+) चिह्न के साथ घोषित किया जाता है और वे "एकल तर्क नियम लागू करते हैं जो यह तय करता है कि संदर्भ के आधार पर गंदे तर्क को कैसे संभालना है। सीधे शब्दों में कहें, यदि केवल एक ही तर्क पारित किया जाता है और वह तर्क पुनरावृत्त होता है, तो वह तर्क है स्लरी पैरामीटर सरणी को भरने के लिए उपयोग किया जाता है। किसी अन्य मामले में, +@ जैसे काम करता है **@ (अर्थात, बिना चपटा घोल)।


sub zaz($a, $b, +@args) { 

   say @args.perl;

}

zaz(1, 2); # []

zaz(1, 2, 3); #[3]

zaz(1, 2, 3, "hello"); # [3 "hello" ]

zaz(1, 2, [4, 5]); # [4, 5], single argument fills up array

zaz(1, 2, 3, [4, 5]); # [3, [4, 5, **behaving as **@

zaz(1, 2, 3, [4, 5], [6]); # [3, [4, 5], [6, **behaving as **@

रूबी में

रूबी (प्रोग्रामिंग भाषा) विभिन्न प्रकार के तर्कों की परवाह नहीं करती है। 

def foo(*args)
  print args
end

foo(1)
# prints `[1]=> nil`

foo(1, 2)
# prints `[1, 2]=> nil`


जंग में

ज़ंग (प्रोग्रामिंग भाषा) प्रकार्य में विविध तर्कों का समर्थन नहीं करता है। इसके अतिरिक्त, यह मैक्रो (कंप्यूटर विज्ञान) का उपयोग करता है।[11] 

macro_rules! calculate {
    // The pattern for a single `eval`
    (eval $e:expr) => {{
        {
            let val: usize = $e; // Force types to be integers
            println!("{} = {}", stringify!{$e}, val);
        }
    }};

    // Decompose multiple `eval`s recursively
    (eval $e:expr, $(eval $es:expr),+) => {{
        calculate! { eval $e }
        calculate! { $(eval $es),+ }
    }};
}

fn main() {
    calculate! { // Look ma! Variadic `calculate!`!
        eval 1 + 2,
        eval 3 + 4,
        eval (2 * 3) + 1
    }
}

जंग एक c_variadic फीचर स्विच के माध्यम से C के विविध प्रणाली के साथ बातचीत करने में सक्षम है। अन्य C इंटरफेस की तरह, सिस्टम को जंग के लिए unsafe माना जाता है।[12]


स्काला में

object Program {
  // Variadic methods store any additional arguments they receive in an array.
  // Consequentially, `printArgs` is actually a method with one parameter: a
  // variable-length array of `String`s.
  private def printArgs(strings: String*): Unit = {
    strings.foreach(println)
  }

  def main(args: Array[String]): Unit = {
    printArgs("hello");          // short for printArgs(["hello"])
    printArgs("hello", "world"); // short for printArgs(["hello", "world"])
  }
}


स्विफ्ट में

स्विफ्ट (प्रोग्रामिंग भाषा) विभिन्न प्रकार के तर्कों की परवाह करती है, लेकिन सभी को पकड़ती है Any प्रकार उपलब्ध है. 

func greet(timeOfTheDay: String, names: String...) {
    // here, names is [String]
    
    print("Looks like we have \(names.count) people")
    
    for name in names {
        print("Hello \(name), good \(timeOfTheDay)")
    }
}

greet(timeOfTheDay: "morning", names: "Joseph", "Clara", "William", "Maria")

// Output:
// Looks like we have 4 people
// Hello Joseph, good morning
// Hello Clara, good morning
// Hello William, good morning
// Hello Maria, good morning


टी.सी.एल में

एक टीसीएल प्रक्रिया या लैम्ब्डा तब विविध होती है जब इसका अंतिम तर्क argsहोता है : इसमें शेष सभी तर्कों की एक सूची (संभवतः खाली) होगी। यह पैटर्न कई अन्य प्रक्रिया-जैसी विधियों में आम है।[13][14] 

proc greet {timeOfTheDay args} {
    puts "Looks like we have [llength $args] people"

    foreach name $args {
        puts "Hello $name, good $timeOfTheDay"
    }
}

greet "morning" "Joseph" "Clara" "William" "Maria"

# Output:
# Looks like we have 4 people
# Hello Joseph, good morning
# Hello Clara, good morning
# Hello William, good morning
# Hello Maria, good morning


यह भी देखें

टिप्पणियाँ

  1. ↑ Making the named parameter optional was needed since there was no way to specify a function taking an unspecified number of arguments in C23 after the removal of K&R style function definitions. Since C++ was already using this syntax for the same purpose, this change was also a way to increase compatibility between the languages.[5]


संदर्भ

  1. ↑ Henry S. Leonard and H. N. Goodman, A calculus of individuals. Abstract of a talk given at the Second Meeting of the Association for Symbolic Logic, held in Cambridge MA on December 28–30, 1936, [1], Journal of Symbolic Logic 2(1) 1937, 63.
  2. ↑ Klemens, Ben (2014). 21st Century C: C Tips from the New School. O'Reilly Media, Inc. p. 224. ISBN 978-1491904442.
  3. ↑ CLP (H): Constraint Logic Programming for Hedges
  4. ↑ "<cstdarg> (stdarg.h) - C++ Reference". www.cplusplus.com.
  5. ↑ "C23 is Finished: Here is What is on the Menu §N2975 - Relax requirements for variadic parameter lists". 31 July 2022.
  6. ↑ Gilding, Alex; Meneide, JeanHeyd (2022-04-15). "WG14-N2975 : Relax requirements for variadic parameter lists, v3" (PDF).
  7. ↑ "DCL50-CPP. Do not define a C-style variadic function".
  8. ↑ "Go by Example: Variadic Functions".
  9. ↑ "Lua 5.2 Reference Manual". www.lua.org. Retrieved 2023-02-05.
  10. ↑ "Lua 5.1 Reference Manual". www.lua.org. Retrieved 2023-02-05.
  11. ↑ "विविधता". Rust By Example.
  12. ↑ "2137-variadic". The Rust RFC Book.
  13. ↑ "प्रोक मैनुअल पेज". Tcl/Tk Documentation.
  14. ↑ "तर्क". Tcler's Wiki.


बाहरी संबंध

Retrieved from ‘https://www.vigyanwiki.in/index.php?title=वैरिएडिक_फ़ंक्शन&oldid=217489’