Learn X in Y minutes

//////////////////
// सी . से तुलना
//////////////////

// C++ _लगभग_C का सुपरसेट है और इसके लिए अपना मूल सिंटैक्स साझा करता है
// परिवर्तनीय घोषणाएं, आदिम प्रकार, और कार्य।

// सी की तरह ही, आपके प्रोग्राम का एंट्री पॉइंट एक फंक्शन है, जिसे कहा जाता है
// मुख्य एक पूर्णांक वापसी प्रकार के साथ।
// यह मान प्रोग्राम की निकास स्थिति के रूप में कार्य करता है।
// अधिक जानकारी के लिए https://en.wikipedia.org/wiki/Exit_status देखें।
int main(int argc, char** argv)
{
    // कमांड लाइन तर्क उसी तरह argc और argv द्वारा पारित किए जाते हैं
    // वे सी में हैं।
    // argc तर्कों की संख्या को इंगित करता है,
    // और argv सी-स्टाइल स्ट्रिंग्स (चार *) की एक सरणी है
    // तर्कों का प्रतिनिधित्व करते हैं।
    // पहला तर्क वह नाम है जिसके द्वारा प्रोग्राम को बुलाया गया था।
    // यदि आप तर्कों की परवाह नहीं करते हैं तो argc और argv को छोड़ा जा सकता है,
    // int main का फंक्शन सिग्नेचर देना ()

    // 0 की निकास स्थिति सफलता को इंगित करती है।
    return 0;
}

// हालाँकि, C++ निम्नलिखित में से कुछ तरीकों से भिन्न होता है:

// सी ++ में, वर्ण अक्षर वर्ण हैं
sizeof('c') == sizeof(char) == 1

// सी में, चरित्र अक्षर ints . हैं
sizeof('c') == sizeof(int)


// सी ++ में सख्त प्रोटोटाइप है
void func(); // फ़ंक्शन जो कोई तर्क स्वीकार नहीं करता है

// सी में
void func(); // फ़ंक्शन जो किसी भी संख्या में तर्कों को स्वीकार कर सकता है

// C++ में NULL के बजाय nullptr का प्रयोग करें
int* ip = nullptr;

// सी मानक हेडर सी ++ में उपलब्ध हैं।
// सी हेडर .h में समाप्त होते हैं, जबकि
// सी ++ हेडर "सी" के साथ उपसर्ग कर रहे हैं और कोई ".एच" प्रत्यय नहीं है।

// सी ++ मानक संस्करण:
#include <cstdio>

// सी मानक संस्करण:
#include <stdio.h>

int main()
{
    printf("Hello, world!\n");
    return 0;
}

///////////////////////
// फंक्शन ओवरलोडिंग
///////////////////////

// सी ++ फ़ंक्शन ओवरलोडिंग का समर्थन करता है
// बशर्ते प्रत्येक फ़ंक्शन अलग-अलग पैरामीटर लेता है।

void print(char const* myString)
{
    printf("String %s\n", myString);
}

void print(int myInt)
{
    printf("My int is %d", myInt);
}

int main()
{
    print("Hello"); // Resolves to void print(const char*)
    print(15); // Resolves to void print(int)
}

/////////////////////////////
// डिफ़ॉल्ट फ़ंक्शन तर्क
/////////////////////////////

// आप किसी फ़ंक्शन के लिए डिफ़ॉल्ट तर्क प्रदान कर सकते हैं
// अगर वे कॉलर द्वारा प्रदान नहीं किए जाते हैं।

void doSomethingWithInts(int a = 1, int b = 4)
{
    // यहां इनट्स के साथ कुछ करें
}

int main()
{
    doSomethingWithInts();      // a = 1,  b = 4
    doSomethingWithInts(20);    // a = 20, b = 4
    doSomethingWithInts(20, 5); // a = 20, b = 5
}

// डिफ़ॉल्ट तर्क तर्क सूची के अंत में होना चाहिए।

void invalidDeclaration(int a = 1, int b) // Error!
{
}


/////////////
// नेमस्पेस
/////////////

// नेमस्पेस वैरिएबल, फंक्शन के लिए अलग-अलग स्कोप प्रदान करते हैं,
// और अन्य घोषणाएं।
// नेमस्पेस को नेस्ट किया जा सकता है।

namespace First {
    namespace Nested {
        void foo()
        {
            printf("This is First::Nested::foo\n");
        }
    } // अंत नामस्थान नेस्टेड
} // अंतिम नाम स्थान पहले

namespace Second {
    void foo()
    {
        printf("This is Second::foo\n");
    }
}

void foo()
{
    printf("This is global foo\n");
}

int main()
{
    // नेमस्पेस सेकेंड से वर्तमान दायरे में सभी प्रतीकों को शामिल करता है। ध्यान दें
    // वह बस foo() अब काम नहीं करता है, क्योंकि यह अब अस्पष्ट है कि क्या
    // हम फू को नेमस्पेस सेकेंड या टॉप लेवल में कॉल कर रहे हैं।
    using namespace Second;

    Second::foo(); // प्रिंट "यह दूसरा है :: फू"
    First::Nested::foo(); // प्रिंट "यह पहला है :: नेस्टेड :: फू"
    ::foo(); // प्रिंट करता है "यह वैश्विक फू है"
}

///////////////
// इनपुट आउटपुट
///////////////

// सी ++ इनपुट और आउटपुट स्ट्रीम का उपयोग करता है
// cin, cout, और cerr stdin, stdout और stderr का प्रतिनिधित्व करते हैं।
// << इंसर्शन ऑपरेटर है और >> एक्सट्रैक्शन ऑपरेटर है।

#include <iostream> // I/O स्ट्रीम के लिए शामिल करें

using namespace std; // स्ट्रीम एसटीडी नेमस्पेस (मानक पुस्तकालय) में हैं

int main()
{
   int myInt;

   // स्टडआउट (या टर्मिनल / स्क्रीन) पर प्रिंट करता है
   cout << "Enter your favorite number:\n";
   // इनपुट लेता है
   cin >> myInt;

   // cout को भी स्वरूपित किया जा सकता है
   cout << "Your favorite number is " << myInt << '\n';
   // प्रिंट करता है "आपका पसंदीदा नंबर <myInt>" है

   cerr << "Used for error messages";
}

//////////
// स्ट्रिंग्स
//////////

// सी ++ में स्ट्रिंग्स ऑब्जेक्ट हैं और इसमें कई सदस्य कार्य हैं
#include <string>

using namespace std; // स्ट्रिंग्स नेमस्पेस एसटीडी (मानक पुस्तकालय) में भी हैं

string myString = "Hello";
string myOtherString = " World";

