C++ in Hindi : Enumerated Types

C++ Enumerated Types

  • Introduction to C++ enumerated types in Hindi 
  • Syntax of C++ enumerated types in Hindi 
  • Example of C++ enumerated types in Hindi

Introduction to C++ Enumerated Types

एक enumerated type (enumeration) user defined data type होता है जिसके variables को कुछ limited values ही assign की जा सकती है। वे values programmer द्वारा enumerated type को declare करते समय ही define की जाती है।

कई बार एक programmer के रूप में आपको ऐसा variable create करने की आवश्यकता होती है जिसको कुछ पहले से निश्चित values ही assign की जा सकती हो। उदाहरण के लिए आप एक gender variable create करते है। इस variable की Male और Female दो ही सही values हो सकती है। 
यदि gender variable को इनके अलावा कोई दूसरी value assign की जाती है तो वह appropriate नहीं होगी। इस situation में आप एक enumerated type declare कर सकते है जिसके variable को सिर्फ Male और Female दो ही values assign की जा सकती हो। 
इसके बाद आप किसी normal type की तरह उस type का variable create करते है। फर्क सिर्फ इतना होगा की normal variable को कोई भी value assign की जा सकती है। लेकिन आपके enumerated type के variable को सिर्फ Male और Female values ही assign की जा सकेगी। 
जब किसी integer variable को कोई character value assign की जाती है तो compiler error generate करता है। उसी प्रकार यदि enumerated type के variable को कोई दूसरी value assign करने का प्रयास किया जाता है तो compiler द्वारा error generate की जाती है।    
Enumerated type की values को enumerators कहा जाता है। Enumerators named constants होते है। यानी technically background में enumerators constants होते है जिन्हें नाम दिया जाता है। 
Enumerators को numbers array की ही तरह zero से assign किये जाते है। यानी आपके पहले enumerator को 0, दूसरे enumerator को 1 और उसी प्रकार हर enumerator को एक number अधिक constants assigned होते है। 
Enumerated types को switch statement के साथ भी use किया जा सकता है। जैसा की आपको पता है switch statement में case pass किया जाता है। एक enumerated type के variable को आप switch case statement में आसानी से pass कर सकते है। 

Syntax of C++ Enumerated Types

C++ में enumerated types को declare करने का general syntax निचे दिया जा रहा है।

enum enumerated-type-name{value1, value2, value3…..valueN};

जैसा की आप ऊपर दिए गए syntax में देख सकते है enumerated type को enum keyword द्वारा declare किया जाता है। इसके बाद enumerated type का नाम लिखा जाता है। इसके बाद curly brackets में वे possible values define की जाती है जिनमें से कोई एक आप उस type के variable को assign करवाना चाहते है।

Enumerated type define करने के बाद उसके variable create किये जाते है। Enumerated type के variable आप दो प्रकार से create कर सकते है। एक तो आप enumerated type को declare करते समय ही curly brackets में values को define करने के बाद और semicolon से statement को end करने से पूर्व उस variable का नाम define कर सकते है।

Enumerated type को declare करते समय ही उसके variable create करने का general syntax निचे दिया जा रहा है।

enum enumerated-type-name{value1, value2,….valueN}variable-name;

इसके अलावा आप separately भी किसी normal variable की तरह enumerated type के variables create कर सकते है।

enumerated-type-name variable-name = value;

किसी normal variable की ही तरह enumerated type के variables को print किया जा सकता है। जब आप ऐसा करते है तो variable का equivalent constant display होता है।

Example of C++ Enumerated Types

C++ में enumerated types के उपयोग को निचे उदाहरण द्वारा समझाया जा रहा है।

#include<iostream>
using namespace std;

int main()
{

   // Defining enum Gender
   enum Gender{Male,Female};

   // Creating Gender type variable
   Gender gender = Male;

   switch(gender)
   {
       case Male : cout<<“Gender is Male”;
       break;
       case Female : cout<<“Gender is Female”;
       break;
       default : cout<<“Value can be Male or Female”;
   }

   return 0;
}

ऊपर दिया गया उदाहरण निचे दिया गया output generate करता है।

Gender is Male

C++ in Hindi : Multithreading

C++ Multithreading

  • Introduction to C++ multithreading in Hindi
  • Implementing C++ multithreading in Hindi 
  • Example of C++ multithreading in Hindi

Introduction to C++ Multithreading 

एक thread किसी process में stream होती है जिससे कोई task perform होता है। किसी process में एक या एक से अधिक threads हो सकती है। हर thread एक independent task को represent करती है।

ऐसी process जिनमें सिर्फ एक thread होती है single threaded process कहलाती है। ऐसी processes से एक साथ एक से अधिक tasks perform नहीं किये जा सकते है। उदाहरण के लिए calculator एक single threaded process होती है। एक calculator में आप एक साथ कई अलग अलग calculations perform नहीं कर सकते है।

जिन processes में एक से अधिक threads होती है वे multithreaded processes कहलाती है। Multithreaded processes में अलग अलग threads के द्वारा एक साथ कई tasks perform किये जा सकते है।

उदाहरण के लिए आपका browser एक multithreaded process है उसमे open किया गया हर tab एक thread (या stream) को represent करता है। उन tabs के द्वारा एक साथ अलग अलग webpages को देखा जा सकता है।

जब कई threads एक साथ कार्य करती है तो वह process multithreading कहलाती है। जब आप कोई C++ program create करते है तो वह एक single threaded program होता है। आपके program का main() method एक single thread को represent करता है।

लेकिन आप अपने program को multithreaded बना सकते है और एक साथ कई tasks perform कर सकते है।

C++ में complete multithreading support C++ के version 11 में add किया गया था। इससे पूर्व multithreading को implement करने के लिए आपको C language में available POSIX threads (pthreads) library को use करना होता था।

हालाँकि POSIX threads library द्वारा multithreading implement की जा सकती थी। लेकिन यह कोई standard तरीका नहीं था और इसे implement करना बहुत complex था।

