basic guide of c++ code

(C++) क्या है और इसका उपयोग क्यों किया जाता है?

C++ एक शक्तिशाली और बहुमुखी प्रोग्रामिंग भाषा है जिसका उपयोग विभिन्न प्रकार के एप्लिकेशन विकसित करने के लिए किया जाता है। यह ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंग (Object-Oriented Programming - OOP) सिद्धांतों का समर्थन करती है, जो बड़े और जटिल सॉफ्टवेयर को संरचित और प्रबंधित करने में मदद करता है।

C++ का उपयोग निम्नलिखित कारणों से किया जाता है:

• प्रदर्शन: यह एक संकलित भाषा (compiled language) है, जिसका अर्थ है कि इसका कोड मशीन कोड में अनुवादित होता है जिसे कंप्यूटर सीधे चला सकता है। इससे यह बहुत तेज़ और कुशल बन जाती है, जो गेम डेवलपमेंट, सिस्टम सॉफ्टवेयर और उच्च-प्रदर्शन वाले एप्लिकेशन के लिए आदर्श है।
• लचीलापन: यह निम्न-स्तरीय प्रोग्रामिंग (low-level programming) (जैसे हार्डवेयर के साथ सीधे इंटरैक्ट करना) और उच्च-स्तरीय प्रोग्रामिंग (high-level programming) (जैसे जटिल लॉजिक और डेटा संरचनाएं बनाना) दोनों के लिए उपयुक्त है।
• विस्तृत उपयोग: इसका उपयोग ऑपरेटिंग सिस्टम (विंडोज, लिनक्स, मैकओएस), गेम इंजन (यूनिटी, अनरियल इंजन), ब्राउज़र (क्रोम, फ़ायरफ़ॉक्स), डेटाबेस और कई अन्य प्रकार के एप्लिकेशन को विकसित करने के लिए किया जाता है।
• विशाल पुस्तकालय समर्थन: C++ में एक बड़ा मानक पुस्तकालय है जो सामान्य प्रोग्रामिंग कार्यों के लिए पहले से ही कोड प्रदान करता है, जिससे विकास प्रक्रिया तेज हो जाती है।
• (OOP) समर्थन: क्लास, ऑब्जेक्ट, इनहेरिटेंस, पॉलिमॉर्फिज़म और एनकैप्सुलेशन जैसी OOP अवधारणाओं के समर्थन के कारण यह जटिल समस्याओं को हल करने के लिए बहुत अच्छी है।

(C++) में वेरिएबल कैसे घोषित करें?

C++ में, एक वेरिएबल एक मेमोरी स्थान का नाम होता है जिसका उपयोग प्रोग्राम के निष्पादन के दौरान डेटा को संग्रहीत करने के लिए किया जाता है। एक वेरिएबल घोषित करने के लिए, आपको इसका डेटा टाइप और फिर वेरिएबल का नाम बताना होगा।

सिंटेक्स:

डेटा_टाइप वेरिएबल_नाम;

उदाहरण:

int आयु;        // एक पूर्णांक (integer) वेरिएबल घोषित किया गया जिसका नाम 'आयु' है।

float औसत;      // एक फ्लोटिंग-पॉइंट (floating-point) वेरिएबल घोषित किया गया जिसका नाम 'औसत' है।

char पहला अक्षर; // एक कैरेक्टर (character) वेरिएबल घोषित किया गया जिसका नाम 'पहला अक्षर' है।

bool सहीयागलत;   // एक बूलियन (boolean) वेरिएबल घोषित किया गया जिसका नाम 'सहीयागलत' है।

double बड़ादशमलव; // एक डबल-प्रेसिजन फ्लोटिंग-पॉइंट वेरिएबल घोषित किया गया जिसका नाम 'बड़ादशमलव' है।

आप घोषणा के समय एक वेरिएबल को इनिशियलाइज़ (initialize) भी कर सकते हैं, जिसका अर्थ है कि आप उसे एक प्रारंभिक मान असाइन कर सकते हैं।

उदाहरण:

int संख्या = 10;

float तापमान = 25.5;

char ग्रेड = 'A';

bool स्थिति = true;

(C++) में डेटा टाइप क्या हैं?

डेटा टाइप (Data types) निर्दिष्ट करते हैं कि एक वेरिएबल किस प्रकार का डेटा संग्रहीत कर सकता है और उस डेटा पर कौन से ऑपरेशन किए जा सकते हैं। C++ में कई बुनियादी डेटा टाइप हैं:

• बुनियादी डेटा टाइप्स (Basic Data Types):
  • int: पूर्णांक (पूर्ण संख्याएँ) संग्रहीत करता है, जैसे -10, 0, 100।
  • float: एकल-परिशुद्धता फ्लोटिंग-पॉइंट संख्याएँ संग्रहीत करता है, जैसे 3.14, -2.71।
  • double: डबल-परिशुद्धता फ्लोटिंग-पॉइंट संख्याएँ संग्रहीत करता है, जो float से अधिक परिशुद्धता प्रदान करता है।
  • char: एक एकल कैरेक्टर संग्रहीत करता है, जैसे 'a', 'Z', '3'।
  • bool: बूलियन मान संग्रहीत करता है, या तो true (सही) या false (गलत)।
  • void: कोई डेटा टाइप नहीं दर्शाता है। इसका उपयोग आमतौर पर उन फ़ंक्शंस के लिए किया जाता है जो कोई मान नहीं लौटाते हैं।
• व्युत्पन्न डेटा टाइप्स (Derived Data Types):
  • एरे (Array): समान डेटा टाइप के तत्वों का एक संग्रह।
  • पॉइंटर (Pointer): किसी अन्य वेरिएबल के मेमोरी एड्रेस को संग्रहीत करता है।
  • रेफरेंस (Reference): किसी मौजूदा वेरिएबल का एक वैकल्पिक नाम।
  • फ़ंक्शन (Function): कोड का एक ब्लॉक जो एक विशिष्ट कार्य करता है।
• उपयोगकर्ता-परिभाषित डेटा टाइप्स (User-Defined Data Types):
  • क्लास (Class): ऑब्जेक्ट्स के लिए एक ब्लूप्रिंट, जिसमें डेटा (सदस्य चर) और फ़ंक्शंस (सदस्य फ़ंक्शन) शामिल होते हैं।
  • struct: क्लास के समान है, लेकिन डिफ़ॉल्ट रूप से इसके सदस्य सार्वजनिक होते हैं।
  • union: एक विशेष डेटा टाइप जो आपको एक ही मेमोरी स्थान पर विभिन्न डेटा टाइप्स को संग्रहीत करने की अनुमति देता है।
  • enum: पूर्णांक स्थिरांकों का एक सेट बनाता है, जिससे कोड अधिक पठनीय हो जाता है।
  • typedef: मौजूदा डेटा टाइप के लिए एक नया नाम बनाता है।
  • using: टाइप एलियास (type alias) घोषित करने का एक आधुनिक तरीका (typedef के समान)।

(C++) में ऑपरेटर कैसे काम करते हैं?

ऑपरेटर (Operators) विशेष प्रतीक होते हैं जिनका उपयोग वेरिएबल और मानों पर संचालन करने के लिए किया जाता है। C++ विभिन्न प्रकार के ऑपरेटर का समर्थन करता है:

• अंकगणितीय ऑपरेटर (Arithmetic Operators): +, -, *, /, %, ++, --
• तुलनात्मक ऑपरेटर (Comparison Operators): ==, !=, >, <, >=, <=
• तार्किक ऑपरेटर (Logical Operators): &&, ||, !
• असाइनमेंट ऑपरेटर (Assignment Operators): =, +=, -=, *=, /=, %=
• बिटवाइज़ ऑपरेटर (Bitwise Operators): (कम सामान्यतः उपयोग किया जाता है)
• विविध ऑपरेटर (Miscellaneous Operators): जैसे sizeof, ?:, ., ->, आदि।

उदाहरण:

int a = 10;

int b = 5;

int योग = a + b;       // योग = 15

int अंतर = a - b;     // अंतर = 5

bool बड़ा = a > b;     // बड़ा = true

bool औरकंडीशन = (a > 0) && (b < 10); // औरकंडीशन = true

a++;                 // अब a = 11 है

(C++) में if-else स्टेटमेंट कैसे उपयोग करें?

if-else स्टेटमेंट का उपयोग प्रोग्राम में निर्णय लेने के लिए किया जाता है। यह आपको एक कंडीशन (condition) का मूल्यांकन करने और कंडीशन के सत्य या असत्य होने के आधार पर कोड के विभिन्न ब्लॉक को निष्पादित करने की अनुमति देता है।

सिंटेक्स:

if (कंडीशन) {

  // यदि कंडीशन सत्य है तो निष्पादित होने वाला कोड

} else {

  // यदि कंडीशन असत्य है तो निष्पादित होने वाला कोड

}