// + का उपयोग संयोजन के लिए किया जाता है।
cout << myString + myOtherString; // "Hello World"

cout << myString + " You"; // "Hello You"

// सी ++ स्ट्रिंग्स म्यूटेबल हैं।
myString.append(" Dog");
cout << myString; // "Hello Dog"


/////////////
// संदर्भ
/////////////

// सी में वाले जैसे पॉइंटर्स के अलावा,
// सी ++ में _references_ हैं।
// ये पॉइंटर प्रकार हैं जिन्हें एक बार सेट करने के बाद पुन: असाइन नहीं किया जा सकता है
// और शून्य नहीं हो सकता।
// उनके पास वैरिएबल के समान सिंटैक्स भी है:
// नहीं * dereferencing के लिए आवश्यक है और
// और (का पता) असाइनमेंट के लिए उपयोग नहीं किया जाता है।

using namespace std;

string foo = "I am foo";
string bar = "I am bar";


string& fooRef = foo; // यह foo का संदर्भ बनाता है।
fooRef += ". Hi!"; // संदर्भ के माध्यम से फू को संशोधित करें
cout << fooRef; // प्रिंट "I am foo. Hi!"

// "fooRef" को पुन: असाइन नहीं करता है। यह "फू = बार" जैसा ही है, और
// फू == "मैं बार हूँ"
// इस लाइन के बाद।
cout << &fooRef << endl;  // फू का पता प्रिंट करता है
fooRef = bar;
cout << &fooRef << endl; // अभी भी फू का पता प्रिंट करता है
cout << fooRef;  // प्रिंट "I am bar"

// fooRef का पता वही रहता है, यानी यह अभी भी foo की बात कर रहा है।


const string& barRef = bar; // बार के लिए एक कॉन्स्टेबल संदर्भ बनाएं।
// सी की तरह, कॉन्स्ट वैल्यू (और पॉइंटर्स और रेफरेंस) को संशोधित नहीं किया जा सकता है।
barRef += ". Hi!"; // त्रुटि, कॉन्स्ट संदर्भों को संशोधित नहीं किया जा सकता है।

// साइडट्रैक: इससे पहले कि हम संदर्भों के बारे में अधिक बात करें, हमें एक अवधारणा पेश करनी चाहिए
// एक अस्थायी वस्तु कहा जाता है। मान लीजिए हमारे पास निम्नलिखित कोड है:
string tempObjectFun() { ... }
string retVal = tempObjectFun();

// दूसरी पंक्ति में वास्तव में क्या होता है:
// - एक स्ट्रिंग ऑब्जेक्ट tempObjectFun से लौटाया जाता है
// - तर्क के रूप में लौटाई गई वस्तु के साथ एक नई स्ट्रिंग का निर्माण किया जाता है
// कंस्ट्रक्टर
// - लौटाई गई वस्तु नष्ट हो जाती है
// लौटाई गई वस्तु को अस्थायी वस्तु कहा जाता है। अस्थायी वस्तुएं हैं
// जब भी कोई फ़ंक्शन किसी ऑब्जेक्ट को लौटाता है, तब बनाया जाता है, और वे नष्ट हो जाते हैं
// संलग्न अभिव्यक्ति के मूल्यांकन का अंत (ठीक है, यह वही है
// मानक कहता है, लेकिन संकलक को इस व्यवहार को बदलने की अनुमति है। ऊपर देखो
// "वापसी मूल्य अनुकूलन" यदि आप इस तरह के विवरण में हैं)। तो इसमें
// कोड:
foo(bar(tempObjectFun()))

// यह मानते हुए कि फू और बार मौजूद हैं, tempObjectFun से लौटाई गई वस्तु है
// बार को पास किया गया, और फू को कॉल करने से पहले इसे नष्ट कर दिया गया।

// अब वापस संदर्भों पर। "संलग्नक के अंत में" का अपवाद
// अभिव्यक्ति" नियम यह है कि यदि एक अस्थायी वस्तु एक कॉन्स्ट संदर्भ के लिए बाध्य है, तो
// किस मामले में इसका जीवन वर्तमान दायरे तक बढ़ जाता है:

void constReferenceTempObjectFun() {
    // constRef अस्थायी वस्तु प्राप्त करता है, और यह इस के अंत तक मान्य है
    // समारोह।
    const string& constRef = tempObjectFun();
    ...
}

// सी ++ 11 में पेश किया गया एक अन्य प्रकार का संदर्भ विशेष रूप से अस्थायी के लिए है
// ऑब्जेक्ट्स। आपके पास इसके प्रकार का एक चर नहीं हो सकता है, लेकिन इसमें पूर्वता होती है
// अधिभार संकल्प:

void someFun(string& s) { ... }  // नियमित संदर्भ
void someFun(string&& s) { ... }  // अस्थायी वस्तु का संदर्भ

string foo;
someFun(foo);  // नियमित संदर्भ के साथ संस्करण को कॉल करें
someFun(tempObjectFun());  // अस्थायी संदर्भ के साथ संस्करण को कॉल करें

// उदाहरण के लिए, आप कंस्ट्रक्टर के इन दो संस्करणों को देखेंगे
// std::basic_string:
basic_string(const basic_string& other);
basic_string(basic_string&& other);

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

/////////////////////
// Enums
/////////////////////

// Enums सबसे अधिक उपयोग किए जाने वाले स्थिरांक को मान निर्दिष्ट करने का एक तरीका है
// आसान विज़ुअलाइज़ेशन और कोड को पढ़ना
enum ECarTypes
{
  Sedan,
  Hatchback,
  SUV,
  Wagon
};

ECarTypes GetPreferredCarType()
{
    return ECarTypes::Hatchback;
}

// सी ++ 11 के रूप में एनम को एक प्रकार असाइन करने का एक आसान तरीका है जो हो सकता है
// डेटा के क्रमांकन में उपयोगी और एनम को आगे-पीछे परिवर्तित करना
// वांछित प्रकार और उनके संबंधित स्थिरांक
enum ECarTypes : uint8_t
{
    Sedan, // 0
    Hatchback, // 1
    SUV = 254, // 254
    Hybrid // 255
};

void WriteByteToFile(uint8_t InputValue)
{
    // किसी फ़ाइल में इनपुटवैल्यू को क्रमबद्ध करें
}

void WritePreferredCarTypeToFile(ECarTypes InputCarType)
{
    // एनम को इसके घोषित एनम प्रकार के कारण uint8_t में परिवर्तित कर दिया गया है
    WriteByteToFile(InputCarType);
}