C++ के version 11 में आपको <thread.h> header file provide की गयी है जिसमे multithreading के लिए जरुरी thread class और functions available है जिन्हें आप अपने program में कँही भी use कर सकते है।

Implementing Multithreading in C++

किसी भी C++ program में multithreading implement करने के लिए सबसे पूर्व आप <thread.h> header file को अपने program में include करते है। इसका syntax निचे दिया जा रहा है।

#include<thread>

OR

#include<thread.h>

केवल <thread.h> header file को include करने के बाद ही आप अपने program में threads create कर सकते है।

Creating Threads 

ऊपर बताई गयी <thread.h> header file में available thread class एक single thread को represent करती है। एक thread create करने के लिए आपको बस thread class का object create करना होता है। 
इस प्रकार आप thread class के कई objects create करके कई threads create कर सकते है। इसका syntax निचे दिया जा रहा है।

thread thread-object-name(callable-code); 

जैसा की आप ऊपर दिए गए syntax में देख सकते है thread class का object create करते समय callable code pass किया जाता है। Callable code वह code होता है जो thread के launch होने पर execute किया जाता है।

Callable code निचे दिए जा रहे codes में से कोई एक हो सकता है।

  • Function – Callable code के रूप में आप किसी function का नाम pass कर सकते है। वह function thread launch होने पर execute हो जाता है। 
  • Class object – Callable code के रूप में किसी class का object भी pass किया जा सकता है। ऐसा करने के लिए आपको उस class में () operator को overload करना होता है। इस operator को override करते समय आप जो code define करते है वही code thread के launch होने पर call होता है। 
  • Lambda expression – Callable code के रूप में lambda expression को भी pass किया जा सकता है। Lambda expression एक unnamed function ही होता है। Lambda function के द्वारा आप thread create करते समय ही उसका callable code भी define कर पाते है। 
यदि callable code किसी प्रकार का argument accept करता है तो arguments को आप callable code के बाद comma से separate करके लिखते है। इसका syntax निचे दिया जा रहा है।

thread thread-object-name(callable-code,arg1,arg2,….argN);

हालाँकि lambda expression के case में इस प्रकार arguments नहीं pass किये जाते है। 

Joining Threads 

Thread object create करने के बाद thread को main thread के साथ attach (join) किया जाता है। यदि thread को main thread के साथ join नहीं किया जाए तो आपकी main thread का execution पहले complete हो जाएगा और thread object द्वारा define की गयी thread execute ही नहीं हो पाएगी। 
किसी thread को main thread के साथ join करने के लिए join() method का प्रयोग किया जाता है। इसका general syntax निचे दिया जा रहा है।

thread-object-name.join();

एक बार जब किसी thread को main thread के साथ join कर दिया जाता है तो main thread अपना execution complete करके terminate होने से पहले उस thread के लिए wait करती है।

Detaching Threads 

जिस प्रकार threads को attach (join) किया जाता है उसी प्रकार उन्हें detach भी किया जाता है। इसके लिए detach() function का प्रयोग किया जाता है। इस function को thread object द्वारा call किया जाता है। 
यह function किसी thread को उसकी parent thread से detach करता है। इसका general syntax निचे दिया जा रहा है।

thread-object-name.detach();

एक thread detach होने के बाद joinable बन जाती है उसे दूसरी threads के साथ attach किया जा सकता है।

Example of C++ Multithreading

C++ multithreading के use को निचे उदाहरण द्वारा समझाया जा रहा है।

#include<iostream>
#include<thread> // Including thread header file
using namespace std;

void myFunc()
{
    cout<<“T1 thread executed”<<endl;
}

int main()
{
    // Creating thread t1 which executes myFunc() function
    thread t1(myFunc);

    // Joining t1 with main thread
    t1.join();

    cout<<“Main thread executed”<<endl;

   return 0;
}

ऊपर दिया गया उदाहरण निचे दिया गया output generate करता है।

T1 thread execute
Main thread executed

C++ in Hindi : Abstract Classes

C++ Abstract Classes

  • Introduction to C++ abstract classes in Hindi 
  • Syntax of C++ abstract classes in Hindi 
  • Example of C++ abstract classes in Hindi 

Introduction to C++ Abstract Classes

Abstract classes ऐसी classes होती है जिनको सिर्फ दूसरी classes द्वारा inherit करने के लिए ही define किया जाता है। Abstract classes का उद्देश्य दूसरी classes को एक structure provide करना होता है जिसे inherit किया जा सके।

किसी class को abstract बनाने के लिए उसमें कम से कम एक pure virtual function define किया जाना आवश्यक होता है। Pure virtual function सिर्फ method का declaration होता है। Pure virtual function = 0 द्वारा declare किया जाता है।

एक pure virtual function की definition वह class provide करती है जो abstract class को inherit करती है। Inherit करने वाली class के लिए pure virtual function की definition provide करना आवश्यक होता है।

यदि ऐसा नहीं किया जाता है तो inherit करने वाली class स्वयं भी abstract बन जाती है। इसके बाद उसे inherit करने वाली class के लिए pure virtual function की definition provide करना आवश्यक हो जाता है।

Normal classes की तरह किसी abstract class के objects नहीं create किये जा सकते है। यदि ऐसा करने का प्रयास किया जाता है तो error generate होती है।

ऐसा इसलिए होता है क्योंकि abstract classes में pure virtual functions की definition नहीं होती है। जब तक किसी method की definition ना हो तो उसे use नहीं किया जा सकता है।