else ब्लॉक वैकल्पिक है। आप कई कंडीशंस की जाँच के लिए else if स्टेटमेंट का भी उपयोग कर सकते हैं।

उदाहरण:

int अंक = 75;

if (अंक >= 60) {

  std::cout << "पास" << std::endl;

} else {

  std::cout << "फेल" << std::endl;

}

int ग्रेड = 85;

if (ग्रेड >= 90) {

  std::cout << "ए ग्रेड" << std::endl;

} else if (ग्रेड >= 80) {

  std::cout << "बी ग्रेड" << std::endl;

} else if (ग्रेड >= 70) {

  std::cout << "सी ग्रेड" << std::endl;

} else {

  std::cout << "डी ग्रेड" << std::endl;

}

(C++) में switch स्टेटमेंट कैसे उपयोग करें?

switch स्टेटमेंट एक और तरीका है जिससे आप कई अलग-अलग कोड ब्लॉक में से एक को निष्पादित कर सकते हैं, जो एक वेरिएबल के मान पर आधारित होता है।

सिंटेक्स:

switch (एक्सप्रेशन) {

  case मान1:

    // यदि एक्सप्रेशन का मान मान1 के बराबर है तो निष्पादित होने वाला कोड

    break;

  case मान2:

    // यदि एक्सप्रेशन का मान मान2 के बराबर है तो निष्पादित होने वाला कोड

    break;

  // ... और केस

  default:

    // यदि एक्सप्रेशन का मान किसी भी केस से मेल नहीं खाता है तो निष्पादित होने वाला कोड (वैकल्पिक)

}

प्रत्येक case के बाद break स्टेटमेंट का उपयोग करना महत्वपूर्ण है। default केस वैकल्पिक है।

उदाहरण:

char ग्रेड = 'बी';

switch (ग्रेड) {

  case 'ए':

    std::cout << "उत्कृष्ट!" << std::endl;

    break;

  case 'बी':

    std::cout << "बहुत अच्छा।" << std::endl;

    break;

  case 'सी':

    std::cout << "ठीक है।" << std::endl;

    break;

  default:

    std::cout << "सुधार की आवश्यकता है।" << std::endl;

}

(C++) में लूप (for, while, do-while) कैसे उपयोग करें?

लूप (Loops) का उपयोग कोड के एक ब्लॉक को कई बार निष्पादित करने के लिए किया जाता है। C++ तीन मुख्य प्रकार के लूप प्रदान करता है: for, while, और do-while।

for लूप

तब उपयोग किया जाता है जब आपको पता होता है कि लूप को कितनी बार निष्पादित करना है।

सिंटेक्स:

for (इनिशियलाइजेशन; कंडीशन; इंक्रीमेंट/डिक्रीमेंट) {

  // निष्पादित होने वाला कोड

}

उदाहरण:

for (int i = 0; i < 5; i++) {

  std::cout << i << std::endl; // आउटपुट: 0 1 2 3 4

}

while लूप

तब उपयोग किया जाता है जब आप अनिश्चित होते हैं कि लूप को कितनी बार निष्पादित करना है।

सिंटेक्स:

while (कंडीशन) {

  // निष्पादित होने वाला कोड

  // आमतौर पर यहां कंडीशन को प्रभावित करने वाला एक स्टेटमेंट होता है

}

उदाहरण:

int i = 0;

while (i < 5) {

  std::cout << i << std::endl; // आउटपुट: 0 1 2 3 4

  i++;

}

do-while लूप

while लूप के समान है, लेकिन यह गारंटी देता है कि लूप में कोड का ब्लॉक कम से कम एक बार निष्पादित होगा।

सिंटेक्स:

do {

  // निष्पादित होने वाला कोड

  // आमतौर पर यहां कंडीशन को प्रभावित करने वाला एक स्टेटमेंट होता है

} while (कंडीशन);

उदाहरण:

int i = 0;

do {

  std::cout << i << std::endl; // आउटपुट: 0

  i++;

} while (i < 1);

(C++) में फंक्शन कैसे बनाएं?

फंक्शन (Functions) कोड के ब्लॉक होते हैं जो एक विशिष्ट कार्य करते हैं।

सिंटेक्स:

रिटर्न_टाइप फंक्शन_नाम(पैरामीटर_लिस्ट) {

  // फंक्शन बॉडी - निष्पादित होने वाला कोड

  // यदि रिटर्न टाइप void नहीं है, तो एक return स्टेटमेंट होना चाहिए

}

उदाहरण:

// एक फंक्शन जो दो पूर्णांकों का योग करता है और परिणाम लौटाता है