// दूसरी ओर, हो सकता है कि आप नहीं चाहते कि गलती से एनम को एक पूर्णांक में डाला जाए
// टाइप करें या अन्य एनम के लिए ताकि इसके बजाय एक एनम क्लास बनाना संभव हो जो
// परोक्ष रूप से परिवर्तित नहीं किया जाएगा
enum class ECarTypes : uint8_t
{
    Sedan, // 0
    Hatchback, // 1
    SUV = 254, // 254
    Hybrid // 255
};

void WriteByteToFile(uint8_t InputValue)
{
    // किसी फ़ाइल में इनपुटवैल्यू को क्रमबद्ध करें
}

void WritePreferredCarTypeToFile(ECarTypes InputCarType)
{
    // संकलित नहीं होगा, भले ही ECarTypes एक uint8_t एनम के कारण है
    // "एनम क्लास" के रूप में घोषित किया जा रहा है!
    WriteByteToFile(InputCarType);
}

//////////////////////////////////////////
// कक्षाएं और वस्तु-उन्मुख प्रोग्रामिंग
//////////////////////////////////////////

// कक्षाओं का पहला उदाहरण
#include <iostream>

// एक वर्ग घोषित करें।
// कक्षाएं आमतौर पर हेडर (.h या .hpp) फाइलों में घोषित की जाती हैं।
class Dog {
        // सदस्य चर और कार्य डिफ़ॉल्ट रूप से निजी हैं।
    std::string name;
    int weight;

// इसका अनुसरण करने वाले सभी सदस्य सार्वजनिक हैं
// जब तक "निजी:" या "संरक्षित:" नहीं मिलता है।
public:

    // Default constructor
    Dog();

    // सदस्य फ़ंक्शन घोषणाएं (कार्यान्वयन का पालन करें)
    // ध्यान दें कि हम यहां रखने के बजाय std::string का उपयोग करते हैं
    // नेमस्पेस एसटीडी का उपयोग करना;
    // ऊपर।
    // हेडर में कभी भी "नेमस्पेस का उपयोग करके" स्टेटमेंट न डालें।
    void setName(const std::string& dogsName);

    void setWeight(int dogsWeight);

    // ऐसे कार्य जो वस्तु की स्थिति को संशोधित नहीं करते हैं
    // को कॉन्स्ट के रूप में चिह्नित किया जाना चाहिए।
    // यह आपको ऑब्जेक्ट के संदर्भ में दिए जाने पर उन्हें कॉल करने की अनुमति देता है।
    // यह भी ध्यान दें कि कार्यों को स्पष्ट रूप से _virtual_ के रूप में घोषित किया जाना चाहिए
    // व्युत्पन्न कक्षाओं में ओवरराइड करने के लिए।
    // कार्य प्रदर्शन कारणों से डिफ़ॉल्ट रूप से आभासी नहीं हैं।
    virtual void print() const;

    // फंक्शन को क्लास बॉडी के अंदर भी परिभाषित किया जा सकता है।
    // इस तरह परिभाषित कार्य स्वचालित रूप से रेखांकित होते हैं।
    void bark() const { std::cout << name << " barks!\n"; }

    // कंस्ट्रक्टर्स के साथ, C++ डिस्ट्रक्टर्स प्रदान करता है।
    // इन्हें तब कहा जाता है जब कोई वस्तु हटा दी जाती है या दायरे से बाहर हो जाती है।
    // यह RAII जैसे शक्तिशाली प्रतिमानों को सक्षम बनाता है
    // (निचे देखो)
    // विध्वंसक आभासी होना चाहिए यदि एक वर्ग से प्राप्त किया जाना है;
    // यदि यह आभासी नहीं है, तो व्युत्पन्न वर्ग 'विनाशक होगा'
    // यदि ऑब्जेक्ट बेस-क्लास संदर्भ के माध्यम से नष्ट हो जाता है तो कॉल नहीं किया जाएगा
    // या सूचक।
    virtual ~Dog();

}; // अर्धविराम को वर्ग परिभाषा का पालन करना चाहिए।

// क्लास सदस्य फ़ंक्शन आमतौर पर .cpp फ़ाइलों में कार्यान्वित किए जाते हैं।
Dog::Dog()
{
    std::cout << "A dog has been constructed\n";
}

// वस्तुओं (जैसे तार) को संदर्भ द्वारा पारित किया जाना चाहिए
// यदि आप उन्हें संशोधित कर रहे हैं या यदि आप नहीं हैं तो संदर्भ संदर्भ।
void Dog::setName(const std::string& dogsName)
{
    name = dogsName;
}

void Dog::setWeight(int dogsWeight)
{
    weight = dogsWeight;
}

// ध्यान दें कि "आभासी" केवल घोषणा में आवश्यक है, परिभाषा नहीं।
void Dog::print() const
{
    std::cout << "Dog is " << name << " and weighs " << weight << "kg\n";
}

Dog::~Dog()
{
    std::cout << "Goodbye " << name << '\n';
}

int main() {
    Dog myDog; // prints "A dog has been constructed"
    myDog.setName("Barkley");
    myDog.setWeight(10);
    myDog.print(); // prints "Dog is Barkley and weighs 10 kg"
    return 0;
} // prints "Goodbye Barkley"

// विरासत:

// इस वर्ग को सब कुछ विरासत में मिला है और डॉग क्लास से संरक्षित है
// साथ ही निजी लेकिन सीधे निजी सदस्यों / विधियों तक नहीं पहुंच सकता है
// ऐसा करने के लिए सार्वजनिक या संरक्षित विधि के बिना
class OwnedDog : public Dog {

public:
    void setOwner(const std::string& dogsOwner);

    // सभी स्वामित्व वाले कुत्तों के लिए प्रिंट फ़ंक्शन के व्यवहार को ओवरराइड करें। ले देख
    // https://en.wikipedia.org/wiki/Polymorphism_(computer_science)#Subtyping
    // अधिक सामान्य परिचय के लिए यदि आप अपरिचित हैं
    // उपप्रकार बहुरूपता।
    // ओवरराइड कीवर्ड वैकल्पिक है लेकिन सुनिश्चित करता है कि आप वास्तव में हैं
    // बेस क्लास में विधि को ओवरराइड करना।

private:
    std::string owner;
};

// इस बीच, संबंधित .cpp फ़ाइल में:

void OwnedDog::setOwner(const std::string& dogsOwner)
{
    owner = dogsOwner;
}

void OwnedDog::print() const
{
    Dog::print(); // बेस डॉग क्लास में प्रिंट फ़ंक्शन को कॉल करें class
    std::cout << "Dog is owned by " << owner << '\n';
    // प्रिंट करता है "कुत्ता <नाम> है और वजन <वजन>" है
    // "कुत्ता <मालिक> के स्वामित्व में है"
}