C++ में abstract classes के माध्यम से ही interfaces implement किये जाते है। दूसरे शब्दों में कहा जाए तो C++ में abstract classes ही interfaces होती है। C++ में abstract classes का मुख्य उद्देश्य modern programming languages (java, C# आदि) की तरह interfaces implement करना ही होता है।

Abstract classes को define करने के लिए आपको pure virtual functions के बारे में पता होना आवश्यक है। इसलिए यदि आपने अभी तक pure virtual functions के बारे में नहीं पढ़ा है तो इनके बारे में विस्तृत जानकारी के लिए कृपया C++ Virtual Functions in Hindi tutorial पढ़े। 

Syntax of C++ Abstract Classes

C++ में abstract class (interface) define करने का general syntax निचे दिया जा रहा है।

class-keyword class-name
{
     //Normal members here (variables, methods)
    //At least one pure virtual function;
}

जैसा की आप ऊपर दिए गए syntax में देख सकते है किसी normal class की ही तरह abstract classes में variables और methods define किये जाते है। इसके अलावा एक abstract class में pure virtual functions भी define किये जाते है।

जब तक कम से कम एक pure virtual function नहीं define किया जाएगा तब तक वह class abstract नहीं कहलाएगी। आप चाहे तो किसी class के सभी functions को pure virtual define कर सकते है।

Example of C++ Abstract Classes

C++ में abstract classes के उपयोग को निचे उदाहरण द्वारा समझाया जा रहा है।

#include<iostream>
using namespace std;

// Virtual class
class myAbstractClass
{

  public:
 
    int Num; 

    // Defining pure virtual function
    virtual void setNum(int n) = 0;

    virtual void display()
    {
          cout<<“Num is : “<<Num;
    }

};

// Normal class inheriting virtual class
class myClass : myAbstractClass
{

public:

    // Providing definition of pure virtual function
    void setNum(int n)
    {
        this->Num = n;
        this->display();
    }

};

int main()
{
   myClass obj;

   obj.setNum(5);
 
   return 0;
}

ऊपर दिया गया उदाहरण निचे दिया गया output generate करता है।

Num is : 5
Previous: C++ References

C++ in Hindi : Abstraction

C++ Abstraction 

  • Introduction to C++ abstraction in Hindi 
  • C++ access specifiers in Hindi 
  • Example of C++ abstraction in Hindi

Introduction to C++ Abstraction

Data abstraction object oriented programming के सबसे महत्वपूर्ण features में से एक है। Data abstraction को data hiding भी कहा जाता है। Data abstraction का मतलब है की उस data को show करना जो user के लिए महत्वपूर्ण है और उस data को hide करना जो user के लिए महत्वपूर्ण नहीं है।

अगर दूसरे शब्दों में कहा जाए तो user को सिर्फ वह data show करना जिसके साथ वह interact करेगा और बाकी की details जो user के लिए किसी भी प्रकार उपयोगी नहीं या अप्रासंगिक है उसे hide करना ही data abstraction कहलाता है।

Data abstraction का एक उदाहरण आपका यह computer हो सकता है जिसके द्वारा आप इस aritcle को पढ़ रहे है। इस computer में आपको सिर्फ mouse के रूप में एक pointer और keyboard के रूप में कुछ keys provide की गयी है जिनके द्वारा आप इस computer से interact करते है।

Background में यह computer कैसे कार्य कर रहा है वह detail आपको show नहीं की गयी है। क्योंकि आपके लिए उस detail का कोई उपयोग नहीं है। इसी प्रकार data abstraction को implement करके आप अपने program के user को सिर्फ वही data या functionality show करते है जो उसके लिए उपयोगी है बाकी की details आप hide करते है।

Abstraction का उपयोग सिर्फ data को hide करने के लिए ही नहीं बल्कि data को protect करने के लिए भी किया जाता है। Data को hide करके आप एक तरह से उसे protect ही कर रहे होते है। क्योंकि hide किया जाने वाला data किसी द्वारा access नहीं किया जा सकता है।

निचे program में data abstraction implement करने की कुछ advantages दी जा रही है।

  • Data abstraction के माध्यम से आप program में implementation और interface को separate कर पाते है। User को interface provide किया जाता है जिससे वह interact करेगा और program का real implementation hide कर लिया जाता है। 
  • Data abstraction की सबसे महत्वपूर्ण advantage यह है की यदि आपको implementation में किसी प्रकार का change करना हो तो ऐसा आप बिना user को disturb किये कर सकते है। इसके लिए आपको user के interface में बदलाव की आवश्यकता नहीं होती है। 
  • Data abstraction से आपकी application secure हो जाती है। 

C++ में data abstraction classes में implementation members को hide करके और interface members को show करके implement किया जाता है।

Implementation members ऐसे class members (variables और methods) होते है जो user से hide किये जाएंगे या फिर जिनका user के लिए कोई उपयोग नहीं है। Interface members (variables और methods) ऐसे members होते है जिन्हें user को show किया जाएगा या जो interface के रूप में user द्वारा उपयोग किये जाएंगे।

C++ में कौनसे members hide होंगे और कौनसे members show होंगे यह define करने के लिए access specifiers का प्रयोग किया जाता है जिनके बारे में आप अगले section में जानेंगे।

C++ Access Specifiers

C++ में members को hide और show करने के लिए 2 access specifiers का प्रयोग किया जाता है। इनके बारे में निचे बताया जा रहा है। 
  • public – इस access specifier द्वारा आप उन members को define करते है जो किसी दूसरे code द्वारा (या class के बाहर) access किये जा सकते है। Public access specifier द्वारा आप program का interface define करते है। इस specifier द्वारा define किये गए सभी members दूसरे code को visible होते है। 
  • private – इस access specifier द्वारा program में implementation define किया जाता है। Private access specifier द्वारा define किये गए members visible नहीं होते है। ऐसे members को दूसरे code द्वारा या class के बाहर access नहीं किया जा सकता है। 
किसी भी C++ program में abstraction implement करने की best approach यह होती है की सब data members (variables) को private define किया जाये और methods को public define किया जाए जो data members से interact करने के लिए प्रयोग किये जाएंगे।

C++ access specifiers को classes में define करने का general syntax निचे दिया जा रहा है।

class-keyword class-name
{
     private:
                  // All private members here…

     public:
                 // All public members here…
};

जैसा की आप ऊपर दिए गए syntax में देख सकते है access specifiers के बाद colon लगाकर उन members को define किया जाता है जिन्हें आप private या public define करना चाहते है।

Example of C++ Abstraction

C++ में abstraction को implement करना निचे उदाहरण द्वारा समझाया जा रहा है।

#include<iostream>
using namespace std;

class myClass
{
  private:
                // Hiding Num by creating it private
                int Num = 5;

  public:
                void display()
                {
                    cout<<“Num is : “<<Num;
                }

};

int main()
{
    myClass obj;

    // Displaying Num using display() function
    obj.display();

    return 0;
}

ऊपर दिया गया उदाहरण निचे दिया गया output show करता है।

Num is : 5

C++ in Hindi : References

C++ References 

  • Introduction to C++ references in Hindi 
  • Syntax of C++ references in Hindi 
  • Example of C++ references in Hindi

Introduction to C++ References 

C++ में reference या reference variable किसी existing variable का alias (वैकल्पिक नाम) होता है। एक बार जब आप किसी variable का reference create करते है तो आप reference variable को real variable की तरह ही प्रयोग कर पाते है। आप दोनों में से किसी भी name को use कर सकते है।

Reference variables normal variables से थोड़े अलग होते है। References compiler द्वारा compile time पर check किये जाते है। इसलिए reference variables को initialize किया जाना अनिवार्य होता है।

एक बार define करने के बाद एक reference किसी दूसरे type को नहीं refer कर सकता है। उदाहरण के लिए यदि आपने एक reference variable create किया है जो integer variable को refer करता है तो आप उसी reference से किसी दूसरे type जैसे की double आदि के variable को नहीं refer कर सकते है।

References को किसी दूसरे variable के address से initialize किया जाता है। ऐसे में आप सोच सकते है की references भी pointers ही होते है लेकिन ऐसा बिलकुल भी नहीं होता है। यह स्पष्ट करने के लिए निचे references और pointers में कुछ differences दिए जा रहे है।

  • एक बार जब reference initialize हो जाए तो उससे आप किसी दूसरे variable को refer नहीं कर सकते है। क्योंकि एक reference किसी memory location का दूसरा नाम होता है और आप कई memory locations को एक ही नाम नहीं दे सकते है। Pointers के द्वारा आप कितने भी variables को initialize कर सकते है। क्योंकि एक  pointer सिर्फ point करने का कार्य करता है। 
  • References कभी भी NULL नहीं हो सकते है। Reference variables हमेशा किसी memory location को refer करते है जँहा पर value stored रहती है। लेकिन pointers को NULL set किया जा सकता है। 
  • जब reference variables को declare किया जाता है तो उन्हें initialize करना जरुरी होता है। लेकिन pointers को declare करते समय initialize करना आवश्यक नहीं होता है। 
  • Reference variable द्वारा refer किये जाने वाली variable की value को use करने के लिए dereferencing (*) operator की आवश्यकता नहीं होती है। आप references variables को normal variables की तरह directly use कर सकते है। लेकिन pointers के द्वारा value access करने के लिए dereferencing operator की आवश्यकता होती है। 
Reference variables को functions में parameters और return type के रूप में भी use किया जा सकता है। Methods को by reference call करके variables को real time में modify किया जाता है। 

Syntax of C++ References 

C++ में reference variables create करने का general syntax निचे दिया जा रहा है।

data-type dereferencing-operator(&) reference-name = variable-name;

जैसा की आप ऊपर दिए गए syntax में देख सकते है reference variable को declare करते समय सबसे पहले data type define किया जाता है। Reference variable का data type भी वही होना चाहिए जो real variable का होता है।

इसके बाद dereferencing operator (&) define किया जाता है। उसके बाद reference variable का नाम define किया जाता है। Reference variable का नाम unique होना चाहिए। इसके बाद वह variable assign किया जाता है जिसे आप refer करना चाहते है।

जैसा की मैने आपको पहले बताया एक reference variable को compile time पर check किया जाता है इसलिए उसे initialize करना अनिवार्य होता है।

Example of C++ References 

C++ में references को use करना निचे उदाहरण द्वारा समझाया जा रहा है।

#include<iostream>
using namespace std;

int main()
{
    int Num = 10;
 
    // Defining reference of Num variable
    int& N = Num;

    cout<<“Num is : “<<Num<<endl;

    // Changing value of Num using reference variable
    N = 20;

    cout<<“Now Num is : “<<N<<endl;
}

ऊपर दिया गया program निचे दिया गया output generate करता है।

Num is : 10
Now Num is : 20

C++ in Hindi : Operators

C++ Operators

  • Introduction to C++ operators in Hindi 
  • Different C++ operators in Hindi 

Introduction to C++ Operators

किसी भी C++ program में data पर operations perform किये जाते है। इसके लिए सबसे पूर्व data को variables के द्वारा computer memory में store किया जाता है। इसके बाद C++ द्वारा supported operators को use करते हुए उस data पर operations perform किये जाते है।

उदाहरण के लिए आप दो variables जिनमे integer values store की गयी है उनके बीच addition operation perform करते है। ऐसा आप addition operator (+) द्वारा करेंगे।

C++ आपको अलग अलग operations perform करने के लिए अलग अलग type के operators provide करती है। जिन्हें आप variables के साथ प्रयोग करते है।

उदहारण के लिए यदि आप program में arithmetic operations जैसे की addition, subtraction, division आदि perform करना चाहते है तो इसके लिए arithmetic operators +, -, / आदि का प्रयोग करते है।

उसी प्रकार यदि आप program में logic (data को compare करना) perform करना चाहते है तो उसके लिए relational operators जैसे की <, >, = आदि use करते है।

Operators के साथ define किये जाने वाले variables operands कहलाते है। उदाहरण के लिए आपने 2 variables a और b create किये है। अब आप इन दोनों के बीच addition operation perform करके result c variable में store करना चाहते है। आप इस प्रकार code लिखते है।

c = a + b;

ऊपर दिए गए code में a और b operands है। क्योंकि इन दोनों को addition (+) operator के साथ define किया गया है। इस code में c भी एक operand है क्योंकि इसे assignment (=) operator के साथ define किया गया है।

C++ में दो तरह के operators पाए जाते है। इनके बारे में निचे बताया जा रहा है।

  • Binary – ऐसे operators जो दो operands के साथ operation perform करते है binary operators कहलाते है। उदाहरण के लिए सभी arithmetic operators binary operators होते है। 
  • Unary – ऐसे operators जो एक operand के साथ operation perform करते है unary operator कहलाते है। उदाहरण के लिए increment (++) और decrement (–) operators unary operators होते है। इन्हे एक ही variable (operand) के साथ use किया जाता है। 

C++ में available विभिन्न operators के बारे में आगे detail से बताया जा रहा है।

Arithmetic Operators 

Arithmetic operators वे operators होते है जिनके द्वारा arithmetic operations perform किये जाते है। C++ द्वारा supported arithmetic operators की list निचे दी जा रही है।

Operator
Explanation 
Syntax
+ (Addition)
Adds a and b
a + b
– (Subtraction)
Subtract b from a
a – b
* (Multiplication)
Multiply a and b
a * b
/ (Division)
Divide a by b
a / b
% (Modulus)
Divide a by b and return remaining value 
a % b

Relational Operators

Relational operators data को compare करने या data के बीच relation define करने के लिए प्रयोग किये जाते है। ये operators true और false के रूप में boolean value return करते है। C++ में available relational operators की list निचे दी जा रही है।

Operator
Explanation 
Syntax
> (Greater than)
Checks whether a is greater than b
a > b
< (Lesser than)
Checks whether a is lesser than b

a < b
>= (Greater than & equal)
Checks whether a is greater than & equal to b 
a >= b
<= (Lesser than & equal)
Checks whether a is lesser than & equal to
a <= b
== (Equal)
Checks whether a is equal to b 
a == b
!= (Not equal)
Checks whether a is not equal to b
a != b

Logical Operators

Logical operators program में logic perform करने के लिए प्रयोग किये जाते है। ये operators conditional expressions के बीच प्रयोग किये जाते है और boolean value true या false return करते है। C++ में available logical operators के बारे में निचे दिया जा रहा है।

Operator
Explanation 
Syntax
&& (AND)
returns true if both conditions are true
cond1 && cond2
|| (OR)
returns true if any of the two condition is true
cond1 || cond2
! (NOT)
returns true if condition is not true, Unary operator 
 !cond

Bitwise Operators

Bitwise operators program में bit operations perform करने के लिए प्रयोग किये जाते है। सबसे पहले variables की values को bits में convert किया जाता है और उसके बाद उन पर operations perform किये जाते है। ये operators true और false return करते है। C++ में available bitwise operators की list निचे दी जा रही है।

Operator
Explanation 
Syntax
& (Binary AND)
Returns bits which are identical in a and b
a & b
| (Binary OR)
Returns all bits from a and b

a | b
^ (XOR)
Returns bits which are in a but not in b
a ^ b
~ (Binary Ones compiment)
Unary operator, Change 0 bits to one and 1 bit to 0
~a
<< (Left Shift)
Shifts bits of a to left by number given on right side of <<
a << number
>> (Right Shift)
Shifts bits of a to right by number given on right side of >>
a >> number

Assignment Operators

Program में assignment operations perform करने के लिए assignment operators प्रयोग किये जाते है। C++ में available assignment operators के बारे में निचे दिया जा रहा है।

Operator
Explanation 
Syntax
= (Assignment)
Assign value of a to b
a = b
+= (Plus and assignment)
Add value of a & b then assign result to a

a += b
-= (Minus and assignment)
Subtract value of b from a then assign result to a
a -= b
*= (Multiply and assignment)
Multiply a & b then assign result to a
a *= b
/= (Divide and assignement)
Divide a by b then assign result to a
a /= b
%= (Modulus and assignment)
Divide a by b then assign remaining value to a
a %= b

Conditional Operator (?:)

C++ आपको conditional operator provide करती है। यह operator ? और : के combination से बनता है। यह operator if else statement का short रूप होता है। इस operator का general syntax निचे दिया जा रहा है।

condition ? true-part : false-part

जैसा की आप ऊपर दिए गए syntax में देख सकते है सबसे पूर्व condition define की जाती है। इसके बाद question mark (?) symbol लगाया जाता है।

इस symbol के बाद वह statement लिखा जाता है जो condition true होने पर use किया जाएगा। इसके बाद colon (:) symbol लगाया जाता है। Colon symbol के बाद वह code लिखा जाता है जो condition के true होने पर use किया जाएगा।

इस operator को मुख्यतः condition के आधार पर variables को value assign करने के लिए प्रयोग किया जाता है।

sizeof() Operator 

C++ में sizeof operator किसी भी variable की size return करता है। इसका syntax निचे दिया जा रहा है।

sizeof(variable-name);

जिस variable की size आप पता करना चाहते है उसका नाम brackets में लिखा जाता है।

* (Pointer) Operator 

Pointer variable define करने के लिए pointer operator का प्रयोग किया जाता है। इस operator का general syntax निचे दिया जा रहा है।

data-type *variable-name;

Pointer variable का प्रयोग किसी दूसरे operator का address store करने के लिए किया जाता है।

& (address of) Operator 

C++ में address of operator किसी भी variable का address return करता है। इस operator का syntax निचे दिया जा रहा है।

pointer-variable = &variable-name;

Address of operator को उस variable के नाम से पूर्व define किया जाता है जिसका variable आप access करना चाहते है। Address को किसी pointer variable में store किया जाता है।

Previous: C++ Constants
Next: C++ Flow Control

C++ in Hindi : Constants

C++ Constants

  • Introduction to C++ constants in Hindi 
  • Defining C++ constants in Hindi 
  • Example of C++ constants in Hindi 

Introduction to C++ Constants

C++ में constants और variables एक समान ही होते है। Constants को भी variables की तरह ही define किया जाता है, इनके data type भी variables के जैसे ही होते है और memory allocation भी variables की तरह ही होता है।

एक constant और variable में फर्क सिर्फ इतना होता है की variable की value run time में किसी भी operation द्वारा change की जा सकती है लेकिन constant की value run time में किसी भी तरह change नहीं की जा सकती है।

उदाहरण के लिए आपने एक variable Num create किया है जिसको आपने 0 value assign की है। Program के run होने पर आप इसमें 2+2 add करके Num variable में store करवाते है।

int Num = 0;

Num = 2+2;  // Num now have 4

इसके बाद Num variable की value 4 हो जाती है जिसे आप print करवाते है। ऐसा आसानी से हो जाता है क्योंकि Num एक variable है और इसकी value आसानी से change हो सकती है।

लेकिन यदि ऊपर दिए गए उदाहरण में Num एक constant होता है और उसकी value को 2+2 expression द्वारा change करने का प्रयास किया जाता तो ऐसा होने पर program में error generate होती है।

Constant को value उन्हें create करते समय ही assign की जाती है। एक बार program run होने के बाद constant की value को change नहीं किया जा सकता है।

C++ में 2 प्रकार के constants होते है। इनके बारे में निचे बताया जा रहा है।

Literal Constants 

एक literal constant direct value होती है। जैसे की 5, 5.4, hello world आदि। Program में जब भी इनकी आवश्यकता होती है तो इन्हे directly use किया जाता है। उदाहरण के लिए कोई variable Num है की जिसकी value 10 है। आप Num variable की value को 2 से divide करके result variable में result store करना चाहते है।

int Num, Result;

Num = 10;

// 2 is literal, used directly in program
Result = Num/2;            

ऐसे में आप Num/2 इस प्रकार लिखेंगे। यँहा पर 2 एक literal constant (direct value) है। इसे directly program में define किया गया है।

Literal constants की के साथ सबसे बड़ी problem यह होती है की यदि आपने इन्हे program में कई बार use किया है और बाद में आपको इन्हे change करने की आवश्यकता होती है तो आपको उन्हें सभी जगह पर ढूंढ के manually change करना होगा। इस problem का solution Symbolic constants होते है।

Symbolic Constants 

Literal constant की तरह symbolic constant कोई value नहीं होती है। Symbolic constant एक नाम होता है जो एक memory location को represent करता है जँहा पर value stored रहती है।

उस नाम के द्वारा आप value को access कर पाते है जैसा की आप variables के साथ करते है। लेकिन जैसा की आपको पता है आप उस value को change नहीं कर सकते है।

Symbolic constant को आप program में कितनी भी बार use कर सकते है। जब आप इसकी value change करते है तो वह value program में automatically change हो जाती है। इसलिए literal constants की अपेक्षा symbolic constants अधिक उपयोगी होते है।

Defining C++ Constants 

C++ में literal constants को आप आसानी से use कर पाते है लेकिन symbolic constants को आप पहले define करते है और उसके बाद use कर करते है। C++ में symbolic constants को आप दो प्रकार से define कर सकते है। इनके बारे में निचे बताया जा रहा है। 

Using #define Preprocessor

C++ में constants को #define preprocessor के द्वारा define करने का general syntax निचे दिया जा रहा है।

#define constant-name value

जब आप #define preprocessor द्वारा constant define करते है तो ऐसा आप program की शुरआत में header files को include करने के बाद करते है। जब आप #define preprocessor के द्वारा constant define करते है तो किसी प्रकार का data type नहीं define करते है।

सबसे पहले आप #define preprocessor को define करते है। इसके बाद आप constant का नाम देते है और उसके बाद space दे कर उसकी value देते है।

Using const Keyword 

C++ में constant define करने के लिए const keyword को use करने का general syntax निचे दिया जा रहा है।

const-keyword data-type constant-name = value;

आप const keyword के प्रयोग से किसी particular type (int, float, char आदि) का constant create कर सकते है।

सबसे पहले आप const keyword define करते है। इसके बाद आप वह data type define करते है जिसका constant आप create करना चाहते है। इसके बाद आप constant का नाम लिखते है और उसके बाद assignment operator (=) लगाकर वह value लिखते है जिसे आप उस constant name के द्वारा access करना चाहते है।

Example of C++ Constants

C++ में constants के use को निचे उदाहरण द्वारा समझाया जा रहा है।

#include<iostream>
using namespace std;

int main()
{
    // Defining constant.
    const int Tax = 5;

    int Bill, Total;

    cout<<“Please enter item amount”;
    cin>>Bill;

    // Tax can not be changed while calculating bill.
    Total =Bill+((Bill*Tax)/100);

    cout<<“Total billing amount with tax is : “<<Total;
 
}

ऊपर दिया गया उदाहरण निचे दिया गया output generate करता है।

Please enter item amount : 300
Total billing amount with tax is : 315 

Previous: C++ Variables

C++ in Hindi : Storage Classes

C++ Storage Classes 

  • Introduction to C++ storage classes in Hindi 
  • Different C++ storage classes in Hindi 

Introduction to C++ Storage Classes

C++ में variables की अलग अलग storage classes (categories) होती है। अलग अलग storage classes के variables अलग अलग तरीके से store और process किये जाते है।

Storage classes programmer को variables के storage, visibility और scope का control provide करती है। Programmers अपनी आवश्यकता के अनुसार किसी भी storage class का variable create कर सकते है।

एक storage class के माध्यम से compiler को variable के बारे में निचे दी जा रही जानकारी प्राप्त होती है।

  • Storage – Storage classes के द्वारा compiler को पता चलता है की variable को कँहा और कैसे store किया जाएगा। 
  • Initial value – Storage classes के माध्यम से compiler को variable की initial (शुरूआती) value पता चलती है। Initial value वह value होती है जो variable create होते ही उसे उसकी class के अनुसार automatically assign हो जाती है। अलग अलग storage classes के variables की initial value अलग अलग होती है। 
  • Scope – Storage classes के माध्यम से compiler को variables के scope का भी पता चलता है। अलग अलग storage classes के variables का scope अलग अलग होता है। 
  • Lifetime – Storage class के माध्यम से compiler को variables के life time का भी पता चलता है। किसी भी variable का life time वह period होता है जब तक वह memory में रहता है। Storage classes के according सभी variables का lifetime अलग अलग होता है। 
C++ में  निचे दी जा रही storage classes available है।

  • auto 
  • register
  • static 
  • extern
  • mutable 
इन सभी storage classes के बारे में आगे detail से बताया जा रहा है। 

auto (automatic)

Auto storage class के variables का scope local होता है। सभी local variables auto variables होते है या फिर आप यह भी कह सकते है की सभी local variables की default storage class auto होती है। 
Auto class के variables की default value garbage होती है। Auto variables RAM में store किये जाते है।
Auto class के variables का life time function तक ही सिमित होता है। जैसे ही function का execution समाप्त होता है variable को memory से remove कर दिया जाता है। 
Auto class के variables को auto keyword द्वारा create किया जाता है। इसका general syntax निचे दिया जा रहा है।

auto data-type variable-name = value;

जैसा की ऊपर बताया गया है by default सभी local variables auto class के होते है इसलिए variables create करते समय आपको auto keyword का प्रयोग करने की आवश्यकता नहीं होती है। जब आप ऐसा करते है तो compiler द्वारा warning show की जाती है। यह special conditions में प्रयोग किया जाता है।

register 

Auto storage class की ही तरह register storage class के variables का scope local होता है, initial value garbage होती है और इनका lifetime function block ही होता है।

लेकिन register variables को CPU registers में store किया जाता है। Register CPU का हिस्सा होते है। Registers को RAM से भी अधिक speed से access किया जा सकता है।

जब आप register variables create करते है तो इस बात की कोई guarantee नहीं होती है की variable register में ही store होगा। यह सिर्फ एक request होती है जो बताती है की यदि program को run करते समय CPU registers free है तो variable को registers में ही store किया जाना चाहिए।

Register variables का एक drawback यह है की आप register variables के pointers नहीं create कर सकते है। Register variables memory में store नहीं होते है इसलिए इनका कोई memory address नहीं होता है। इसलिए आप इनके pointer variables नहीं create कर सकते है।

Register variables create करने का general syntax निचे दिया जा रहा है।

register-keyword data-type variable-name;

जैसा की आप ऊपर दिए गए syntax में देख सकते है register variables को register keyword द्वारा define किया जाता है।

जब आपको किसी variables को program में frequently use करना हो तब आपको उसे register storage class के साथ define करना चाहिए।

static 

Static storage class के variables का scope local होता है और इनकी initial value zero होती है। Static variables का lifetime complete program का execution होता है। यानी की जब तक पूरा program execute होता है तब तक static variable memory में रहता है। 
हालाँकि static variables का lifetime complete program execution होता है लेकिन इन variables को केवल उन्हीं functions blocks द्वारा प्रयोग किया जा सकता है जिनके द्वारा इन्हे create किया गया है। 
Static variables create करने का general syntax निचे दिया जा रहा है।

static-keyword data-type variable-name;

Static variables को static keyword द्वारा create किया जाता है।

Extern (External)

Extern storage class के variables का scope global होता है और इनकी initial value zero होती है। Extern variables का lifetime complete program execution होता है। 
Extern variables create करने का general syntax निचे दिया जा रहा है।

extern-keyword data-type variable-name;

Extern variables को program के बाहर extern keyword द्वारा globally declare किया जाता है। Extern variables को सभी program files में access किया जा सकता है। Extern variables को declare करते समय आप उन्हें initialize नहीं कर सकते है। 

Mutable 

Mutable storage class सिर्फ class objects के साथ ही प्रयोग की जाती है। Mutable variables (objects) की initial value zero होती है, इनका scope local होता है और इनका lifetime वह class होती है जिनके सन्दर्भ में इन्हें define किया जाता है। 
जैसा की आपको पता है की constant variables को modify नहीं किया जा सकता है उसी प्रकार constant objects के data members को भी नहीं change किया जा सकता है। लेकिन यदि कोई data member (variable) mutable declare किया गया है तो उसे constant object के द्वारा change किया जा सकता है।

Mutable variables create करने का general syntax निचे दिया जा रहा है।

mutable-keyword data-type data-member-name;

Mutable variables को mutable class के साथ declare किया जाता है।

Previous: C++ Type Qualifiers
Next: C++ References

C++ in Hindi : Type Qualifiers

C++ Type Qualifiers

  • Introduction to C++ type qualifiers in Hindi 
  • Different C++ type qualifiers in Hindi 

Introduction to C++ Type Qualifiers

C++ में type qualifiers के द्वारा किसी variable के बारे में अतिरिक्त जानकारी provide की जाती है। इन्हें variable के नाम से पूर्व define किया जाता है।

उदाहरण के लिए type qualifier का प्रयोग करके आप compiler को बता सकते है की variable की value change नहीं की जा सकती है।

C++ में निचे दिए जा रहे type qualifiers available है।

  • const
  • volatile 
  • restrict
इन सभी type qualifiers के बारे में निचे detail से बताया जा रहा है। 

const 

जब किसी variable को const qualifier के साथ define किया जाता है तो इसका अर्थ यह होता है की उस variable की value change नहीं की जा सकती है। Const variable create करने का general syntax निचे दिया जा रहा है। 
const-keyword data-type variable-name = value;
इस प्रकार के variables को declare करते समय ही इनकी value set की जाती है। किसी भी const variable की value compile time पर known होनी चाहिए। यदि ऐसा नहीं किया जाता है तो error generate होती है।

// No value set, will generate an error
const int Age;    

यदि किसी class object को const define किया जा रहा है तो यह आवश्यक है की उस class के सभी members को constructor में initialize (value set करना) किया जाए। Class objects को const define करने का general syntax निचे दिया जा रहा है।

const-keyword class-name object-name;

इसके अलावा जब किसी object को const define किया जाता है तो उस class के किसी भी data members (variables) की value change नहीं की जा सकती है। साथ ही उस class के कोई भी non const functions call नहीं किये जा सकते है। 
एक pointer को भी constant define किया जा सकता है। इसका syntax निचे दिया जा रहा है।

data-type * const-keyword Variable-name = value;

Const pointer define करने के लिए pointer operator (*) और variable name के बीच const keyword define किया जाता है।

volatile 

C++ में volatile type qualifier compiler को बताता है की variable की value program में define किये गए तरीकों के अलावा किसी दूसरे माध्यम से भी change हो सकती है। इस प्रकार के variable पर compiler या program का कोई control नहीं होता है। 
Volatile variables की value program के बाहर दूसरे mediums से change होती है। उदाहरण के लिए किसी hardware की state change होने के कारण ऐसे variables की value change हो सकती है। 
Volatile variables create करने का general syntax निचे दिया जा रहा है। 
volatile-keyword data-type variable-name = value;
Volatile variables memory access में consistency रखते है। जब भी volatile variable की value की आवश्यकता होती है तो इसे memory में से read किया जाता है और जब volatile variable की value change होती है तब ही इसे memory में write किया जाता है। 
जब किसी class को volatile define किया जाता है तो उसके सभी members automatically volatile हो जाते है।

volatile class class-name
{
     //all class members will be volatile

कोई variable एक साथ const और volatile दोनों हो सकता है। ऐसे में वह variable किसी ऐसी process द्वारा change किया जाता है जो asynchronous हो।

आप किसी function को भी volatile define कर सकते है। लेकिन ऐसा आप केवल तब ही कर सकते है जब वह function static नहीं हो और class का member हो।

restrict 

C++ में restrict qualifier restrict pointers define करने के लिए प्रयोग किया जाता है। जब किसी pointer को restrict define किया जाता है तो जिस object को वह point करता है उसे सिर्फ और सिर्फ उसी restrict pointer द्वारा access किया जा सकता है। इसके अलावा उस object को access करने वाले सभी माध्यमों को restrict कर दिया जाता है।

Previous: C++ Exception Handling
Next: C++ Storage Classes

C++ in Hindi : Type Modifiers

C++ Type Modifiers

  • Introduction to C++ type modifiers in Hindi 
  • Different C++ type modifiers in Hindi 
  • Example of C++ type modifiers in Hindi

Introduction to C++ Type Modifiers

C++ आपको कुछ built in primitive data types (int, char और double) को modify (change) करने की capability provide करती है। ऐसा type modifiers द्वारा किया जाता है।

किसी data type को change करने की आवश्यकता कई कारणों से हो सकती है। उदाहरण के लिए आप एक integer variable Age create करते है। जिसकी value user से runtime में प्राप्त की जाती है।

Normally एक integer variable में negative values भी store की जा सकती है। इसलिए यह संभावना है की user कोई negative value enter करे।

लेकिन आप चाहते है की आपका Age variable negative values ना store करें तो इसके लिए आप type modifier के प्रयोग से int को इस प्रकार modify कर सकते है की वह सिर्फ positive values ही store करेगा।

Type modifiers द्वारा मुख्यतः किसी data type की size और उसकी sign characterstics को change किया जा सकता है। यानी एक तो आप data type की size change कर सकते है और इसके अलावा आप यह भी decide कर सकते है की data type द्वारा negative value allow की जायेगी या नहीं।

Different C++ Type Modifiers

C++ में क्रमशः signed, unsigned, short और long 4 data type modifiers available है। इनके बारे में निचे detail से बताया जा रहा है।

signed 

इस type modifier को integer और character के साथ use किया जाता है। यह type modifier बताता है की variable में negative और positive दोनों तरह की values store की जा सकती है। By default एक integer signed ही होता है। एक signed integer की range -32768 से 32767 तक होती है। 
Integer के अलावा char के साथ भी इस type modifier को use किया जा सकता है। हालाँकि कोई भी character negative या positive नहीं हो सकता है। लेकिन C++ में सभी characters असल में numbers (ASCII Codes) द्वारा ही represent किये जाते है।

इसलिए यदि आप signed char define करते है तो आप -128 से 127 तक के numbers से characters को use कर सकते है।

unsigned 

इस modifier को int और char के साथ use किया जा सकता है। जब किसी integer variable को unsigned define किया जाता है तो उसमे सिर्फ positive values ही store की जा सकती है।
जब आप unsigned char define करते है तो आप 0 से 255 तक के numbers से character को define कर सकते है। 

short 

इस modifier को integer के साथ use किया जाता है। यह modifier integer की size modify करने के लिए use किया जाता है। इस modifier के प्रयोग से integer की size आधी हो जाती है। 

long 

इस modifier को int और long types के साथ use किया जाता है। इस modifier के प्रयोग से data type की size दुगनी हो जाती है। 

Example of C++ Type Modifiers

C++ type modifiers के उपयोग को निचे उदाहरण द्वारा समझाया जा रहा है।

#include<iostream>
using namespace std;

int main()
{
    // Unsigned integer variable can only store positive value
    unsigned int numF = -3000;

    // Signed integer variable can store negative value
    signed int numS = -3000;
 
    cout<<numF<<n;
    cout<<numS<<n;

    return 0;
}

ऊपर दिए गए उदाहरण में numF एक unsigned integer variable है जिसमें -3000 value store की जा रही है। जब इसकी value print की जायेगी तो एक random number show किया जाएगा क्योंकि यह एक unsigned integer है।

इसके अलावा numS एक signed integer variable है। जब इसकी value print की जायेगी तो -3000 ही print होगा क्योंकि यह एक signed integer variable है। यह उदाहरण निचे दिया गया output generate करता है।

247292920
-3000
Previous: C++ Namespaces