int जोड़(int a, int b) {

  return a + b;

}

// एक फंक्शन जो एक ग्रीटिंग मैसेज प्रिंट करता है और कोई मान नहीं लौटाता है

void ग्रीटिंग(std::string नाम) {

  std::cout << "नमस्ते, " << नाम << "!" << std::endl;

}

int main() {

  int परिणाम = जोड़(5, 3);

  std::cout << "योग: " << परिणाम << std::endl; // आउटपुट: योग: 8

  ग्रीटिंग("जॉन"); // आउटपुट: नमस्ते, जॉन!

  return 0;

}

(C++) में फंक्शन के तर्क और रिटर्न वैल्यू कैसे काम करते हैं?

जब आप एक फंक्शन कॉल करते हैं, तो आप उसे आर्गुमेंट (arguments) पास कर सकते हैं।

उदाहरण:

// फंक्शन जो दो डबल लेता है और उनका गुणनफल लौटाता है

double गुणा(double num1, double num2) {

  double परिणाम = num1 * num2;

  return परिणाम;

}

int main() {

  double पहला नंबर = 4.5;

  double दूसरा नंबर = 2.0;

  double उत्पाद = गुणा(पहला नंबर, दूसरा नंबर); // पहला नंबर और दूसरा नंबर आर्गुमेंट हैं

  std::cout << "उत्पाद: " << उत्पाद << std::endl; // आउटपुट: उत्पाद: 9

  return 0;

}

(C++) में फंक्शन ओवरलोडिंग क्या है?

फंक्शन ओवरलोडिंग C++ की एक विशेषता है जो आपको एक ही नाम के कई फंक्शन बनाने की अनुमति देती है।

उदाहरण:

#include <iostream>

// फंक्शन जो दो पूर्णांकों का योग करता है

int जोड़(int a, int b) {

  std::cout << "पूर्णांकों का योग: ";

  return a + b;

}

// फंक्शन जो तीन पूर्णांकों का योग करता है

int जोड़(int a, int b, int c) {

  std::cout << "तीन पूर्णांकों का योग: ";

  return a + b + c;

}

// फंक्शन जो दो डबल का योग करता है

double जोड़(double a, double b) {

  std::cout << "डबल का योग: ";

  return a + b;

}

int main() {

  std::cout << जोड़(5, 10) << std::endl;      // पूर्णांकों का योग: 15

  std::cout << जोड़(1, 2, 3) << std::endl;   // तीन पूर्णांकों का योग: 6

  std::cout << जोड़(2.5, 3.7) << std::endl;  // डबल का योग: 6.2

  return 0;

}

(C++) में क्लास और ऑब्जेक्ट क्या हैं और कैसे बनाएं?

क्लास (Class) एक ब्लूप्रिंट या टेम्पलेट है जिसका उपयोग ऑब्जेक्ट (objects) बनाने के लिए किया जाता है।

सिंटेक्स:

class क्लास_नाम {

public:

  // सार्वजनिक सदस्य (डेटा और फंक्शन)

private:

  // निजी सदस्य (डेटा और फंक्शन)

protected:

  // संरक्षित सदस्य (डेटा और फंक्शन)

};

सिंटेक्स (ऑब्जेक्ट बनाना):

क्लास_नाम ऑब्जेक्ट_नाम;

उदाहरण:

#include <iostream>

#include <string>

class कार {

public:

  std::string रंग;

  std::string मॉडल;

  void जानकारीदें() {

    std::cout << "रंग: " << रंग << ", मॉडल: " << मॉडल << std::endl;

  }

};

int main() {

  कार मेरीकार;       // कार क्लास का एक ऑब्जेक्ट बनाना

  मेरीकार.रंग = "लाल";

  मेरीकार.मॉडल = "सेडान";

  मेरीकार.जानकारीदें(); // आउटपुट: रंग: लाल, मॉडल: सेडान

  कार दूसरीकार;

  दूसरीकार.रंग = "नीला";

  दूसरीकार.मॉडल = "एसयूवी";

  दूसरीकार.जानकारीदें(); // आउटपुट: रंग: नीला, मॉडल: एसयूवी

  return 0;

}

(C++) में इनहेरिटेंस क्या है और कैसे काम करता है?

इनहेरिटेंस (Inheritance) OOP का एक तंत्र है जो आपको एक नई क्लास बनाने की अनुमति देता है।

सिंटेक्स:

class व्युत्पन्न_क्लास_नाम : एक्सेस_निर्दिष्टीकरण बेस_क्लास_नाम {

public:

  // व्युत्पन्न क्लास के सदस्य

};

उदाहरण:

#include <iostream>

#include <string>

// बेस क्लास

class वाहन {

public:

  std::string ब्रांड;

  void जानकारीदें() {

    std::cout << "ब्रांड: " << ब्रांड << std::endl;

  }

};

// व्युत्पन्न क्लास

class कार : public वाहन {

public:

  int दरवाजोंकीसंख्या;

  void कारजानकारीदें() {

    जानकारीदें(); // बेस क्लास फंक्शन को कॉल करना

    std::cout << "दरवाजे: " << दरवाजोंकीसंख्या << std::endl;

  }

};

int main() {

  कार मेरीकार;

  मेरीकार.ब्रांड = "टोयोटा"; // बेस क्लास सदस्य को एक्सेस करना

  मेरीकार.दरवाजोंकीसंख्या = 4; // डिराइव्ड क्लास सदस्य को एक्सेस करना

  मेरीकार.कारजानकारीदें();

  // आउटपुट:

  // ब्रांड: टोयोटा

  // दरवाजे: 4

  return 0;

}

(C++) में पॉलिमॉर्फिज़म क्या है और कैसे काम करता है?

पॉलिमॉर्फिज़म (Polymorphism) OOP की एक अवधारणा है जिसका अर्थ है "कई रूप"।

कंपाइल-टाइम पॉलिमॉर्फिज़म

(फंक्शन ओवरलोडिंग और ऑपरेटर ओवरलोडिंग)

रन-टाइम पॉलिमॉर्फिज़म

(वर्चुअल फंक्शन)

उदाहरण (रन-टाइम पॉलिमॉर्फिज़म):

#include <iostream>

class पशु {

public:

  virtual void ध्वनिबनाओ() {

    std::cout << "पशु ध्वनि करता है" << std::endl;

  }

};

class कुत्ता : public पशु {

public:

  void ध्वनिबनाओ() override {

    std::cout << "कुत्ता भौंकता है" << std::endl;

  }

};

class बिल्ली : public पशु {

public:

  void ध्वनिबनाओ() override {

    std::cout << "बिल्ली म्याऊं करती है" << std::endl;

  }

};

int main() {

  पशु* p1 = new पशु();

  पशु* p2 = new कुत्ता();

  पशु* p3 = new बिल्ली();

  p1->ध्वनिबनाओ(); // आउटपुट: पशु ध्वनि करता है

  p2->ध्वनिबनाओ(); // आउटपुट: कुत्ता भौंकता है

  p3->ध्वनिबनाओ(); // आउटपुट: बिल्ली म्याऊं करती है

  delete p1;

  delete p2;

  delete p3;

  return 0;

}

(C++) में मेमोरी मैनेजमेंट कैसे करें?

C++ आपको मेमोरी को मैन्युअल रूप से प्रबंधित करने की अनुमति देता है।

स्टेटिक मेमोरी एलोकेशन

डायनामिक मेमोरी एलोकेशन

उदाहरण (डायनामिक मेमोरी एलोकेशन):

#include <iostream>

int main() {

  int* ptr = new int; // एक पूर्णांक के लिए डायनामिक रूप से मेमोरी आवंटित करना

  *ptr = 10;

  std::cout << "मान: " << *ptr << std::endl;

  delete ptr; // आवंटित मेमोरी को डी-आवंटित करना

  int* arr = new int[5]; // 5 पूर्णांकों के लिए डायनामिक रूप से मेमोरी आवंटित करना

  for (int i = 0; i < 5; i++) {

    arr[i] = i * 2;

  }

  std::cout << "एरे के तत्व: ";

  for (int i = 0; i < 5; i++) {

    std::cout << arr[i] << " ";

  }

  std::cout << std::endl;

  delete[] arr; // एरे के लिए आवंटित मेमोरी को डी-आवंटित करना

  return 0;

}

स्मार्ट पॉइंटर (Smart pointers) जैसी अवधारणाएँ मेमोरी मैनेजमेंट को आसान बनाने में मदद कर सकती हैं।

(C++) में पॉइंटर क्या हैं और कैसे उपयोग करें?

पॉइंटर (Pointers) ऐसे वेरिएबल हैं जो किसी अन्य वेरिएबल के मेमोरी एड्रेस को संग्रहीत करते हैं।

सिंटेक्स:

डेटा_टाइप* पॉइंटर_नाम;

उदाहरण:

#include <iostream>