//////////////////////////////////////////
// आरंभीकरण और ऑपरेटर ओवरलोडिंग
//////////////////////////////////////////

// सी ++ में आप ऑपरेटरों के व्यवहार को ओवरलोड कर सकते हैं जैसे +, -, *, /, आदि।
// यह एक फ़ंक्शन को परिभाषित करके किया जाता है जिसे कहा जाता है
// जब भी ऑपरेटर का उपयोग किया जाता है।

#include <iostream>
using namespace std;

class Point {
public:
        // सदस्य चर को इस तरह से डिफ़ॉल्ट मान दिया जा सकता है।
    double x = 0;
    double y = 0;

        // एक डिफ़ॉल्ट कंस्ट्रक्टर को परिभाषित करें जो कुछ भी नहीं करता है
    // लेकिन बिंदु को डिफ़ॉल्ट मान (0, 0) पर प्रारंभ करें
    Point() { };

    // The following syntax is known as an initialization list
    // and is the proper way to initialize class member values
    Point (double a, double b) :
        x(a),
        y(b)
    { /* मानों को इनिशियलाइज़ करने के अलावा कुछ न करें */ }

    // + ऑपरेटर को ओवरलोड करें।
    Point operator+(const Point& rhs) const;

    // + = ऑपरेटर को अधिभारित करें
    Point& operator+=(const Point& rhs);

    // - और - = ऑपरेटरों को जोड़ना भी समझ में आता है,
    // लेकिन हम उन्हें संक्षिप्तता के लिए छोड़ देंगे।
};

Point Point::operator+(const Point& rhs) const
{
    // एक नया बिंदु बनाएं जो इस एक और rhs का योग हो।.
    return Point(x + rhs.x, y + rhs.y);
}

// के सबसे बाएं चर के संदर्भ को वापस करने के लिए यह अच्छा अभ्यास है
// सौंपा गया कार्य। `(a += b) == c` इस तरह से काम करेगा।
Point& Point::operator+=(const Point& rhs)
{
    x += rhs.x;
    y += rhs.y;

    // `this` उस वस्तु का सूचक है, जिस पर एक विधि कहलाती है।
    return *this;
}

int main () {
    Point up (0,1);
    Point right (1,0);
    // यह प्वाइंट + ऑपरेटर को कॉल करता है
    // पॉइंट अप + (फ़ंक्शन) को इसके पैरामीटर के रूप में दाईं ओर कॉल करता है
    Point result = up + right;
    // Prints "Result is upright (1,1)"
    cout << "Result is upright (" << result.x << ',' << result.y << ")\n";
    return 0;
}

/////////////////////
// टेम्पलेट्स
/////////////////////

// C++ में टेम्प्लेट ज्यादातर सामान्य प्रोग्रामिंग के लिए उपयोग किए जाते हैं, हालांकि वे हैं
// अन्य भाषाओं में सामान्य निर्माणों की तुलना में बहुत अधिक शक्तिशाली। वे भी
// स्पष्ट और आंशिक विशेषज्ञता और कार्यात्मक-शैली प्रकार का समर्थन करें
// कक्षाएं; वास्तव में, वे एक ट्यूरिंग-पूर्ण कार्यात्मक भाषा एम्बेडेड हैं
// सी ++ में!

// हम उस तरह की सामान्य प्रोग्रामिंग से शुरू करते हैं जिससे आप परिचित हो सकते हैं। सेवा
// एक वर्ग या फ़ंक्शन को परिभाषित करें जो एक प्रकार का पैरामीटर लेता है:
template<class T>
class Box {
public:
    // इस वर्ग में, टी का उपयोग किसी अन्य प्रकार के रूप में किया जा सकता है।
    void insert(const T&) { ... }
};

// संकलन के दौरान, कंपाइलर वास्तव में प्रत्येक टेम्पलेट की प्रतियां बनाता है
// प्रतिस्थापित मापदंडों के साथ, इसलिए वर्ग की पूरी परिभाषा होनी चाहिए
// प्रत्येक आह्वान पर उपस्थित। यही कारण है कि आप टेम्पलेट वर्ग परिभाषित देखेंगे
// पूरी तरह से हेडर फाइलों में।

// स्टैक पर टेम्प्लेट क्लास को इंस्टेंट करने के लिए:
Box<int> intBox;

// और आप इसका उपयोग कर सकते हैं जैसा कि आप उम्मीद करेंगे:
intBox.insert(123);

// आप निश्चित रूप से, नेस्ट टेम्प्लेट कर सकते हैं:
Box<Box<int> > boxOfBox;
boxOfBox.insert(intBox);

// C++11 तक, आपको दो '>' के बीच एक जगह रखनी थी, अन्यथा '>>'
// सही शिफ्ट ऑपरेटर के रूप में पार्स किया जाएगा।

// आप कभी-कभी देखेंगे
// टेम्पलेट<टाइपनाम टी>
// बजाय। 'वर्ग' कीवर्ड और 'टाइपनाम' कीवर्ड _अधिकतर_ हैं
// इस मामले में विनिमेय। पूरी व्याख्या के लिए देखें
// https://en.wikipedia.org/wiki/Typename
// (हाँ, उस कीवर्ड का अपना विकिपीडिया पेज है)।

// इसी तरह, एक टेम्पलेट फ़ंक्शन:
template<class T>
void barkThreeTimes(const T& input)
{
    input.bark();
    input.bark();
    input.bark();
}

// ध्यान दें कि यहां प्रकार के मापदंडों के बारे में कुछ भी निर्दिष्ट नहीं है। संकलक
// उत्पन्न करेगा और फिर टेम्पलेट के प्रत्येक आमंत्रण को टाइप-चेक करेगा, इसलिए
// उपरोक्त फ़ंक्शन किसी भी प्रकार 'T' के साथ काम करता है जिसमें एक कॉन्स 'bark' विधि होती है!

Dog fluffy;
fluffy.setName("Fluffy")
barkThreeTimes(fluffy); // Prints "Fluffy barks" three times.

// टेम्प्लेट मापदंडों का वर्ग होना जरूरी नहीं है:
template<int Y>
void printMessage() {
  cout << "Learn C++ in " << Y << " minutes!" << endl;
}

// और आप स्पष्ट रूप से अधिक कुशल कोड के लिए टेम्पलेट्स को विशेषज्ञ बना सकते हैं। का
// बेशक, विशेषज्ञता के अधिकांश वास्तविक दुनिया के उपयोग इस तरह के रूप में तुच्छ नहीं हैं।
// ध्यान दें कि आपको अभी भी फ़ंक्शन (या वर्ग) को टेम्पलेट के रूप में घोषित करने की आवश्यकता है
// भले ही आपने सभी मापदंडों को स्पष्ट रूप से निर्दिष्ट किया हो।
template<>
void printMessage<10>() {
  cout << "Learn C++ faster in only 10 minutes!" << endl;
}

