C++ Functions

 

 

---

A function is a block of code which only runs when it is called.

You can pass data, known as parameters, into a function.

Functions are used to perform certain actions, and they are important for reusing code: Define the code once, and use it many times.

Function code का एक समुह  है जो केवल तभी execute होता है जब इसे call किया जाता है।

आप किसी function में data, जिसे parameter के रूप में जाना जाता है, pass कर सकते हैं।

Function का उपयोग कुछ कार्यों को करने के लिए किया जाता है, और वे कोड का reuse (पुन: उपयोग) करने के लिए महत्वपूर्ण हैं: कोड को एक बार define (परिभाषित) करें, और इसे कई बार उपयोग करें।

---

Create a Function

C++ provides some pre-defined functions, such as main(), which is used to execute code. But you can also create your own functions to perform certain actions.

To create (often referred to as declare) a function, specify the name of the function, followed by parentheses ():

C++ कुछ pre-defined (पूर्व-परिभाषित) फ़ंक्शन प्रदान करता है, जैसे कि main(), जिसका उपयोग कोड execute करने के लिए किया जाता है। लेकिन आप कुछ कार्यों को करने के लिए अपने स्वयं के function भी बना सकते हैं।

एक function बनाने के लिए (जिसे अक्सर declare कहा जाता है), function का नाम specify (निर्दिष्ट) करें, उसके बाद parentheses ():

Syntax

void myFunction() {
  // code to be executed
}

Example Explained

• myFunction() is the name of the function
• void means that the function does not have a return value. You will learn more about return values later in the next chapter
• inside the function (the body), add code that defines what the function should do

• myFunction() फ़ंक्शन का नाम है

• void का अर्थ है कि function कुछ भी return नही करेगा। आप अगले अध्याय में return value के बारे में अधिक जानेंगे

• function (body) के अंदर, code लिखे जो define करता है कि function को क्या करना चाहिए

---

Call a Function

Declared functions are not executed immediately. They are "saved for later use", and will be executed later, when they are called.

To call a function, write the function's name followed by two parentheses () and a semicolon ;

In the following example, myFunction() is used to print a text (the action), when it is called:

Declared function को तुरंत execute नहीं किया जाता है। उन्हें "बाद में use के लिए saved किया गया है", और बाद में, जब उन्हें call किया जाएगा, execute किया जाएगा।

किसी function को call करने के लिए, function का नाम और उसके बाद parentheses () और एक semicolon (;) लिखें|

निम्नलिखित उदाहरण में, myFunction() का उपयोग किसी text को प्रिंट करने के लिए किया जाता है, जब इसे call किया जाता है:

Example

Inside main, call myFunction():

// Create a function
void myFunction() {
  cout << "I just got executed!";
}

int main() {
  myFunction(); // call the function
  return 0;
}

// Outputs "I just got executed!"

A function can be called multiple times:

Example

void myFunction() {
  cout << "I just got executed!\n";
}

int main() {
  myFunction();
  myFunction();
  myFunction();
  return 0;
}

// I just got executed!
// I just got executed!
// I just got executed!

---

 

---

Function Declaration and Definition

A C++ function consist of two parts:

• Declaration: the return type, the name of the function, and parameters (if any)
• Definition: the body of the function (code to be executed)

C++ function में दो भाग होते हैं:

• Declaration: return type, function का नाम और parameter (यदि कोई हो)

• Definition: function का body (execute किया जाने वाला code)

void myFunction() { // declaration
  // the body of the function (definition)
}

Note: If a user-defined function, such as myFunction() is declared after the main() function, an error will occur:

यदि एक user defined function, जैसा कि myfunction() को main() function के बाद declare किया जाता है तो error देगा |

Example

int main() {
  myFunction();
  return 0;
}

void myFunction() {
  cout << "I just got executed!";
}

// Error

However, it is possible to separate the declaration and the definition of the function - for code optimization.

You will often see C++ programs that have function declaration above main(), and function definition below main(). This will make the code better organized and easier to read:

हालाँकि, code optimization के लिए declaration और function की definition को अलग करना संभव है।

आप अक्सर C++ प्रोग्राम देखेंगे जिनमें main() के ऊपर function declaration और main() के नीचे function definition होती है। इससे code बेहतर ढंग से व्यवस्थित हो जाएगा और पढ़ने में आसान हो जाएगा:

Example

// Function declaration
void myFunction();

// The main method
int main() {
  myFunction();  // call the function
  return 0;
}

// Function definition
void myFunction() {
  cout << "I just got executed!";
}

C++ Function Parameters

 

---

Parameters and Arguments

Information can be passed to functions as a parameter. Parameters act as variables inside the function.

Parameters are specified after the function name, inside the parentheses. You can add as many parameters as you want, just separate them with a comma:

Information को एक parameter के रूप में functions में pass किया जा सकता है। Parameter function के अंदर variable के रूप में कार्य करते हैं।

Parameter, function के नाम के बाद, कोष्ठक के अंदर दिये जाते हैं। आप जितने चाहें उतने parameter जोड़ सकते हैं, बस उन्हें comma से अलग करें:

Syntax

void functionName(parameter1, parameter2, parameter3) {
  // code to be executed
}

The following example has a function that takes a string called fname as parameter. When the function is called, we pass along a first name, which is used inside the function to print the full name:

निम्नलिखित उदाहरण में एक function है जो fname नामक string को parameter के रूप में लेता है। जब function को call किया जाता है, तो हम first name देते हैं, जिसका उपयोग function के अंदर full नाम print करने के लिए किया जाता है:

Example

void myFunction(string fname) {
  cout << fname << " Refsnes\n";
}

int main() {
  myFunction("Liam");
  myFunction("Jenny");
  myFunction("Anja");
  return 0;
}

// Liam Refsnes
// Jenny Refsnes
// Anja Refsnes

When a parameter is passed to the function, it is called an argument. So, from the example above: fname is a parameter, while Liam, Jenny and Anja are arguments.

जब किसी parameter को function में पास किया जाता है, तो इसे argument कहा जाता है। तो, उपरोक्त उदाहरण से: fname एक parameter है, जबकि Liam, Jenny और Anja argument हैं।

---

C++ Default Parameters

 

---

Default Parameter Value

You can also use a default parameter value, by using the equals sign (=).

If we call the function without an argument, it uses the default value ("Norway"):

आप equal sign (=) का उपयोग करके default parameter value का भी उपयोग कर सकते हैं।

यदि हम function को बिना किसी argument के call करते हैं, तो यह default value ("Norway") का उपयोग करता है:

Example

void myFunction(string country = "Norway") {
  cout << country << "\n";
}

int main() {
  myFunction("Sweden");
  myFunction("India");
  myFunction();
  myFunction("USA");
  return 0;
}

// Sweden
// India
// Norway
// USA

Try it Yourself »

A parameter with a default value, is often known as an "optional parameter". From the example above, country is an optional parameter and "Norway" is the default value.

Default value वाले parameter को अक्सर "optional parameter" के रूप में जाना जाता है। उपरोक्त उदाहरण से, country एक optional parameter है और "Norway" default value है।

---

C++ Multiple Parameters

 

---

Multiple Parameters

Inside the function, you can add as many parameters as you want:

फ़ंक्शन के अंदर, आप जितने चाहें उतने parameter add कर सकते हैं:

Example

void myFunction(string fname, int age) {
  cout << fname << " Refsnes. " << age << " years old. \n";
}

int main() {
  myFunction("Liam", 3);
  myFunction("Jenny", 14);
  myFunction("Anja", 30);
  return 0;
}

// Liam Refsnes. 3 years old.
// Jenny Refsnes. 14 years old.
// Anja Refsnes. 30 years old.

Note that when you are working with multiple parameters, the function call must have the same number of arguments as there are parameters, and the arguments must be passed in the same order.

जब आप multiple parameter के साथ काम कर रहे होते हैं, तो function call में arguments की संख्या उतनी ही होनी चाहिए जितनी parameter हैं, और arguments को उसी order में pass किया जाना चाहिए।

 

C++ Recursion

Recursion

Recursion is the technique of making a function call itself. This technique provides a way to break complicated problems down into simple problems which are easier to solve.

Recursion may be a bit difficult to understand. The best way to figure out how it works is to experiment with it.

Recursion किसी function को स्वयं call करने की technique है। यह technique complex problem को simple problem में तोड़ने का एक तरीका प्रदान करती है जिन्हें हल करना आसान होता है।

Recrsion को समझना थोड़ा मुश्किल हो सकता है। यह कैसे काम करता है इसका पता लगाने का सबसे अच्छा तरीका इसके साथ प्रयोग करना है।

 

Recursion Example

Adding two numbers together is easy to do, but adding a range of numbers is more complicated. In the following example, recursion is used to add a range of numbers together by breaking it down into the simple task of adding two numbers:

दो संख्याओं को एक साथ जोड़ना आसान है, लेकिन संख्याओं की एक range को जोड़ना अधिक complex है। निम्नलिखित उदाहरण में, recursion का उपयोग संख्याओं की एक range को दो संख्याओं को जोड़ने के simple function में तोड़कर एक साथ जोड़ने के लिए किया जाता है:

Example

int sum(int k) {
  if (k > 0) {
    return k + sum(k - 1);
  } else {
    return 0;
  }
}

int main() {
  int result = sum(10);
  cout << result;
  return 0;
}

Example Explained

When the sum() function is called, it adds parameter k to the sum of all numbers smaller than k and returns the result. When k becomes 0, the function just returns 0. When running, the program follows these steps:

10 + sum(9)
Since the function does not call itself when k is 0, the program stops there and returns the result.

जब sum() फ़ंक्शन को call किया जाता है, तो यह k से छोटी सभी संख्याओं के sum में parameter k जोड़ता है और result देता है। जब k 0 हो जाता है, तो function केवल 0 return है। चलते समय, प्रोग्राम इन steps का पालन करता है:

10 + योग(9)

चूँकि k 0 होने पर function self-call नहीं करता है, प्रोग्राम वहीं रुक जाता है और result return कर् देता  है।

The developer should be very careful with recursion as it can be quite easy to slip into writing a function which never terminates, or one that uses excess amounts of memory or processor power. However, when written correctly recursion can be a very efficient and mathematically-elegant approach to programming.

 

Developer को recursion से बहुत सावधान रहना चाहिए क्योंकि ऐसे function को लिखना काफी आसान हो सकता है जो कभी समाप्त नहीं होता है, या जो अधिक मात्रा में मेमोरी या processor पावर का उपयोग करता है। हालाँकि, जब सही ढंग से लिखा जाता है तो recursion programming के लिए एक बहुत ही कुशल(efficient) और mathematical रूप से सुरुचिपूर्ण हो सकता है।