int main() {

  int संख्या = 25;

  int* ptr;       // एक पूर्णांक पॉइंटर घोषित करना

  ptr = &संख्या;   // 'संख्या' का मेमोरी एड्रेस 'ptr' को असाइन करना

  std::cout << "संख्या का मान: " << संख्या << std::endl;       // आउटपुट: संख्या का मान: 25

  std::cout << "संख्या का मेमोरी एड्रेस: " << &संख्या << std::endl; // आउटपुट: संख्या का मेमोरी एड्रेस: 0x...

  std::cout << "पॉइंटर 'ptr' का मान: " << ptr << std::endl;    // आउटपुट: पॉइंटर 'ptr' का मान: 0x... (संख्या का एड्रेस)

  std::cout << "'ptr' द्वारा इंगित मान: " << *ptr << std::endl;  // आउटपुट: 'ptr' द्वारा इंगित मान: 25

  // पॉइंटर के माध्यम से संख्या के मान को संशोधित करना

  *ptr = 30;

  std::cout << "संख्या का नया मान: " << संख्या << std::endl; // आउटपुट: संख्या का नया मान: 30

  return 0;

}

(C++) में डायनामिक मेमोरी एलोकेशन कैसे करें?

C++ में डायनामिक मेमोरी एलोकेशन रन-टाइम पर new और delete ऑपरेटरों का उपयोग करके किया जाता है।

सिंटेक्स:

डेटा_टाइप* पॉइंटर = new डेटा_टाइप; // एकल ऑब्जेक्ट के लिए

डेटा_टाइप* पॉइंटर = new डेटा_टाइप[साइज़]; // एरे के लिए

उदाहरण:

#include <iostream>

int main() {

  // एकल पूर्णांक के लिए डायनामिक मेमोरी एलोकेशन

  int* myInt = new int;

  *myInt = 100;

  std::cout << "मान (डायनामिक): " << *myInt << std::endl;

  delete myInt;

  // पूर्णांकों के एरे के लिए डायनामिक मेमोरी एलोकेशन

  int साइज़ = 5;

  int* myArray = new int[साइज़];

  for (int i = 0; i < साइज़; i++) {

    myArray[i] = i * 5;

  }

  std::cout << "एरे के तत्व (डायनामिक): ";

  for (int i = 0; i < साइज़; i++) {

    std::cout << myArray[i] << " ";

  }

  std::cout << std::endl;

  delete[] myArray;

  return 0;

}

(C++) में फाइल कैसे पढ़ें और लिखें?

C++ आपको <fstream> लाइब्रेरी का उपयोग करके फाइलों को पढ़ने और लिखने की अनुमति देता है।

उदाहरण:

#include <iostream>

#include <fstream>

#include <string>

int main() {

  // फाइल में लिखना

  std::ofstream outfile("उदाहरण.txt");

  if (outfile.is_open()) {

    outfile << "यह फाइल में लिखी गई एक लाइन है।" << std::endl;

    outfile << "यह दूसरी लाइन है।" << std::endl;

    outfile.close();

    std::cout << "फाइल में सफलतापूर्वक लिखा गया।" << std::endl;

  } else {

    std::cerr << "फाइल खोलने में असमर्थ।" << std::endl;

  }

  // फाइल से पढ़ना

  std::ifstream infile("उदाहरण.txt");

  std::string line;

  if (infile.is_open()) {

    std::cout << "\nफाइल की सामग्री:" << std::endl;

    while (getline(infile, line)) {

      std::cout << line << std::endl;

    }

    infile.close();

  } else {

    std::cerr << "फाइल खोलने में असमर्थ।" << std::endl;

  }

  return 0;

}

(C++) में फाइल मोड क्या हैं और कैसे उपयोग करें?

जब आप <fstream> लाइब्रेरी का उपयोग करके किसी फाइल को खोलते हैं, तो आप एक फाइल मोड निर्दिष्ट कर सकते हैं।

उदाहरण:

#include <iostream>

#include <fstream>

int main() {

  // मौजूदा फाइल के अंत में लिखना

  std::ofstream appendFile("उदाहरण.txt", std::ios::app);

  if (appendFile.is_open()) {

    appendFile << "यह एक पंक्ति है जिसे जोड़ा गया है।" << std::endl;

    appendFile.close();

    std::cout << "फाइल में जोड़ा गया।" << std::endl;

  } else {

    std::cerr << "फाइल खोलने में असमर्थ।" << std::endl;

  }

  // बाइनरी फाइल लिखना

  std::ofstream binaryFile("बाइनरी.dat", std::ios::out | std::ios::binary);

  if (binaryFile.is_open()) {

    int data = 12345;

    binaryFile.write(reinterpret_cast<char*>(&data), sizeof(data));

    binaryFile.close();

    std::cout << "बाइनरी फाइल में लिखा गया।" << std::endl;

  } else {

    std::cerr << "बाइनरी फाइल खोलने में असमर्थ।" << std::endl;

  }

  return 0;

}