printMessage<20>();  // Prints "Learn C++ in 20 minutes!"
printMessage<10>();  // Prints "Learn C++ faster in only 10 minutes!"


/////////////////////
// संचालन अपवाद
/////////////////////

// मानक पुस्तकालय कुछ अपवाद प्रकार प्रदान करता है
// (देखें https://en.cppreference.com/w/cpp/error/exception)
// लेकिन किसी भी प्रकार को अपवाद के रूप में फेंका जा सकता है
#include <exception>
#include <stdexcept>

// _try_ ब्लॉक के अंदर फेंके गए सभी अपवादों को बाद में पकड़ा जा सकता है
// _कैच_ हैंडलर।
try {
    // _new_ का उपयोग करके ढेर पर अपवाद आवंटित न करें।
    throw std::runtime_error("A problem occurred");
}

// कॉन्स्ट संदर्भ द्वारा अपवादों को पकड़ें यदि वे ऑब्जेक्ट हैं
catch (const std::exception& ex)
{
    std::cout << ex.what();
}

// पिछले _catch_ ब्लॉक द्वारा नहीं पकड़े गए किसी भी अपवाद को पकड़ता है
catch (...)
{
    std::cout << "Unknown exception caught";
    throw; // Re-throws the exception
}

///////
// आरएआईआई
///////

// RAII का अर्थ  "संसाधन अधिग्रहण आरंभीकरण है"।
// इसे अक्सर C++ में सबसे शक्तिशाली प्रतिमान माना जाता है
// और सरल अवधारणा है कि एक वस्तु के लिए एक निर्माता
// उस वस्तु के संसाधनों को प्राप्त करता है और विनाशक उन्हें जारी करता है।

// यह समझने के लिए कि यह कैसे उपयोगी है,
// एक फ़ंक्शन पर विचार करें जो C फ़ाइल हैंडल का उपयोग करता है:
void doSomethingWithAFile(const char* filename)
{
    // शुरू करने के लिए, मान लें कि कुछ भी विफल नहीं हो सकता है।

    FILE* fh = fopen(filename, "r"); // Open the file in read mode.

    doSomethingWithTheFile(fh);
    doSomethingElseWithIt(fh);

    fclose(fh); // Close the file handle.
}

// दुर्भाग्य से, त्रुटि प्रबंधन से चीजें जल्दी जटिल हो जाती हैं।
// मान लीजिए कि fopen विफल हो सकता है, और वह doSomethingWithTheFile और
// doSomethingElseWithIt विफल होने पर त्रुटि कोड लौटाता है।
// (अपवाद विफलता से निपटने का पसंदीदा तरीका है,
// लेकिन कुछ प्रोग्रामर, विशेष रूप से C बैकग्राउंड वाले,
// अपवादों की उपयोगिता पर असहमत)।
// अब हमें विफलता के लिए प्रत्येक कॉल की जांच करनी होगी और फ़ाइल हैंडल को बंद करना होगा
// यदि कोई समस्या हुई।
bool doSomethingWithAFile(const char* filename)
{
    FILE* fh = fopen(filename, "r"); // फ़ाइल को रीड मोड में खोलें
    if (fh == nullptr) // लौटाया गया सूचक विफलता पर शून्य है।
        return false; // Report that failure to the caller.

    // मान लें कि प्रत्येक फ़ंक्शन विफल होने पर गलत लौटाता है
    if (!doSomethingWithTheFile(fh)) {
        fclose(fh); // फ़ाइल हैंडल को बंद करें ताकि यह लीक न हो।
        return false; // त्रुटि का प्रचार करें।
    }
    if (!doSomethingElseWithIt(fh)) {
        fclose(fh); // फ़ाइल हैंडल को बंद करें ताकि यह लीक न हो।
        return false; // त्रुटि का प्रचार करें।
    }

    fclose(fh); // फ़ाइल हैंडल को बंद करें ताकि यह लीक न हो।
    return true; // सफलता का संकेत दें
}

// सी प्रोग्रामर अक्सर गोटो का उपयोग करके इसे थोड़ा साफ करते हैं:
bool doSomethingWithAFile(const char* filename)
{
    FILE* fh = fopen(filename, "r");
    if (fh == nullptr)
        return false;

    if (!doSomethingWithTheFile(fh))
        goto failure;

    if (!doSomethingElseWithIt(fh))
        goto failure;

    fclose(fh); // Close the file
    return true; // Indicate success

failure:
    fclose(fh);
    return false; // Propagate the error
}

// यदि फ़ंक्शन अपवादों का उपयोग करके त्रुटियों को इंगित करता है,
// चीजें थोड़ी साफ हैं, लेकिन फिर भी उप-इष्टतम हैं।
void doSomethingWithAFile(const char* filename)
{
    FILE* fh = fopen(filename, "r"); // Open the file in shared_ptrread mode
    if (fh == nullptr)
        throw std::runtime_error("Could not open the file.");

    try {
        doSomethingWithTheFile(fh);
        doSomethingElseWithIt(fh);
    }
    catch (...) {
        fclose(fh); // Be sure to close the file if an error occurs.
        throw; // Then re-throw the exception.
    }

    fclose(fh); // Close the file
    // Everything succeeded
}

// इसकी तुलना C++ के फाइल स्ट्रीम क्लास (fstream) के उपयोग से करें
// fstream फ़ाइल को बंद करने के लिए अपने विनाशक का उपयोग करता है।
// ऊपर से याद करें कि विध्वंसक स्वचालित रूप से कहलाते हैं
// जब भी कोई वस्तु दायरे से बाहर हो जाती है।
void doSomethingWithAFile(const std::string& filename)
{
    // ifstream इनपुट फ़ाइल स्ट्रीम के लिए छोटा है
    std::ifstream fh(filename); // Open the file

    // Do things with the file
    doSomethingWithTheFile(fh);
    doSomethingElseWithIt(fh);

} //फ़ाइल स्वचालित रूप से यहाँ विध्वंसक द्वारा बंद कर दी गई है

// इसके _massive_ फायदे हैं:
// 1. चाहे कुछ भी हो जाए,
// संसाधन (इस मामले में फ़ाइल हैंडल) को साफ किया जाएगा।
// एक बार जब आप विध्वंसक को सही ढंग से लिख लेते हैं,
// हैंडल को बंद करना और रिसोर्स को लीक करना भूल जाना _असंभव_ है।
// 2. ध्यान दें कि कोड ज्यादा साफ है।
// विनाशक पर्दे के पीछे फ़ाइल को बंद करने का प्रबंधन करता है
// आपको इसके बारे में चिंता किए बिना।
// 3. कोड अपवाद सुरक्षित है।
// फंक्शन और क्लीनअप में कहीं भी एक अपवाद फेंका जा सकता है
// अभी भी होगा।

