1.3a
— cout, cin, endl, std namespace और using statements पर एक नज़र
std::cout
जैसा की पिछले sections में बताया गया, std::cout (जो iostream library का हिस्सा है) का
इस्तेमाल screen पर text
output करने के लिए किया जाता है । फिर से
याद दिलाने के लिए ये रहा हमारा Hello world program:
|
1
2
3
4
5
6
7
|
#include <iostream>
int main()
{
std::cout <<
"Hello world!";
return 0;
}
|
एक ही line में एक से अधिक चीजें print करने के लिए output operator (<<) का इस्तेमाल एक से ज्यादा बार किया जा सकता है । उदाहरण के लिए:
|
1
2
3
4
5
6
7
8
|
#include <iostream>
int main()
{
int x = 4;
std::cout <<
"x is equal to: " << x;
return 0;
}
|
ये program निम्नलिखित output देगा:
x is equal to: 4
आपको क्या लगता है, नीचे दिया गया program क्या print करेगा ?
|
1
2
3
4
5
6
7
8
|
#include <iostream>
int main()
{
std::cout <<
"Hi!";
std::cout <<
"My name is Alex.";
return 0;
}
|
आपको Result चौंकाने वाला लग
सकता है । ये program निम्नलिखित output देगा:
Hi!My name is Alex.
std::endl
यदि हमे एक से ज्यादा lines print करना है, हम std::endl
की मदद से ये कर सकते हैं । जब std::endl
का प्रयोग std::cout
के साथ किया जाता है, ये screen पर एक new line
character डाल देता है (अर्थात cursor को अगले line पर ले जाता है) ।
उदाहरण के लिए:
|
1
2
3
4
5
6
7
8
|
#include <iostream>
int main()
{
std::cout <<
"Hi!" << std::endl;
std::cout <<
"My name is Alex." << std::endl;
return 0;
}
|
ये code print करेगा:
Hi!
My name is Alex.
std::cin
std::cin
std::cout का बिलकुल opposite
(उल्टा) है -- जहां std::cout
output operator (<<) के द्वारा भेजे गए data को console पर print करता है, वहीँ std::cin
input operator (>>) के द्वारा console में user से input लेता है । आप variables से परिचित हो चुके हैं, इसलिए अब हम std::cin का प्रयोग user से input लेकर किसी variable में store करना सीखेंगे ।
|
1
2
3
4
5
6
7
8
9
10
11
|
//#include "stdafx.h" // यदि Visual Studio use कर रहे हैं तो इस
line को uncomment
कीजिये
#include <iostream>
int main()
{
std::cout <<
"Enter a number: "; // user से एक number माँगा जा रहा है
int x = 0;
std::cin >> x;
// console से user द्वारा दिए गये number को read कर x पर store कर रहा है
std::cout <<
"You entered " << x << std::endl;
return 0;
}
|
इस program को खुद से compile और run करने की कोशिश
कीजिये । जब आप इस program को run करोगे, सबसे पहले print होगा: “Enter a number: ” और फिर ये आपके input का इंतज़ार करेगा । जब आप कोई number type कर enter key press करोगे तो ये print करेगा: “You entered ” और इसके बाद वो number जो आपने input किया था ।
उदाहरण के लिए मान लेते हैं आपने 4 enter किया:
Enter a number: 4
You entered 4
ये user से input लेने का बहुत आसान तरीका है, और इसका प्रयोग आने वाले बहुत सारे examples में किया जाने वाला है ।
यदि आपके number enter करने के बाद screen तुरंत बंद हो जाता है तो कृपया 0.7 — C++ में आने वालीं कुछ
सामान्य परेशानियाँ में दिए गये solutions पर एक नज़र डालिए ।
(एक मजेदार side note, यदि आप कोई बहुत बड़ा number enter करोगे तो program के results आपको झटका दे सकते
हैं । इसे एक बार कर के देखें! ऐसा इसलिए होता है क्यूंकि x एक निश्चित सीमा तक ही numbers को store कर सकता है । इसके
बाद, ये “overflow”
कर जाता है । आगे आने वाले section में हम overflow पर चर्चा करेंगे ।)
std::cin,
std::cout, << और >>
नये programmers अकसर std::cin,
std::cout, << और >>
को एक ही समझ बैठते हैं । इन्हें याद
रखने का एक आसान तरीका नीचे दिया गया है:
- std::cin
और std::cout हमेसा किसी statement की बायीं ओर होते हैं
- std::cout
का इस्तेमाल value का output
देने के लिए होता है (cout = output)
- std::cin
का इस्तेमाल यूजर से input value लेने के लिए होता है (cin = input)
- <<
को हमेसा std::cout के साथ इस्तेमाल किया जाता है, और ध्यान दीजिये की इस symbol का direction
r-value से console की तरफ जाता हुआ दिखाई देता है । std::cout << 4 value 4 को console की तरफ भेजता है
- >>
को हमेसा std::cin के साथ इस्तेमाल किया जाता है, और इसका direction console से variable
की तरफ जाता हुआ दिखाई पड़ता है । std::cin >> x दिए गये value
को console से
x के तरफ भेजता है
std
namespace
Standard
library में हर चीज़ एक विशेष container
के अंदर रहता है (जिसे namespace कहते हैं) जिसका नाम std (“standard”
का छोटा रूप) है ।
इससे ये समझा जा सकता है की std::cout का नाम असल में “std::cout” नही है । ये सिर्फ “cout” है और “std”, उस namespace का नाम है जिसके
अंदर cout रहता है ।
हम आने वाले एक section में namespaces के बारे में और
अधिक चर्चा करेंगे और साथ ही ये भी जानेंगे की हम खुद अपना namespace
कैसे बना सकते हैं । अभी के लिए,
namespaces के बारे में बस इतना जानना काफी है की
जब भी हम किसी ऐसी चीज़ का इस्तेमाल करते हैं जो standard
library का हिस्सा है (जैसे की cout), हमे compiler को बताना पड़ता है
की वो std namespace के अन्दर है ।
Explicit
namespace qualifier std::
“std::”
prefix का इस्तेमाल कर हम compiler को ये बता सकते हैं की cout std namespace के अन्दर है:
|
1
|
std::cout << "Hello
world!";
|
ये cout को अपने program में इस्तेमाल करने का सबसे सुरक्षित तरीका है, क्यूंकि compiler को यहाँ बिना किसी दिक्कत के पता लग जाता है की cout कहाँ स्थित है (क्यूंकि हमने std:: को ठीक cout के पहले लिखा है, ये आसानी से बताया जा सकता है की cout और std:: के बीच कुछ सम्बन्ध
है) ।
लेकिन यदि आप standard library का बहुत ज्यादा उपयोग करने लगे, तो बार-बार standard library के किसी object के आगे “std::” type करना program को पढने/समझने में
भी मुश्किल बना देता है और ये काम थकाऊ भी है । C++ चीजों को आसान बनाने के लिए दो और तरीके प्रदान करता है । ये दोनों
तरीके भी compiler को यही बताने के
काम आते हैं की कोई object standard library का हिस्सा है या नहीं ।
using
declaration
चीजों को आसान बनाने का एक तरीका using
declaration statement है । यहाँ हमारा Hello
world program 5वीं line पर एक using declaration के साथ फिर से लिखा जा रहा है:
|
1
2
3
4
5
6
7
8
|
#include <iostream>
int main()
{
using std::cout; // ये using declaration compiler को बता रहा है की cout को हर जगह std::cout में बदल जाना है
cout << "Hello
world!"; // इसलिए यहाँ std::
prefix की कोई ज़रूरत नहीं!
return 0;
}
|
यहाँ using declaration “using std::cout;” compiler को ये बता रहा है की हम std namespace से object cout का इस्तेमाल करने
वाले हैं । इसलिए अब जब भी compiler को “cout” मिलता है, ये समझ लेता है की हमारा मतलब std::cout है । इसी के चलते line 6 में हम “std::cout” के बजाय केवल “cout” लिख सकते हैं । हमे कोई compiler error नहीं मिलेगा ।
यहाँ इस छोटे से example में using declaration का फायदा नहीं
दिखेगा, लेकिन यदि आप किसी function में cout (या cin या endl) का बहुत ज्यादा
इस्तेमाल करने लगोगे, तो ये आपके codes को पढने में काफी आसान बना सकता है ।
यद्दपि ये “std::” prefix के जितना साफ़ तरीके से चीजों को नहीं समझाता, इसे साधारणतः उपयोग के लिए सही और सुरक्षित माना जाता है ।
using
directive
चीजों को और ज्यादा आसान बनाने के लिए using
directive statements का प्रयोग किया
जाता है । 5वें line पे एक using directive के साथ नीचे हमारा Hello world program फिर से लिखा गया है:
|
1
2
3
4
5
6
7
8
|
#include <iostream>
int main()
{
using namespace std; // ये using directive compiler को बताता है की std namespace के हर एक चीज़ का इस्तेमाल किया जायेगा!
cout << "Hello
world!"; // इसलिए यहाँ std::
prefix की ज़रूरत नही है!
return 0;
}
|
Using
directive “using namespace std;” compiler को बतलाता है की हम std namespace में रहने वाले हर चीज़ का इस्तेमाल करने वाले है, इसलिए जब compiler को कोई ऐसा नाम मिल जाता है जिसे compiler नहीं पहचान पाता, तो इस नाम के बारे में जानने के लिए compiler
std namespace को check करेगा । इसलिए compiler को जब program में “cout” दिख जाता है (जिसे
ये नहीं पहचानता), ये std
namespace में जाकर cout को वहाँ तलाश करेगा ।
using
directive का उपयोग करना एक अच्छा solution है या नहीं, ये अभी भी programmers
के बीच बहस का एक मुद्दा है । क्यूंकि
using directives किसी namespace
में स्थित सारे नामों को खींच लाते
हैं, किसी program में आपके objects (जैसे की variables, functions, classes आदि) को दिए गये नाम इन नामों (namespace
के objects से मिलते नाम) से टकरा सकते हैं । इस तरह की समस्या को एक naming
collision कहा जाता है । लेकिन इन दिक्कतों के
आने की संभावना बहुत कम होती है ।
Functions
के अन्दर या बाहर Using
declarations और directives
यदि एक using declaration या directive को function के अन्दर रखा गया है, तो namespace में स्थित नामों को
केवल उसी function के अन्दर directly
access किया जा सकता है (बिना std::
prefix के) । ये naming
collisions होने की संभावना को उसी function तक सीमित रखता है । लेकिन यदि किसी using
declaration या directive
का इस्तेमाल function के बाहर किया जा रहा है, तो namespace में स्थित नाम file में कहीं से भी directly access किये जा सकते हैं! इस प्रकार naming collisions होने की संभावना काफी हद तक बढ़ जाती है ।
Naming
collision का एक example
चलिए एक उदाहरण पर नज़र डालते हैं जहाँ एक using
directive naming collision का कारण बनती है:
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
#include <iostream>
int cout() // ये हमारे द्वारा define किया गया "cout" function है, ध्यान दें की ये std
namespace का हिस्सा नहीं है
{
return 5;
}
int main()
{
using namespace std;
// using directive std::cout को "cout"
लिखने की अनुमति देता है
cout <<
"Hello, world!"; // compiler के लिए परेशानी! वो नही समझ पायेगा की हमें कौन सा cout चाहिए
return 0;
}
|
ऊपर दिए गये example में, compiler ये समझ नहीं पायेगा
की cout से हमारा मतलब क्या
है, std::cout या वो cout
function जो हमने define किया है । इस परिस्थिति में, compiler एक “ambiguous symbol” error के साथ compile करने में असफल हो जायेगा । भले ही ये उदाहरण काफी छोटा है, यदि हम std::cout का स्पष्ट रूप में इस्तेमाल कुछ इस तरह से करते:
|
1
|
std::cout <<
"Hello, world!";
|
या using directive की जगह using
declaration का इस्तेमाल करते:
|
1
2
|
using std::cout;
cout <<
"Hello, world!";
|
तो हमारे program को compile करने में कोई
दिक्कत नहीं होती ।
बहुत से लोग “using directives” का इस्तेमाल करना इसी कारण से पसंद नही करते । कुछ लोगों के अनुसार
ये सही है जब तक इसे केवल और केवल किसी function के अन्दर रखा जाये
(जो naming collision की संभावना को उस function तक में ही सीमित रखता है) ।
using
statements पर एक नोट
इस page से आगे के examples में, हमलोग ज्यादातर सबसे स्पष्ट रूप से ही
standard library के objects का इस्तेमाल करेंगे (std:: prefix लगाकर), लेकिन फिर भी कुछ
जगहों पर जहां code को अच्छी तरह पढ़
पाना ज्यादा ज़रूरी है, हम functions
के अन्दर “using
directives” का प्रयोग करेंगे । ये पूरी तरह से आप
पर निर्भर है की आप programming करते वक़्त “using statements” का इस्तेमाल करना चाहोगे या नहीं ।
जो भी हो लेकिन “using statements” का इस्तेमाल functions के बाहर करने से बचना चाहिए ।
Rule:
Function body के बाहर using
statements का इस्तेमाल ना
करें
No comments:
Post a Comment