(C++) में त्रुटि हैंडलिंग कैसे करें?

C++ में त्रुटियों को संभालने के लिए कई तरीके हैं, जिनमें रिटर्न कोड और एक्सेप्शन हैंडलिंग शामिल हैं।

(C++) में try-catch ब्लॉक कैसे उपयोग करें?

try-catch ब्लॉक का उपयोग C++ में एक्सेप्शन को हैंडल करने के लिए किया जाता है।

सिंटेक्स:

try {

  // कोड जिसमें एक्सेप्शन उत्पन्न हो सकता है

  // ...

  if (/* कोई त्रुटि स्थिति */) {

    throw std::runtime_error("एक त्रुटि हुई"); // एक एक्सेप्शन फेंकना

  }

  // ...

} catch (डेटा_टाइप एक्सेप्शन_ऑब्जेक्ट) {

  // एक्सेप्शन को हैंडल करने वाला कोड

  std::cerr << "पकड़ा गया एक्सेप्शन: " << एक्सेप्शन_ऑब्जेक्ट.what() << std::endl;

} catch (...) {

  // अन्य सभी प्रकार के एक्सेप्शन को पकड़ने वाला ब्लॉक (वैकल्पिक)

  std::cerr << "एक अज्ञात एक्सेप्शन पकड़ा गया।" << std::endl;

}

उदाहरण:

#include <iostream>

#include <stdexcept>

int भागफल(int अंश, int हर) {

  if (हर == 0) {

    throw std::runtime_error("शून्य से भागफल!");

  }

  return अंश / हर;

}

int main() {

  int a = 10;

  int b = 0;

  int परिणाम;

  try {

    परिणाम = भागफल(a, b);

    std::cout << "परिणाम: " << परिणाम << std::endl;

  } catch (const std::runtime_error& e) {

    std::cerr << "त्रुटि: " << e.what() << std::endl;

  }

  int c = 20;

  int d = 5;

  try {

    परिणाम = भागफल(c, d);

    std::cout << "परिणाम: " << परिणाम << std::endl; // आउटपुट: परिणाम: 4

  } catch (const std::runtime_error& e) {

    std::cerr << "त्रुटि: " << e.what() << std::endl;

  }

  return 0;

}

(C++) में एरे क्या हैं और कैसे उपयोग करें?

एरे (Arrays) समान डेटा टाइप के तत्वों का एक निश्चित आकार का अनुक्रमिक संग्रह है।

सिंटेक्स:

डेटा_टाइप एरे_नाम[साइज़];

उदाहरण:

#include <iostream>

int main() {

  int अंक[5]; // 5 पूर्णांकों का एक एरे घोषित करना

  // एरे के तत्वों को इनिशियलाइज़ करना

  अंक[0] = 10;

  अंक[1] = 20;

  अंक[2] = 30;

  अंक[3] = 40;

  अंक[4] = 50;

  // एरे के तत्वों को एक्सेस करना और प्रिंट करना

  std::cout << "एरे के तत्व:" << std::endl;

  for (int i = 0; i < 5; i++) {

    std::cout << "अंक[" << i << "] = " << अंक[i] << std::endl;

  }

  // घोषणा के समय एरे को इनिशियलाइज़ करना

  int औरअंक[] = {100, 200, 300}; // साइज़ स्वचालित रूप से 3 पर सेट हो जाएगा

  std::cout << "\nदूसरे एरे के तत्व:" << std::endl;

  for (int i = 0; i < sizeof(औरअंक) / sizeof(औरअंक[0]); i++) {

    std::cout << "औरअंक[" << i << "] = " << औरअंक[i] << std::endl;

  }

  return 0;

}

(C++) में लिंक्ड लिस्ट क्या हैं और कैसे उपयोग करें?

लिंक्ड लिस्ट (Linked lists) एक प्रकार का डेटा स्ट्रक्चर है जो तत्वों (नोड्स) का एक क्रम है।

उदाहरण:

#include <iostream>

struct नोड {

  int डेटा;

  नोड* अगला;

};