// सभी मुहावरेदार सी ++ कोड सभी संसाधनों के लिए बड़े पैमाने पर आरएआईआई का उपयोग करता है।
// अतिरिक्त उदाहरणों में शामिल हैं
// - unique_ptr और shared_ptr . का उपयोग करके मेमोरी
// - कंटेनर - मानक पुस्तकालय लिंक्ड सूची,
// वेक्टर (यानी स्व-आकार देने वाला सरणी), हैश मैप, और इसी तरह
// जब वे दायरे से बाहर हो जाते हैं तो सभी स्वचालित रूप से अपनी सामग्री को नष्ट कर देते हैं।
// - लॉक_गार्ड और यूनिक_लॉक का उपयोग करने वाले म्यूटेक्स


/////////////////////
// स्मार्ट पॉइंटर
/////////////////////

// आम तौर पर एक स्मार्ट पॉइंटर एक ऐसा वर्ग होता है जो "रॉ पॉइंटर" ("नया" का उपयोग) को लपेटता है
// क्रमशः सी में मॉलोक / कॉलोक)। लक्ष्य सक्षम होना है
// स्पष्ट रूप से हटाने की आवश्यकता के बिना इंगित की जा रही वस्तु के जीवनकाल का प्रबंधन करें
// वस्तु। यह शब्द केवल पॉइंटर्स के एक सेट का वर्णन करता है जिसमें
// अमूर्त का उल्लेख किया।
// स्मार्ट पॉइंटर्स को रोकने के लिए कच्चे पॉइंटर्स पर प्राथमिकता दी जानी चाहिए
// जोखिम भरा मेमोरी लीक, जो तब होता है जब आप किसी ऑब्जेक्ट को हटाना भूल जाते हैं।

// कच्चे सूचक का उपयोग:
Dog* ptr = new Dog();
ptr->bark();
delete ptr;

// स्मार्ट पॉइंटर का उपयोग करके, आपको हटाने के बारे में चिंता करने की ज़रूरत नहीं है
// अब वस्तु का।
// एक स्मार्ट पॉइंटर एक नीति का वर्णन करता है, जिसमें संदर्भों की गणना की जाती है
// सूचक। वस्तु नष्ट हो जाती है जब अंतिम
// वस्तु का संदर्भ नष्ट हो जाता है।

// "std::shared_ptr" का उपयोग:
void foo()
{
    // It's no longer necessary to delete the Dog.
    std::shared_ptr<Dog> doggo(new Dog());
    doggo->bark();
}

// संभावित परिपत्र संदर्भों से सावधान रहें !!!
// हमेशा एक संदर्भ होगा, इसलिए इसे कभी नष्ट नहीं किया जाएगा!
std::shared_ptr<Dog> doggo_one(new Dog());
std::shared_ptr<Dog> doggo_two(new Dog());
doggo_one = doggo_two; // p1 references p2
doggo_two = doggo_one; // p2 references p1

// कई प्रकार के स्मार्ट पॉइंटर्स हैं।
// उनका उपयोग करने का तरीका हमेशा एक जैसा होता है।
// यह हमें इस प्रश्न की ओर ले जाता है: हमें प्रत्येक प्रकार के स्मार्ट पॉइंटर का उपयोग कब करना चाहिए?
// std::unique_ptr - इसका उपयोग तब करें जब आप केवल एक संदर्भ रखना चाहते हैं
// वस्तु।
// std::shared_ptr - इसका उपयोग तब करें जब आप इसके लिए कई संदर्भ रखना चाहते हैं
// एक ही वस्तु और यह सुनिश्चित करना चाहते हैं कि इसे हटा दिया गया है
// जब सभी संदर्भ चले गए हैं।
// std::weak_ptr - जब आप एक्सेस करना चाहते हैं तो इसका इस्तेमाल करें
// एक std::shared_ptr की अंतर्निहित वस्तु उस वस्तु को आवंटित किए बिना।
// कमजोर पॉइंटर्स का उपयोग सर्कुलर रेफरेंसिंग को रोकने के लिए किया जाता है।


/////////////////////
// कंटेनर
/////////////////////

// कंटेनर या मानक टेम्पलेट लाइब्रेरी कुछ पूर्वनिर्धारित टेम्पलेट हैं।
// वे इसके तत्वों के लिए भंडारण स्थान का प्रबंधन करते हैं और प्रदान करते हैं
// सदस्य उन्हें एक्सेस और हेरफेर करने के लिए कार्य करता है।

// कुछ कंटेनर इस प्रकार हैं:

// वेक्टर (गतिशील सरणी)
// हमें रन टाइम पर ऐरे या ऑब्जेक्ट्स की सूची को परिभाषित करने की अनुमति दें
#include <vector>
string val;
vector<string> my_vector; // initialize the vector
cin >> val;
my_vector.push_back(val); // will push the value of 'val' into vector ("array") my_vector
my_vector.push_back(val); // will push the value into the vector again (now having two elements)

// एक वेक्टर के माध्यम से पुनरावृति करने के लिए हमारे पास 2 विकल्प हैं:
// या तो क्लासिक लूपिंग (वेक्टर के माध्यम से इंडेक्स 0 से उसके अंतिम इंडेक्स तक पुनरावृति):
for (int i = 0; i < my_vector.size(); i++) {
    cout << my_vector[i] << endl; // वेक्टर के तत्व तक पहुँचने के लिए हम ऑपरेटर का उपयोग कर सकते हैं []
}

// या एक पुनरावर्तक का उपयोग करना:
vector<string>::iterator it; // initialize the iterator for vector
for (it = my_vector.begin(); it != my_vector.end(); ++it) {
    cout << *it  << endl;
}

// सेट
// सेट कंटेनर हैं जो एक विशिष्ट क्रम के बाद अद्वितीय तत्वों को संग्रहीत करते हैं।
// सेट अद्वितीय मूल्यों को क्रमबद्ध क्रम में संग्रहीत करने के लिए एक बहुत ही उपयोगी कंटेनर है
// बिना किसी अन्य फ़ंक्शन या कोड के।

#include<set>
set<int> ST;    // Will initialize the set of int data type
ST.insert(30);  // Will insert the value 30 in set ST
ST.insert(10);  // Will insert the value 10 in set ST
ST.insert(20);  // Will insert the value 20 in set ST
ST.insert(30);  // Will insert the value 30 in set ST
// अब सेट के तत्व इस प्रकार हैं
// 10 20 30