int main() {

  नोड* हेड = nullptr; // खाली लिस्ट

  // पहला नोड जोड़ना

  नोड* पहलानोड = new नोड;

  पहलानोड->डेटा = 10;

  पहलानोड->अगला = nullptr;

  हेड = पहलानोड;

  // दूसरा नोड जोड़ना

  नोड* दूसरानोड = new नोड;

  दूसरानोड->डेटा = 20;

  दूसरानोड->अगला = nullptr;

  पहलानोड->अगला = दूसरानोड;

  // लिस्ट को ट्रैवर्स करना और डेटा प्रिंट करना

  नोड* वर्तमान = हेड;

  std::cout << "लिंक्ड लिस्ट के तत्व: ";

  while (वर्तमान != nullptr) {

    std::cout << वर्तमान->डेटा << " ";

    वर्तमान = वर्तमान->अगला;

  }

  std::cout << std::endl;

  // मेमोरी को साफ़ करना (मेमोरी लीक से बचने के लिए महत्वपूर्ण)

  वर्तमान = हेड;

  नोड* अगलानोड;

  while (वर्तमान != nullptr) {

    अगलानोड = वर्तमान->अगला;

    delete वर्तमान;

    वर्तमान = अगलानोड;

  }

  हेड = nullptr;

  return 0;

}

**(C++)** मानक टेम्पलेट लाइब्रेरी (STL) std::list क्लास प्रदान करती है।

(C++) में स्टैक और क्यू क्या हैं और कैसे उपयोग करें?

स्टैक (Stack) और क्यू (Queue) लीनियर डेटा स्ट्रक्चर हैं।

उदाहरण (STL का उपयोग करके):

#include <iostream>

#include <stack>

#include <queue>

int main() {

  // स्टैक का उपयोग करना

  std::stack<int> मेरास्टैक;

  मेरास्टैक.push(10);

  मेरास्टैक.push(20);

  मेरास्टैक.push(30);

  std::cout << "स्टैक के शीर्ष तत्व: " << मेरास्टैक.top() << std::endl; // आउटपुट: स्टैक के शीर्ष तत्व: 30

  मेरास्टैक.pop(); // 30 को हटाना

  std::cout << "स्टैक के शीर्ष तत्व अब: " << मेरास्टैक.top() << std::endl; // आउटपुट: स्टैक के शीर्ष तत्व अब: 20

  std::cout << "स्टैक का आकार: " << मेरास्टैक.size() << std::endl;     // आउटपुट: स्टैक का आकार: 2

  // क्यू का उपयोग करना

  std::queue<std::string> मेरीक्यू;

  मेरीक्यू.push("पहला");

  मेरीक्यू.push("दूसरा");

  मेरीक्यू.push("तीसरा");

  std::cout << "क्यू का पहला तत्व: " << मेरीक्यू.front() << std::endl; // आउटपुट: क्यू का पहला तत्व: पहला

  मेरीक्यू.pop(); // "पहला" को हटाना

  std::cout << "क्यू का पहला तत्व अब: " << मेरीक्यू.front() << std::endl; // आउटपुट: क्यू का पहला तत्व अब: दूसरा

  std::cout << "क्यू का आकार: " << मेरीक्यू.size() << std::endl;       // आउटपुट: क्यू का आकार: 2

  return 0;

}

अतिरिक्त जानकारी:

• (नेमस्पेस (Namespaces)): C++ नेमस्पेस का उपयोग नाम टकराव से बचने के लिए किया जाता है।
• (टेम्प्लेट (Templates)): टेम्प्लेट आपको जेनेरिक फ़ंक्शन और क्लासेस लिखने की अनुमति देते हैं।
• (प्रीप्रोसेसर डायरेक्टिव (Preprocessor Directives)): #include, #define जैसी पंक्तियाँ प्रीप्रोसेसर डायरेक्टिव हैं।

यह लेख (C++) प्रोग्रामिंग के विभिन्न पहलुओं को कवर करता है, जिसमें बुनियादी अवधारणाएँ, (डेटा टाइप्स), (ऑपरेटर), कंट्रोल फ्लो स्टेटमेंट, (फंक्शन), (क्लास) और (ऑब्जेक्ट), (इनहेरिटेंस), (पॉलिमॉर्फिज़म), मेमोरी मैनेजमेंट, (पॉइंटर), फाइल हैंडलिंग, त्रुटि हैंडलिंग और डेटा स्ट्रक्चर शामिल हैं। प्रत्येक विषय को विस्तृत जानकारी और उदाहरणों के साथ समझाया गया है, जिससे यह (C++) सीखने के इच्छुक किसी भी व्यक्ति के लिए एक संपूर्ण गाइड बन जाता है।