// किसी तत्व को मिटाने के लिए
ST.erase(20); // मान 20 . के साथ तत्व मिटा देगा
// एसटी सेट करें: 10 30
// सेट के माध्यम से पुनरावृति करने के लिए हम पुनरावृत्तियों का उपयोग करते हैं
set<int>::iterator it;
for(it=ST.begin();it!=ST.end();it++) {
    cout << *it << endl;
}
// Output:
// 10
// 30

// पूरे कंटेनर को साफ करने के लिए हम कंटेनर_नाम.क्लियर () का उपयोग करते हैं
ST.clear();
cout << ST.size();  // will print the size of set ST
// आउटपुट: 0

// नोट: डुप्लिकेट तत्वों के लिए हम मल्टीसेट का उपयोग कर सकते हैं
// नोट: हैश सेट के लिए, unordered_set का उपयोग करें। वे अधिक कुशल हैं लेकिन
// आदेश को संरक्षित न करें। unordered_set C++11 के बाद से उपलब्ध है

// नक्शा
// मैप्स एक प्रमुख मूल्य के संयोजन द्वारा गठित तत्वों को संग्रहीत करता है
// और एक विशिष्ट क्रम के बाद एक मैप किया गया मान।

#include<map>
map<char, int> mymap;  // Will initialize the map with key as char and value as int

mymap.insert(pair<char,int>('A',1));
// Will insert value 1 for key A
mymap.insert(pair<char,int>('Z',26));
// Will insert value 26 for key Z

// To iterate
map<char,int>::iterator it;
for (it=mymap.begin(); it!=mymap.end(); ++it)
    std::cout << it->first << "->" << it->second << std::cout;
// आउटपुट:
// ए-> 1
// जेड-> 26

// कुंजी के अनुरूप मान ज्ञात करने के लिए
it = mymap.find('Z');
cout << it->second;

// आउटपुट: 26

// नोट: हैश मैप के लिए, unordered_map का उपयोग करें। वे अधिक कुशल हैं लेकिन करते हैं
// आदेश को संरक्षित नहीं करें। unordered_map C++11 के बाद से उपलब्ध है।

// गैर-आदिम मूल्यों (कस्टम वर्ग) की ऑब्जेक्ट कुंजियों वाले कंटेनरों की आवश्यकता होती है
// ऑब्जेक्ट में या फ़ंक्शन पॉइंटर के रूप में फ़ंक्शन की तुलना करें। पुरातन
// डिफ़ॉल्ट तुलनित्र हैं, लेकिन आप इसे ओवरराइड कर सकते हैं।
class Foo {
public:
    int j;
    Foo(int a) : j(a) {}
};
struct compareFunction {
    bool operator()(const Foo& a, const Foo& b) const {
        return a.j < b.j;
    }
};
// इसकी अनुमति नहीं है (हालांकि यह कंपाइलर के आधार पर भिन्न हो सकता है)
// एसटीडी :: नक्शा <फू, इंट> फूमैप;
std::map<Foo, int, compareFunction> fooMap;
fooMap[Foo(1)]  = 1;
fooMap.find(Foo(1)); //true


////////////////////////////////////
// लैम्ब्डा एक्सप्रेशन (सी ++ 11 और ऊपर)
////////////////////////////////////

// लैम्ब्डा एक अनाम फ़ंक्शन को परिभाषित करने का एक सुविधाजनक तरीका है
// वस्तु उस स्थान पर ठीक है जहां इसे लागू किया गया है या पारित किया गया है
// किसी फ़ंक्शन के लिए एक तर्क।

// उदाहरण के लिए, दूसरे का उपयोग करके जोड़े के वेक्टर को सॉर्ट करने पर विचार करें
// जोड़ी का मूल्य

vector<pair<int, int> > tester;
tester.push_back(make_pair(3, 6));
tester.push_back(make_pair(1, 9));
tester.push_back(make_pair(5, 0));

// लैम्ब्डा एक्सप्रेशन को सॉर्ट फ़ंक्शन के तीसरे तर्क के रूप में पास करें
// सॉर्ट <एल्गोरिदम> हेडर से है

sort(tester.begin(), tester.end(), [](const pair<int, int>& lhs, const pair<int, int>& rhs) {
        return lhs.second < rhs.second;
    });

// लैम्ब्डा एक्सप्रेशन के सिंटैक्स पर ध्यान दें,
// [] लैम्ब्डा में चर को "कैप्चर" करने के लिए प्रयोग किया जाता है
// "कैप्चर लिस्ट" परिभाषित करती है कि लैम्ब्डा के बाहर से फंक्शन बॉडी के अंदर क्या उपलब्ध होना चाहिए और कैसे।
// यह या तो हो सकता है:
// 1. एक मान: [x]
// 2. एक संदर्भ: [&x]
// 3. संदर्भ के अनुसार वर्तमान में कोई भी चर [&]
// 4. ३ के समान, लेकिन मूल्य से [=]
// उदाहरण:

vector<int> dog_ids;
// number_of_dogs = 3;
for(int i = 0; i < 3; i++) {
    dog_ids.push_back(i);
}

int weight[3] = {30, 50, 10};

// मान लें कि आप कुत्तों के वजन के अनुसार dog_ids को सॉर्ट करना चाहते हैं
// तो dog_ids अंत में बन जाना चाहिए: [२, ०, १]

// यहाँ वह जगह है जहाँ लैम्ब्डा के भाव काम आते हैं

sort(dog_ids.begin(), dog_ids.end(), [&weight](const int &lhs, const int &rhs) {
        return weight[lhs] < weight[rhs];
    });
// ध्यान दें कि हमने उपरोक्त उदाहरण में संदर्भ द्वारा "वजन" पर कब्जा कर लिया है।
// सी ++ में लैम्ब्डा पर अधिक: https://stackoverflow.com/questions/7627098/what-is-a-lambda-expression-in-c11

/////////////////////////////
// रेंज के लिए (सी ++ 11 और ऊपर)
/////////////////////////////

// आप एक कंटेनर पर लूप को पुनरावृत्त करने के लिए एक श्रेणी का उपयोग कर सकते हैं
int arr[] = {1, 10, 3};

for(int elem: arr){
    cout << elem << endl;
}

// आप "ऑटो" का उपयोग कर सकते हैं और कंटेनर के तत्वों के प्रकार के बारे में चिंता न करें
// उदाहरण के लिए:

for(auto elem: arr) {
    // Do something
}

/////////////////////
// मजेदार चीजें
/////////////////////

// सी ++ के पहलू जो नवागंतुकों (और यहां तक ​​​​कि कुछ दिग्गजों) के लिए आश्चर्यजनक हो सकते हैं।
// यह खंड, दुर्भाग्य से, बेतहाशा अधूरा है; सी ++ सबसे आसान में से एक है
// भाषाएं जिनके साथ अपने आप को पैर में गोली मारनी है।

// आप निजी तरीकों को ओवरराइड कर सकते हैं!
class Foo {
  virtual void bar();
};
class FooSub : public Foo {
  virtual void bar();  // Overrides Foo::bar!
};


// 0 == false == NULL (most of the time)!
bool* pt = new bool;
*pt = 0; // मान बिंदुओं को 'पीटी' द्वारा गलत पर सेट करता है।
pt = 0;  // 'पीटी' को अशक्त सूचक पर सेट करता है। दोनों पंक्तियाँ बिना किसी चेतावनी के संकलित हैं।

// nullptr उस समस्या में से कुछ को ठीक करने वाला है:
int* pt2 = new int;
*pt2 = nullptr; // Doesn't compile
pt2 = nullptr;  // Sets pt2 to null.

// बूल के लिए एक अपवाद बनाया गया है।
// यह आपको if(!ptr) के साथ नल पॉइंटर्स के लिए परीक्षण करने की अनुमति देता है,
// लेकिन परिणामस्वरूप आप सीधे बूल को नलप्टर असाइन कर सकते हैं!
*pt = nullptr;  // This still compiles, even though '*pt' is a bool!


// '=' != '=' != '='!
// कॉल फू :: फू (कॉन्स्ट फू एंड) या कुछ प्रकार (मूव शब्दार्थ देखें) कॉपी
// कंस्ट्रक्टर।
Foo f2;
Foo f1 = f2;

// कॉल फू :: फू (कॉन्स्ट फू एंड) या संस्करण, लेकिन केवल 'फू' भाग की प्रतिलिपि बनाता है
// 'फूसब'। 'fooSub' के किसी भी अतिरिक्त सदस्य को छोड़ दिया जाता है। यह कभी कभी
// भयानक व्यवहार को "ऑब्जेक्ट स्लाइसिंग" कहा जाता है।
FooSub fooSub;
Foo f1 = fooSub;

// Calls Foo::operator=(Foo&) or variant.
Foo f1;
f1 = f2;


////////////////////////////////////
// टुपल्स (सी ++ 11 और ऊपर)
////////////////////////////////////

#include<tuple>

// वैचारिक रूप से, टुपल्स पुराने डेटा संरचनाओं (सी-जैसी संरचना) के समान हैं
// लेकिन डेटा सदस्यों को नामित करने के बजाय,
// इसके तत्वों को टपल में उनके क्रम द्वारा एक्सेस किया जाता है।

// हम एक टपल के निर्माण के साथ शुरू करते हैं।
// मूल्यों को टपल में पैक करें
auto first = make_tuple(10, 'A');
const int maxN = 1e9;
const int maxL = 15;
auto second = make_tuple(maxN, maxL);

// Printing elements of 'first' tuple
cout << get<0>(first) << " " << get<1>(first) << '\n'; //prints : 10 A

// Printing elements of 'second' tuple
cout << get<0>(second) << " " << get<1>(second) << '\n'; // prints: 1000000000 15

// टपल को वेरिएबल में अनपैक करना

int first_int;
char first_char;
tie(first_int, first_char) = first;
cout << first_int << " " << first_char << '\n';  // prints : 10 A

// हम इस तरह टपल भी बना सकते हैं।

tuple<int, char, double> third(11, 'A', 3.14141);
// tuple_size टपल में तत्वों की संख्या लौटाता है (एक कॉन्स्टेक्स के रूप में)

cout << tuple_size<decltype(third)>::value << '\n'; // prints: 3

// tuple_cat सभी टुपल्स के तत्वों को एक ही क्रम में संयोजित करता है।

auto concatenated_tuple = tuple_cat(first, second, third);
// concatenated_tuple बन जाता है = (10, 'ए', 1e9, 15, 11, 'ए', 3.14141)

cout << get<0>(concatenated_tuple) << '\n'; // prints: 10
cout << get<3>(concatenated_tuple) << '\n'; // prints: 15
cout << get<5>(concatenated_tuple) << '\n'; // prints: 'A'


/////////////////////////////////
// लॉजिकल और बिटवाइज ऑपरेटर्स
////////////////////////////////

// सी ++ में अधिकांश ऑपरेटर अन्य भाषाओं की तरह ही हैं

// लॉजिकल ऑपरेटर्स

// सी ++ बूलियन अभिव्यक्तियों के लिए शॉर्ट-सर्किट मूल्यांकन का उपयोग करता है, यानी, दूसरा तर्क निष्पादित किया जाता है या
// केवल तभी मूल्यांकन किया जाता है जब पहला तर्क अभिव्यक्ति के मूल्य को निर्धारित करने के लिए पर्याप्त नहीं है

true && false // निष्पादित करता है **तार्किक और** असत्य उत्पन्न करने के लिए
true || false // सत्य उत्पन्न करने के लिए **तार्किक या** करता है
! true        // प्रदर्शन करता है **तार्किक नहीं** झूठा उत्पन्न करने के लिए

// प्रतीकों का उपयोग करने के बजाय समकक्ष कीवर्ड का उपयोग किया जा सकता है
true and false // प्रदर्शन करता है **तार्किक और ** गलत उत्पन्न करने के लिए
true or false  // सत्य उत्पन्न करने के लिए **तार्किक या ** करता है
not true       // निष्पादित करता है **तार्किक नहीं ** असत्य उत्पन्न करने के लिए

// बिटवाइज ऑपरेटर्स

// **<<** लेफ्ट शिफ्ट ऑपरेटर
// << बिट्स को बाईं ओर शिफ्ट करता है
4 << 1 // 8 देने के लिए 4 के बिट्स को 1 से बायीं ओर शिफ्ट करता है
// x << n को x * 2^n . के रूप में माना जा सकता है


// **>>** राइट शिफ्ट ऑपरेटर
// >> बिट्स को दाईं ओर शिफ्ट करता है
4 >> 1 // २ देने के लिए ४ के बिट्स को १ से दायीं ओर शिफ्ट करता है
// x >> n को x / 2^n . के रूप में माना जा सकता है

~4    // Performs a bitwise not
4 | 3 // Performs bitwise or
4 & 3 // Performs bitwise and
4 ^ 3 // Performs bitwise xor

// समतुल्य कीवर्ड हैं
compl 4    // Performs a bitwise not
4 bitor 3  // Performs bitwise or
4 bitand 3 // Performs bitwise and
4 xor 3    // Performs bitwise xor