C++
UNIT - I
वस्तुकेन्द्रित प्रोग्रमिंग (OBJECT ORIENTED PROGRAMMING) सी भी समस्या का समाधान करने के लिए पहले उस वस्तु पर केन्द्रित करते हैं तथा उस वस्तु को विशेषताओं और कमियों से ही उसके प्रयोग की विधियों की खेाज करते है। समस्त विश्व वस्तु केन्द्रित (Object Oriented) ही है। कम्प्यूटर प्रोग्रामिंग में प्रोग्रमिंग की आधुनिक शैली वस्तु केन्द्रित प्रोग्रामिंग भी इसी तथ्य के अनुरूप है। आधुनिक कम्प्यूटर प्रोग्रामिंग भाषाओं जैसे- C++, JAVA आदि में इसी प्रोग्रामिंग शैली का प्रयोग होता है।
परम्परागत प्रोग्रामिंग शैली एवं वस्तु केन्द्रित प्रोग्रामिंग शैली कम्प्यूटर प्रोग्राम लिखने की परम्परागत प्रोग्रामिंग शैली में हम परिवर्तनांको के आधार पर प्रोग्रामिंग में अनेक Function के अन्दर करते है। इन्हीं परिवर्तनांको के आधार पर प्रोग्रामिंग में अनेक प्रकार के कार्य किये जा सकते है। जैसेः- गणनाएं, आकडे, प्रिंट करना आंकडे संचित करना (store) आदि कार्य होते है। वस्तु केन्द्रित प्रोग्रामिंग में परिवर्तनांकों एवं किसी वर्ग के आंकडे प्रभावित नहीं होतें है। इससे प्रोग्राम को नियन्त्रण करना सरल हो जाता है। इस कार्य को वस्तु केन्द्रित प्रोग्रामिंग भाषा (Object Oriented Programming Language) में एनकैप्स्यूलेशन जिसका शाब्दिक अर्थ एक के भीतर दूसरा रखने की क्रिया कहा जाता है।
वस्तु और वर्ग प्रोग्रामिंग वस्तु केन्द्रित शैली के बारे में अन्य जानकारी प्राप्त करने से पूर्व हमें वस्तु (Object) एवं वर्ग (Class) के बारे में जानकारी होनी आवश्यक है।
वस्तु (Object) प्रोग्रामिंग की वस्तु केन्द्रित शैली का भी यही मुख्य आधार है। विभिन्न वस्तुओं को एकत्र करके प्रयोग का एक नमूना तैयार किया जाता है, जो कि सार्वजनिक लक्ष्य को प्राप्त करने के लिए आपस में सूचनाओं का आदान प्रदान करते हैं।
वर्ग (Class)
आंकड़ा का पृथक्करण (Data Abstraction )
आंकड़ा नियन्त्रण (Data Encapsulation)
बहुरूपण (Polymorphism)
उत्तराधिकार (Inheritance)
संदेश प्रवहन (Message Passing)
ऑब्जेक्ट (Object)
ऑब्जेक्ट किसी वर्ग का एक दृष्टान्त होता है (Object is an Instance of a Class) ऑब्जेक्ट एवं पब्लिक Function की सहायता से ही वर्ग घोषित किए गए परिवर्तनांकों के मान में परिवर्तन किया जाता है ।
वर्ग (Class)
वर्ग विभिन्न Function एवं परिवर्तनांकों का एक समूह है (Class is a Collection of different Data Type of Variables and Function) किसी भी ऑब्जेक्ट ओरिएण्टेड प्रोग्राम में कम से कम एक वर्ग का घोषित किया जाना आवश्यक होता है । चूंकि प्रोग्रामिंग भाषा C++ में तैयार किए गए प्रोग्राम को भी C++ में चलाया जा सकता है, अतः प्रोग्रामिंग भाषा C++ को पूर्णतया ऑब्जैक्ट ओरिएण्टेड प्रोग्रामिंग भाषा नहीं कहा जा सकता ।
आंकड़ों का पृथक्करण (Data Abstraction) सम्पूर्ण जटिलता के सरलीकरण से है। इसे इस प्रकार समझें, कि लाइट ऑन करने के लिए स्विच बोर्ड पर केवल एक स्विच को दबाने का कार्य करते हैं । इस कार्य के लिये स्विच को दबाने से स्विच के अन्दर क्या हुआ, स्विच के दबाने से लाइट कैसे ऑन हुई, यह सब जानने की आवश्यकता नहीं होती । यही गुण पृथक्करण (Abstraction) कहलाता है।
इस प्रकार कह सकते हैं, किसी कार्य को सम्पन्न करने के लिये केवल आवश्यक ज्ञान ही पर्याप्त है, न कि कार्य की आन्तरिक प्रक्रिया एवं उससे सम्बन्धित अप्रत्यक्ष रूप में होने वाले कार्य के ज्ञान की भी ।
आंकड़ा नियंत्रण (Data Encapsulation)
आंकड़ा नियन्त्रण वस्तु केन्द्रित प्रोग्रामिंग शैली का एक अत्यन्त महत्वपूर्ण तथ्य है। यह Data Structure एवं Functionality को वस्तु (Object) में मिलाता है। एनकैप्स्यूलेशन ऑब्जैक्ट के आन्तरिक रूप को उसके उपयोक्ता से छुपाता भी है। और उपयोग हो सकने वाले ऑब्जैक्ट को सूचित भी करता है। आंकड़ा नियन्त्रण (Encapsulation) अर्थात् Function व आंकड़ों को एकीकरण करना।
ऑब्जेक्ट ओरिएण्टेड प्रोग्रामिंग शैली की इस विशेषता के कारण प्रोग्राम एवं आंकड़ों दोनों को बाहरी हस्तक्षेप से बचा सकते है। उत्तराधिकार भी ऑब्जैक्ट ओरिएण्टेड प्रोग्रमिंग शैली की एक महत्वपूर्ण एवं उपयोगी विशेषता है। इसके द्वारा एक वर्ग की विशेषता किसी दूसरे वर्ग से प्राप्त करवा सकते हैं। इस महत्वपूर्ण विधि से हमारे प्रोग्राम को नए आयाम मिलते हैं। इसमें मूल class को base class तथा उत्तराधिकार प्राप्त करने वाले class को derived class के या child class कहा जाता है।
प्रथम वस्तु केन्द्रित प्रोग्रामिंग भाषा Simula (DN66, Kir 89) का निर्माण अनुरूपण (Simulation) सुविधा उपलब्ध कराने के लिए किया गया था। अनुरूपण (Simulation) एक एप्लीकेशन के जटिल निर्माण अस्तित्वों को एकत्रित करके करता है। एक एप्लीकेशन में प्रत्येक अस्तित्वों का उनके स्वभाव, उनके गुणों और उनके व्यहारों को आंका जाता है। इसके इस स्वभाव के कारण अनुरूपण (Simulation) को सरलता पूर्वक समझा जा सकता है। इसमें अस्तित्वों को सीधे प्रयोग करने की सुविधा के कारण अनुरूपण (Simulation) वाले प्रोग्रामिंग अन्य प्रोग्राम्स से भिन्न नजर आते हैं। यदि अस्तित्व के लिए वस्तु शब्द का प्रयोग किया जाए तो हमें वस्तु का अनुस्थापन (Object Orientation ) प्राप्त हो जाता है। वस्तु का अनुस्थापन (Object Orientation ) किन्हीं सॉफटवेयर्स को ऑब्जेक्ट के संग्रह के रूप में प्रदर्शित करता है , जिसमें वस्तु केन्द्रित प्रोग्रामिंग भाषा की विशेषताएं वस्तु केन्द्रित अर्थात् ऑब्जेक्ट ओरिएण्टेड प्रोग्रामिंग भाषा की निम्नांकित विशेषताएं होती हैं, जिनके कारण इसे वस्तु केन्द्रित प्रोग्रामिंग भाषा कहा जाता है -
बहुरूपण (Polymorphism)
बहुरूपण (Polymorphism) का शाब्दिक अर्थ है। - एक नाम पर अनेक कार्य । इस विधि से किसी कार्य को पृथक् परिस्थिति में उसी के अनुसार करवा सकते हैं। बहुरूपण हमें समान बाहरी स्ट्रक्चर के आन्तरिक भिन्नता लिए हुए ऑब्जेक्ट्स को प्रयोग करने की सुविधा प्रदान करता है।
संदेश प्रवहन (Message Passing)
Procedure Oriented Programing- Procedure Oriented भाषा की मुख्य कमी यह थी कि इसमें डाटा को कोई भी Function आसानी से बदल सकता था । तथा प्रोग्रामिंग का मुख्य केन्द्र Function अथवा प्रोसीजर होता है। अतः भाषा कि इस कमी को दूर करने के लिये ऑब्जेक्ट प्रवृत्त प्रोग्रामिंग (Object Oriented Programming) भाषा विकसित की गई। OOPs में डाटा को महत्वपूर्ण माना गया है। तथा कोई बाहरी Function आकस्मिक रूप से इसे नहीं बदल सकता । OOPs में डाटा और Function एक दूसरे से बंधे होते है। तथा डाटा के साथ वाले Function ही इन्हें उपयोग कर सकते है। ऑब्जेक्ट प्रवृत्त प्रोग्रामिंग (Object Oriented Programming) किसी समस्या को कई तत्वों में विभाजित करता है। जिसे ऑब्जेक्ट कहते है। तथा यह फिर उन Object के चारों ओर डाटा तथा Function का निमार्ण करता है।
प्रोग्राम नियन्त्रण (Control Statement)
प्रत्येक प्रोग्रामिंग भाषा में प्रोग्राम को नियन्त्रित करने की सुविधा होती है। प्रत्येक प्रोग्रामिंग भाषा में प्रोग्रम को नियन्त्रित करने के लिए विशेष कमाण्ड्स का प्रयोग होता है। प्रोग्राम को नियन्त्रित करने के लिए अधिकतर कमाण्ड्स प्रोग्रामिंग भाषा ‘सी’ से ली गई हैं। ये कमाण्ड्स दोनों प्रोग्रमिंग भाषाओं में समान रूप से प्रयोग की जाती हैं।
प्रोग्राम को विभिन्न परिस्थितियों में भिन्न भिन्न प्रकार से चलाया जाता है। सामान्यतः किसी प्रोग्राम में निर्णय उसी प्रकार लिए जाते है, जिस प्रकार हम अपने जीवन में निर्णय लेते हैं। प्रोग्रमिंग भाषा ‘सी++’ में प्रोग्राम को नियन्त्रित करने के लिए निर्णयात्मक स्टेटमेंट्स (Sensitive Statement) का प्रयोग किया जाता है।
निर्णयात्मक स्टेटमेंट (Decision Statement)
निर्णयात्मक स्टेटमेंट प्रोग्रमिंग भाषा ‘सी++’ में लिखे गए प्रोग्राम का ऐसा भाग होता है, जिसमें दिए गए निर्देश (Statement) का पालन करने की एक से अधिक परिस्थितियां हो सकती हैं। निर्देश में वर्णित प्रत्येक परिस्थिति के लिए स्पष्ट निर्देश दिए होते है। ताकि जैसी भी परिस्थिति हो वैसा निर्णय लेकर प्रोग्राम आगे बढ़ता है। प्रोग्रामिंग भाषा ‘सी++’ में निर्णयात्मक स्टेटमेन्ट निम्नलिखित चार प्रकार के होते हैं-
if स्टेटमेन्ट
Conditional Operator(?) स्टेटमेन्ट
switch स्टेटमेन्ट
go to स्टेटमेन्ट
if स्टेटमेन्ट
इस स्टेटमेन्ट का प्रयोग प्रोग्रामिंग भाषा ‘सी++’ के प्रोग्राम्स में सबसे अधिक किया जाता है। इस स्टेटमेन्ट को चयन स्टेटमेन्ट (Selection Statement) भी कहते हैं। प्रोग्रामिंग भाषा ‘सी++’ के प्रोग्राम में निर्णय लेने के लिए if स्टेटमेन्ट का प्रयोग किया जाता है। इस की वर्ड को अंग्रेजी में वर्णमाला के lower case में ही प्रयोग किया जाता है
Conditional Operator (? :)स्टेटमेन्ट
प्रेाग्रामिंग भाषा ‘सी++’ में Conditional Operator जिसको कि (? :) द्वारा दर्शाया जाता है, का प्रयोग भी if……else की भांति किया जा सकता है। इसको लिखने का तरीका छोटा होने के कारण इसका प्रयोग अधिक प्रयोग किया जाता है।
गुम्फित (nested) if……else स्टेटमेन्ट
जब किसी if…… else स्टेटमेन्ट के अन्दर एक अथवा एक से अधिक अन्य nested if…… else स्टेटमेन्ट का प्रयोग किया जाता है, तो उन्हें गुम्फित (Nested) if…. else स्टेटमेन्ट्स कहा जाता है nested का शाब्दिक अर्थ है, शरण लेना अतः (Nested) if…. else स्टेटमेन्ट को इस प्रकार भी कहा जा सकता है कि जब किसी if…...else स्टेटमेन्ट में अन्य एक से अधिक if…. else स्टेटमेन्ट्स शरणागत होते हैं तब इन सभी को गुम्फित (nested if ........else) स्टेटमेन्ट्स कहा जाता है।
Example
//Program for if …. else statement
#include <iostream.h>
#include <conio.h>
void main ()
{
int a,b,c;
cout<<”enter any two numbers “;
cin>>a>>b;
if(a>b)
cout<<”\nA is greater “<<a;
else
cout<<”\nB is greater “<<b;
getch();
}
Example
//Conditional statement ?:
#include<iostream.h>
#include<conio.h>
void main()
{
int a,b,c;
cout<<”enter any two numbers “;
cin>>a>>b;
c=(a>b? a : b)
cout<<”\n greater “<<c;
getch();
}
Switch Statement
कभी-कभी किसी प्रेाग्राम में if…else स्टेटमेन्ट अथवा else....if स्टेटमेन्ट का गुम्फित (Nested ) रूप इतना जटिल हो जाता है कि प्रोग्रामर स्वयम् भी शर्तों के पूर्ण होने पर अथवा अपूर्ण रहने पर होने वाले कार्यान्वयन के मध्य भ्रमित - सा रह जाता है।
ऐसी परिस्थितियों में प्रोग्रमिंग भाषा ‘सी++’ में switch स्टेटमेन्ट की सुविधा दी गयी है, अर्थात जब सामने किसी एक शर्त के अनेक विकल्प होते हैं। और प्रत्येक विकल्प के लिए भिन्न - भिन्न कार्यान्वयन होना होता है, तो switch स्टेटमेन्ट का प्रयोग किया जाता है । switch स्टेटमेन्ट में की-वर्ड switch के बाद ( ) braces में उस परिवर्तनांक का नाम देते हैं जिस परिवर्तनांक का मान case के अनुसार fixed करना है।
Example:
//Switch Statement
#include<iostream.h>
#include<conio.h>
void main()
{
int marks,index;
cout<<”\n\t Enter marks: ”;
cin>>marks;
index=marks/10;
switch(index)
{
case 10:
cout<<"Excellent ";
break;
case 9:
cout<<" Honours ";
break;
case 8:
cout<<”\n Very Good”;
break;
case 7:
cout<<"Good ";
break;
case 6:
cout<<”\nFirst Division”;
break;
case 5:
cout<<”\nSecond division”;
break;
case 4:
cout<<”\nThird Division”;
break;
default :
cout<<”\n Fail”;
}
}
goto स्टेटमेंन्ट
कभी -कभी यह आवश्यक हो जाता है कि प्रोग्राम के कार्यान्वयन के दौरान, प्रोग्राम के सामान्य कार्यान्वयन को छोड़कर प्रोग्राम के किसी और भाग में जाना होता है, ऐसी स्थिति में go/goto का प्रयोग किया जाता है। यह एक बिना शर्त की ब्रांचिंग प्रक्रिया है। प्रोग्राममिंग भाषा ‘सी++’ में यह स्टेटमेन्ट नियन्त्रण के स्थानांतरण के काम आता है। जहां पर हमें प्रोग्राम का स्थानाान्तरण करना होता है। वहां हम एक lable प्रयोग करते हैं। Lable के आगे colon (:) लगाना आवश्यक होता है। Keyword goto के बाद उस label का नाम प्रयोग किया जाता है। लेबल का नाम प्रोग्रमिंग भाषा ‘सी++’ में प्रयोग किए जाने वाले की -वर्ड्स के अतिरिक्त कुछ भी हो सकता है। सामान्यतः label की लम्बाई आठ अक्षर अथवा इससे कम होती है। Label में परिवर्तनांक के नाम के लिए प्रयोग सामान्य नियमों का पालन किया जाता है।
Example:
#include<iostream.h>
#include<conio.h>
void main()
{
int a,b,c;
clrscr();
cout<<”Enter any two numbers “;
cin>>a>>b;
if(a>b)
{
goto x;
x:
cout<<”A is greater “;
}
else
{
goto y;
y:
cout<<”B is greater “;
}
getch();
}
for स्टेटमेन्ट
सूत्र- for (first_part;seconfd_part;third_part)
Block Of Statements
Exit() Function
किसी लूप में break स्टेटमेन्ट का प्रयोग करके उस लूप से सशर्त बाहर तो आ जाते हैं। परंतु प्रोग्राम से बाहर नहीं आ पाते। प्रोग्राम से बाहर आने के लिए प्रोग्रामिंग भाषा सी++ में एक स्टैण्डर्ड Function exit () का प्रयाोग किया जाता है। इस Function के द्वारा कम्पाइलर सीधा प्रोग्राम से बाहर आ जाता है।
Example:
#include<iostream.h>
#include<conio.h>
void main()
{
int i;
for(i=1;i<=10;i++)
{
cout<<”\n”<<i;
}
getch();
}
While loop यह दी गई (Condition) के सत्य रहने तक इसकी लूप बाॅडी (Loop Body) के कथनों के क्रियान्वयन (Execution) को दोहराता रहता है। शर्त के असत्य होने पर लूप समाप्त हो जाता है,इसे लूप Exit कहते है।
While लूप का प्रारूप:
|
while(Condition)
{
Statements;
}
Ex:
#include<iostream.h>
#include<conio.h>
void main()
{
int a;
clrscr();
while (a<=10)
{
cout<<””\n”<<a;
a=a+1;
}
getch();
}
Do-While loop (The Do -While Loop)- Do-While Loop
इसकी लूप बाॅडी में लिखे कथनों को क्रियान्वित करके शर्त को जाँचता है। यह क्रम तब तक दोहराया जाता है। जब तक शर्त सत्य (True) रहती है। इस प्रकार Do While लूप बाॅडी कथनों को कम से कम एक बार क्रियान्वित करता है। यह शर्त लूप बाॅडी के बाद जाँचता है। अतः यह पोस्ट -टेस्टेड (Post Tested) लूप कहलाता है।
Do While लूप का प्रारूप:
Do
{
Statement 1;
}
While<Condition True>;
Statement 2;
Ex.
#include<iostream.h>
#include<conio.h>
void main()
{
int a;
clrscr();
do
{
cout<<”\n”<<a;
a=a+1;
}while (a<=10);
getch();
}
Structure of C++
C Programing भाषा या C++ Programing भाषा में लिखे जाने वाले Programming को Execute करने के लिये, उसमें एक main() Function का होना अत्यंत होना आवश्यक है। एक प्रोग्राम फाइल में एक से अधिक main() Function नहीं हो सकते। यह एक प्रयोगकर्ता द्वारा परिभाषित Function (User Define Function) है। main( ) Function को शुरू '{' Brace द्वारा तथा समाप्त }brace द्वारा किया जाता है। प्रोग्राम फाइल के Execution के समय { यह बताता है कि Execution यहां से शुरू होना है और } यह बताता है कि Execution यहां समाप्त होना हैं एक प्रोग्राम में main() Function तो एक ही रहता है। परंतु अन्य function का प्रयोग किया जा सकता है। प्रत्येक Function के लिये { और } के मध्य स्टेटमेन्ट्स दिये जाते है।
प्रत्येक प्रोग्राम में इस main( ) Function के साथ कुछ फाइल, जिन्हे include files अथवा हैडर (Header Files) जाता है, को भी अपने प्रोग्राम में सम्मिलित करना होता है। ये फाइल्स C++ की मानक लाइब्रेरी (Standard Library) की भांति प्रयोग होती है। C++ में Input तथा Output के कार्य में समान रूप से सहायक हैडर फाइल एक ही-iostream.h अतः प्रोग्राम में इस फाइल को main( ) Function से पहले include करना होता है।
Example
Creating The Source Files, Compiling And Linking
(1) C++ सोर्स कोड लिखनाः
जब किसी C++ प्रोग्राम के लिये Source Code तैयार करते है,तब इसे भी टेक्स्ट एडिटर में टाईप कर उस फाइल को plain टेक्स्ट के रूप में सुरक्षित करते हैै C++ प्रोग्रामिंग में दो प्रकार की सोर्स कोड फाइल प्रयुक्त होती है -इंटरफेस फाइल (इसे हेडर फाइल भी कहा जाता है) और Application File (इसे सोर्स फाइल भी कहा जाता है।)
(1) C++ header file के लिये स्टेण्डर्ड file एक्सटेंशन .h जबकि C++ के लिये स्टेडर्ड फाईल एक्सटेंशन .cpp है।
(2) Source File को कम्पाईल एवं लिंक करना
जिसे प्रोग्राम का कम्पाईलर (Complier) कहा जाता है। वह कम्पाईलिंग का कार्य करता है। एक अन्य प्रोग्राम,जिसे लिंकर (linker) कहा जाता है। प्रोग्राम के लिये आवश्यक कम्पाइलर Object फाईलों को लिंक करता हैं
C++ Compiler सोर्स कोड पर कई बार प्रोसेस करता है। और प्लेन टेक्स्ट सेार्स फाइल को बायनरी Object Code में परिवर्तित करता है। इसका फाईल एक्सटेंशन सामान्यतः a.obj अथवा a.o होता है। आब्जेक्ट कोड फाइल में मशीन कोड होता है।लिंकर सोर्स कोड से कम्पाईल की गई किन्ही भी आब्जेक्ट कोड फाइलो को लेता है और उन्हे प्रोग्राम की आवश्यकतानुसार C++ लायब्रेरी कोड और विशेष को बिल्ड प्रोसेस कहा जाता है।
------------------------------------------------------------------------------------------
Unit – II
सी++ टोकन(C++ Tokens)
जैसा कि जानते हैं कि अक्षरों से शब्द बनते हैं तथा शब्दो से वाक्यों के समूह पैराग्राफ बनता है। इस प्रकार किसी पैराग्राफ में शब्द लघुतम इकाई हैं। इसी तरह सी++ में सबसे छोटी इकाई (Smallest Individual Unit) को टोकन कहते हैं। सी++ में निम्न टोकन होते हैं
1 आइडेंटीफायर्स (Identifiers)
2 की.वर्डस (Keywords)
3 स्थिरांक (Constant)
4 स्ट्रिग्ंस आपरेटर (String Operator)
1 आइडेंटीफायर्स (Identifiers) आइडेंटीफायर प्रोग्राम के द्वारा बनाये गये वेरियेबल (Variables), Function, Arrays, Class के नाम होते है। ये किसी भाषा की मूलभूत आवश्यकता है जिसके नाम निधार्रित करने के लिये अपने नियम होते हैं ये निम्नलिखित है।
- यह वर्णमाला के अक्षर,अंक तथा अंडरस्कोप (Underscore) होते है।
- इनके नाम अंक से प्रारंभ नहीं होते है।
- आइडेंटीफायर के नाम में छोटे और बडे़ अक्षर भिन्न होते है। उदाहरण Total, Total तथा total
- अनके नाम के मध्य कोई रिक्त स्थान नही होने चाहिए।
2 की-वर्ड (Underscore) C++ भाषा के वे आरक्षित शब्द जिनके प्रयोग द्वारा इस भाषा के कथन व निर्देश लिखे जाते है। की-वर्ड(Keyword) कहलातें है।
asm double new switch
auto else operator template
case enum private this
catch flow public try
char for register typedef
class friend return union
const goto short unsigned
continue if signed virtual
default inline sizeof void
delete int static volatile
do long struct while
;3 स्थिरांक (Variable) वे संख्याऐं, शब्द या चिन्ह जिनका मान प्रोग्राम के सम्पूर्ण क्रियान्वयन (execution) के दौरान परिर्वतित नही होता है, स्थिरांक (Variable) कहलाते है।
सांकेतिक स्थिरांक (symbolic constant)- C++ (symbolic constant) को दो प्रकार से बनाया गया है
;1 constant qualifier का उपयोग करके।
;2 enum की-वर्ड का उपयोग करके ।
उपर्युक्त दोनो प्रकार से integer constant के समूह को घोषित कर सकते है। Constant के मान को प्रोग्राम क्रियान्वयन के समय बदला नहीं जा सकता है। C++ में constant का उपयोग निम्न प्रकार से
किया जा सकता हैः
const int size=15;
char name(size);
Integer Constant को Enum keyword द्वारा भी बनाया जा सकता है। उदाहरण के लिए कोई तीन constant x, y, z का निर्माण करना है तथा इन्हे 0,1,2 का मान क्रमश प्रदान करना हैं तब निम्न statement देंगेः
enum{x,y,z};
मूलभूत डाटा टाईप (Basic Data Types)
प्रत्येक प्रोग्राम में उपयोग किये जाने वाले डाटा कई प्रकार के हो सकते हैं,जैसे अंकीय, शाब्दिक आदि। C++ में डाटा अलग-अलग हो सकते हैं , अर्थात C++ में डाटा टाईप बेहद संख्या में उपलब्ध होते है। सी++ के मूलभूत डाटा टाईप जिन्हें पूर्व निर्मित (built in) भी कहते हैं वे integer, floating point और character type हैं। इनका संक्षिप्त विवरण निम्न हैः
(a) इंटीजर टाईप (Integer Type)
(b) फ्लोटिंग पाइंट (Floating Point)
(c) करेक्टर टाईप (Character Type)
(a) Integer Type इस टाईप में वे पूर्णाक संख्याये होती हैं जिनमे दशमलव बिन्दु का प्रयोग न किया गया हो। उदाहरणः528, 28, 22935 इसमे - 32768 से +32767 तक की value होती हैं। इससे अधिक सीमा के लिये long int का प्रयोग किया जाता है।
(b) Floating Point यह दशमलव युक्त वास्तविक संख्याओ के लिये हैं। ये संख्याँए मात्राओं के मापन में प्रयुक्त होती हैं । उदाहरणः 33.23, -23.3,153.00 इनकी सीमा 10. 38 से 10.38 होती हैं। यद्यपि double data type से 10.38 से 10.308 की सीमा में Floating Point संख्याए प्रयुक्त करते है।
(c) Character Type - ये वर्णमाला के एक अक्षर,अंक या विशेष चिन्ह को सिंगल कोट में बंन्द करके प्रयुक्त किये जाते हैं । उदाहरणः 'P' , '&'
डाटा टाईप (Data Types)
C++ भाषा के प्रोग्राम में प्रयुक्त किये जाने वाले डाटा के मूलभूत प्रकार-इंटीजर टाईप फ्लोटिंग पाइंट होते हैं। इन सभी टाईप को एक श्रेणी में रखा गया हैं, जिसे प्राथमिक डाटा टाईप कहते है।
Data Type |
Meaning |
Byte |
|
Char |
Character |
1 |
|
Int |
Integer |
2 |
|
Float |
Floating |
4 |
|
Double |
Long Value |
8 |
|
Void |
Null Value |
0 |
डाटा टाईप के इन पाँच प्रकारो का आगे विस्तार करके C++ भाषा में प्रयुक्त किया जाता हैं। डाटा टाईप को नया रुप देकर इनकी सीमा और गुणधर्म में विस्तार करने पर प्राप्त डाटा टाईप, टाईप माडीफायर (Type Modifier) कहलाता हैं।
यूजर परिभाषित डाटा टाइप (User Defined Data Type) को मूल या आधार -डाटा के अतिरिक्त अन्य दूसरे डाटा टाइप की अवश्यकता होती है। Basic Data Type में एक ही प्रकार के Data Type संग्रहित होते है। जैसे- int, float आदि। इसके लिये User Defined Data Type बनाते है।
स्ट्रक्चर तथा यूनियन (Structure & Union)
इस प्रकार का उपयोग एक की परिवर्तनांक को प्रयोग करने के लिये करते है।
Class Class भी एक User defined data type है। Class को Basic Data Type की तरह प्रयोग कर परिवतनांक बना सकते है। Class Type के जो परिवर्तनांक बनते है। उन्हे Object कहते है।
व्युत्पन्न डाटा टाइप (Derived Data Type)
ऐरे(Array) - एक समान डाटा आइटमों का एक समूह जिसका एक ही नाम हो ऐरे कहलाता है। ऐरे एक वेरियेबल होता है। जो मेमोरी में एक से अधिक स्थितियो को व्यक्त करता है।
ऐरे में संग्रहीत स्थिरांक या डाटा आइटम ऐरे कहलाते है। वह ऐरे जिसमें केवल एक ही Subscript हो एकलविमीय ऐरे कहते है। जबकि ऐसा ऐरे जिनमें दो subscript का प्रयोग किया जाता है,द्विविमीय ऐरे कहते है।
पाॅइंटर (Pointer)
C++ में, सी में प्रयुक्त किये जाने वाले प्वाइंटर के अतिरिक्त Constant Pointer तथा Constant के लिये प्वाइंटर के नियम भी लागू होते है।
उदाहरणः int *pr //Integer Pointer
*pr=20; // a में अप्रत्यक्ष रूप से 20 माना गया है।
टाइप कम्पैटिबिलिटी (type compatibility)- C++ में C की अप्रेक्षा type compatibility के नियम का कड़ाई से पालन करना पड़ता है । उदाहरण के लिए के लिए C++ मे int, short int, अथवा long int तीनों अलग अलग प्रकार के है। अतः इनका मान एक दूसरे को प्रदान करने से पहले इनके मान को देना होगा । इसी तरह char , unsigned char, signed, char भी अलग -अलग प्रकार के है यह प्रतिबंध जरूरी है ताकि function Overloading की जा सकें क्योंकि दो function जिनके मान समान हो, उनके argument के आधार पर ही उन दोनों का अलग-अलग तरह के उपयोग कर सकतें है।
वेरियेबल्स (Variable)
मेमोरी में स्थितियोंके वे नाम जिनका मान प्रोग्राम के क्रियान्वयन (Execution) के दौरान परिवर्तित हो सकता है, वेरियेबल कहलाते है। वेरियेबल का नाम (Variable Name) मेमोरी की स्थितियों के नाम होते है। ये मेमोरी के स्थान करेक्टर, इंटीजर, फ्लोटिंग पाॅइंट आदि टाइप के स्थिरांक कर सकते हैं क्योकि जिस टाइप का स्थिरांक होता है, उसी टाइप का वेरियेबल उसे मेमोरी में संग्रहीत कर सकता है।
Declaration of Variable वेरियेबल का टाइप घोषित करने की क्रिया वेरियेबल डिक्लेरेशन (Variable Declaration) कहलाती है। जिसका प्रारूप निम्न प्रकार है-
Data Type Variable Name
Or
Data Type Variable1, Variable2 .........;
उदाहरणः
int i;
float num;
int k=10, m=50;
नोटः वेरियेबल डिक्लेयर करते समय उन्हे स्थिरांक भी एसाइन कर सकते है।
परिवर्तनांक का डायनामिंक इनिशियलाइजेशन (Dynamic Initialization of Variable)
"C" में variable स्थिरांक व्यंजक के साथ ही Initialize होता है। Compiler Initialization Code Compilation के समय तय करता है। जबकि "C++" में कम्पाइलेशन के समय ही वेरियेबल के इनिशियलाइजेशन का प्रावधान है। इस क्रिया को गतिक इनिशियलाइजेशन कहते है। C++ में वेरियेबल को क्रियान्वयन के समय घोषणा के स्थान पर व्यंजक का प्रयोग कर इनिशियलाइज किया जा सकता है।
उदा
........
int a= strlen(String)
.................................
float si = 1.5 *a*b;
Variable का डिक्लेयरेशन तथा इनिशियलाइजेशन दोनो एक ही समय, जहाॅ वेरियेबल का पहली बार प्रयोग हो रहा है,किया जा सकता है।
float avg;
avg=sum/n;
रिफ्रेन्स वेरियेबल (Reference Variable)
C++ में पहले वेरियेबल को एक उपनाम (Alias) दिया जा सकता है। मान लीजिए पहले कोई परिवर्तनाॅक avg बनाया है। तथा उसे एक और नाम Average प्रदान कर दिया है। उस स्थिति में Average तथा mean दोनों नाम का प्रयोग कर सकते है।जैसे एक आदमी का नाम अमन है,और उसे "बाबा" नाम से भी पुकारते है।
Data Type & Reference_name = variable name;
float avg = 3.14;
float avg_num = avg;
ऑपरेटर क्या है ?
किसी भी प्रोग्रामिंग भाषा में प्रयोग किए जाने वाले ऑपरेटर्स वे संकेत होते हैं, जो कि कम्प्यूटर को गणितीय अथवा तार्किक संगणनाएं करने के लिए निर्देशित करते हैं। प्रोग्रामिंग भाषा C तथा C++ में ऑपरेटर्स का विशेष उपयोग है। ‘सी’ प्रोग्रामिंग भाषा में भी ऑपरेटर का प्रयोग गणना करने , निर्णय लेने के लिए ही किया जाता है। ऑपरेटर का प्रयोग परिवर्तनांक अथवा संख्याओं के साथ किया जा सकता है।
ऑपरेटर के प्रकार
प्रोग्रमिंग भाषा C++ मे प्रोग्रमिंग भाषा C के समान ही निम्नांकित आठ प्रकार के ऑपरेटर होते है।
अंकगणितीय ऑपरेटर (Arithmetic Operator)
- अंकगणितीय ऑपरेटर्स का प्रयोग आंकिक गणनाओं के लिये किया जाता है प्रोग्रमिंग भाषा '++' में निम्नांकित पांच प्रकार के होते है।
ऑपरेटर
+ जोड़ (addition)
- घटा (Subtraction)
* गुणा (Multiplication)
/ भाग (Division)
% भाग-अवशेष (Modulus Division)
2.संबंध परक ऑपरेटर्स (Relational Operator)
जब दो संख्याओ में असमानता अथवा समानता प्रकट करते हुए लिखना होता है,तब संबंध सूचक ऑपरेटर का प्रयोग करते है।
pr = -a का पता pr में संकलित
Operator Mathematical Symbol 'C' Symbol
Equal to = ==
Not equal to /= !=
Less Then < <
Greater Then > >
Less Then Equal to <= <=
Greater Then Equal to >= >=
3.तार्किक ऑपरेटर (Logical Operator)
एक से अधिक सम्बन्धसूचक ऑपरेटर का प्रयोग करने के लिए तार्किक ऑपरेटर का प्रयोग किया जाता है। ‘सी ++’ में तार्किक ऑपरेटर तीन प्रकार के होते है- -&&(And), || (OR) तथा !(Not)
एसाइमेन्ट ऑपरेटर (Assignment Operator)
जब हम किसी परिवर्तनांक को मान प्रदान करते है। तो हम एसाइन्मेंट ऑपरेटर का प्रयोग करते है। ‘सी’ प्रोग्रमिंग भाषा में यह ऑपरेटर ( = ) है।
int a = 10;
int b = 100;
4. इन्क्रीमेट तथा डिक्रीमेंट ऑपरेटर्स (Increment and Decrement Operator)
जब हमें किसी परिवर्तनांक में से एक घटाना अथवा एक जोड़ना हो तो हम इन्क्रीमेंट और डिक्रिमेंट ऑपरेटर का प्रयोग करते हैं। ‘सी++’ में यह ऑपरेटर ‘- -’ और ‘++’ में दर्शाए जाते हैं। इस ऑपरेटर में यह ध्यान रखना चाहिए कि यह ऑपरेटर परिवर्तनांक से पहले प्रयोग करना है अथवा बाद में, क्योंकि स्थान बदलने से इनका स्वभाव बदल जाता है। पहले प्रयोग किए जाने वाले इन्क्रीमेंट अथवा डिक्रीमेंट ऑपरेटर को pre increment operator अथवा pre decrement operator तथा बाद में प्रयोग किए जाने वाले post increment operator अथवा post decrement operator कहा जाता है।
5.सशर्त ऑपरेटर्स (Conditional Operator)
प्रोग्रमिंग भाषा ‘सी++’ में सशर्त ऑपरेटर ‘‘?’’ है यह पोस्ट स्टेमेंट का संक्षिप्त रूप है। जो स्टेटमेंट एक लाइन में लिखा जा सकता है। यदि यह लिखना है-
if(x!=y)
cout<<x;
else
cout<<y;
इन चार लाइन्स के स्टेटमेंट को सशर्त ऑपरेटर की सहायता से निम्न प्रकार, एक लाइन में भी लिख सकते हैं- x=(x!=y) ? x:y;
इस ऑपरेटर के प्रयोग द्वारा लिखे गए स्टेटमेंट से भी वही परिणाम प्राप्त होता है जो कि कई लाइन्स में लिखे गए परिणाम से स्टेटमेंट द्वारा प्राप्त होता है। सूत्र- Condition ? true : false;
#include<iostream.h>
#include<conio.h>
void main()
{
int a,b,c;
clrscr();
cout<<"Enter any two number ";
cin>>a>>b;
c=(a>b)?a:b;
cout<<c;
getch();
}
6.बिटवाइस ऑपरेटर्स (Bitwise Operator)
इस ऑपरेटर का प्रयोग बिट के जांचने और बिट को दाएं अथवा बाएं हटाने के लिए प्रयोग किया जाता है। विभिन्न बिटवाइस ऑपरेटर्स है।
बिटवाइस ऑपरेटर का प्रयोग integer ( ) प्रकार के परिवर्तनांकों में ही किया जाता है।
इस प्रोग्राम भाषा में कुछ विशेष प्रकार के अन्य ऑपरेटर्स का प्रयोग भी किया जाता हैै, जिनमें से मुख्य निम्न वर्णित हैं-
sizeof ( ) Operator
इस ऑपरेटर का प्रयोग किसी परिवर्तनांक , अक्षर संख्या अथवा किसी विन्यास द्वारा प्रयुक्त बाईट का पता लगाने के लिए किया जाता है।
7.Comma कोमा ऑपरेटर्स
इस ऑपरेटर का प्रयोग एक जैसे परिवर्तनांकों को घोषित करने के लिए किया जाता है। एक से अधिक परिवर्तनांकों को घोषित करने का कार्य अथवा इन परिवर्तनों को मान प्रदान करने का कार्य इस ऑपरेटर द्वारा एक ही लाइन में कर सकते हैं। इस ऑपरेटर का प्रयोग से प्रोग्राम आकार में छोटा हो जाता है।
सी++ के अन्य मुख्य ऑपरेटर्स
प्रोग्रमिंग भाषा में C++ ऑपरेटर्स का महत्वपूर्ण स्थान है, इसमें अनेक ऑपरेटर्स सम्मिलित किए गए हैं। अभी तक जिन ऑपरेटर्स का अध्ययन किया है, प्रोग्रमिंग भाषा ‘सी’ एवं ‘सी++’ दोनों में समान रूप से प्रयोग किए जाते हैं, परन्तु ‘सी++’ में कुछ नए ऑपरेटर्स भी समाहित किए गए हैं,अब इनके बारे में जानकारी प्राप्त करंगे।
8. स्कोप रिजाॅलूशन (::) ऑपरेटर (Scope of Resolution Operator ::)
C++ Object Oriented Programming भाषा के साथ-साथ structure Language भी है। एक ही नाम के परिवर्तनांक को अलग-अलग block में प्रयोग कर सकते है। परिवर्तनांक का मान block के अंदर परिवर्तित रहता तथा जब क्रियान्वयन block के बाहर आता है है। तब परिवर्तनांक मान नष्ट हो जाता है। अतः जो परिवर्तनांक मान नष्ट हो जाता है। अतः जो परिवर्तनांक block के अंदर घोषित किये जाते है। उन्हे स्थानीय परिवर्तनांक कहते है।
उदाहरण में परिवर्तनांक दो अलग-अलग memory location का प्रयोग कर रहा है। जिसमें अलग-अलग मान संग्रहित है। कई बार ग्राफिक block का भी प्रयोग करना पड़ता है।
9. मेम्बर डिफ्रेनशिएटिंग ऑपरेटर (Member Differentiating Operator)
C++ विभिन्न क्लास में विभिन्न प्रकार के डाटा और function member के रुप में होते हैं C++ में class member तक पहुचने के लिए pointer का भी प्रयोग किया जा सकता हैं। C++ भाषा में इस तरह के तीन pointer to member ऑपरेटर होते हैंः
..* class के member को pointer के रुप में घोषित करने के लिए।
Object का नाम तथा उस सदस्य के प्वाइंटर का प्रयोग करके उसके member तक पहुचने के लिए।
10. मेमोरी मैनेजमेन्ट ऑपरेटर (Memory Management Operator)
C में क्रियान्वयन के समय memory dynamically प्रदान करने के लिए malloc () तथा calloc( ) function का प्रयोग करते है सी++ मे उपरोक्त function के साथ दो और unary operator new तथा delete का प्रयोग किया जा सकता हैं। new तथा delete ऑपरेटर का प्रयोग किया जाता है।
new :- का प्रयोग करके आब्जेक्ट का निर्माण किया जा सकते है तथा delete के प्रयोग से इसे नष्ट किया जा सकता हैं।
Pointer variable = new data type
m=new int;
n = new float;
delete pointer-varible
delete m;
delete n;
end, setw (manipulators)
प्राग्रामिंग भाषा ‘सी++’ डेटा आउटपुट को अपनी इच्छा एवं आवश्यकतानुसार डिजाइन करने के लिए इन ।ऑपरेटर्स का प्रयोग करते हैं। ऑपरेटर्स endl का कार्य लाइन का अन्त दर्शाना तथा कर्सर को अगली लाइन में ले जाना है यह ऑपरेटर ठीक उसी प्रकार कार्य करता है, जिस प्रकार बैकस्लेश अक्षर स्थिरांक /n कार्य करता है । पिछले पृष्ठ पर दिए गए बाईं ओर वाले उदाहरण प्रोग्राम प्रयोग किया गया है तथा दोनों के कार्य की समानता को दर्शाया गया है ।
ऑपरेटर endl अथवा बैकस्लैश अक्षर स्थिरांक /n के द्वारा प्राप्त आउटपुट सदैव स्थिति left align होता है । जो कि अंकों को लिखने की आदर्श स्थिति नहीं होती है। अंकों को आदर्श स्थिति में लिखने के लिए अर्थात् right align करने के लिए ऑपरेटर्स setw का प्रयोग किया जाता है।
11. टाइप कास्ट ऑपरेटर (Type Cast Operator)
C++ में परिवर्तनांक तथा expression का type cast operator द्वारा data type परिवर्तित किया जा सकता है।
Syntax- type name(expression);
avg=total/float(c)
Expression And Implicit
व्यंजक (Expression) व्यंजक operator स्थिरांक तथा परिवर्तनांक का समूह होता है। जो भाषा के नियम का पालन करते है। उन्हे expression कहते है।
(1) स्थिरांक व्यंजक (Constant Expression) इसमें केवल स्थिरांक मान होते है।जैसे-
15
10+25
'a'
(2) पूर्णाक व्यंजक (Integer Expression) जिस Expression का परिणाम integer आता हो, उसे integer expression कहते हैं जैसे-
a+b
10+int(5.2)
(3) फ्लोट व्यंजन (Float Expression) जिस Expression का परिणाम floating point आता हैं,उसे float expression कहते है।
a+b
10+float(5)
ans 15.0
(4) प्वाइंटर व्यंजक (Pointer Expression) जिस expression का परिणाम address तथा value में प्राप्त होता है,उसे pointer expression कहते है।
&m or ptr or ptr+1 or "abc"
Operator Precedence (Operator की सहचरता एवं प्राथमिकताए)
जब एक से अधिक Operator एक ही स्टेटमेन्ट में प्रयोग करते है,तो यह जानना आवश्यक हो जाता है। कि कौन-सी गणना पहले व कौन-सी गणना बाद में हो रही है। एवं कौन-सी गणना दाएं से बाएं एवं अथवा कौन-सी गणना बाएं से दाएं हो रही है। जिसमें operator की सहचरता का गणनाक्रम एवं प्रथमिकताएं स्पष्ट की गयी है।
Operator Associative
:: Left to Right
( ) [ ] postfix ++ postfix -- Right to Left
unary *unary &(type) Right to Left
sizeof new delete Right to Left
-> ** Left to Right
* % Left to Right
+ - Left to Right
<< >> Left to Right
<= >= Left to Right
नियंत्रक संरचना (Control Structure)
प्रोग्राम निर्देशों का एक समूह होता है। और प्रोग्राम में छोटे से छोटे तथा बड़े से बड़े निर्देश का बराबर का महत्व होता है। प्रोग्रामर, प्रोग्राम को एक विशेष कार्य के लिये तैयार करते है। कम्प्यूटर में यद्यपि स्वयं निर्णय लेने कि क्षमता नहीं होती, परंतु प्रोग्रामरों के निर्देशानुसार कम्प्यूटर उपयुक्त विकल्प का चयन का निर्णय करता हैं। उदाहरण-प्रोग्राम क्रम में चलते हुए एक पंक्ति से आगे कई पंक्तियों को छोड़कर परिस्थितिवश बढ़ जाता हैं तथा उसे विशेष पंक्ति क्रियान्वित करना पडता हैं। प्रोग्राम कथन जो ऐसे निर्देशों का पालन करता हैं नियंत्रक कथन कहलाता हैं।
संरचना के प्रकार (Types of Structure)
प्रोग्राम में निम्नलिखित तीन संरचनाओं का प्रयोग किया गया हैं-
(1) क्रमिक अथवा सीधा (Sequential or Straight)
(2) शाखित अथवा चयन (Branched or Selection)
(3) लूपिंग अथवा पुनरावृत्रि (Looping or Repetition)
(1) क्रमिक एवं सीधा (Sequential or Straight)प्रोग्राम में लिखे गए कथनो का क्रियान्वयन क्रम अनुसार होता हैं। कथन जिस क्रम में कम्पाइलर को प्राप्त होते है। उसी क्रम में वे क्रियान्वित हो जाता है। उसे sequential or straight कहते है।
(2) शाखित क्रियान्वयन (Branched Execution) प्रोग्राम समान्य अवस्था में नियंत्रण या क्रियान्वयन क्रमिक (Sequential) होता हैं। प्रोग्राम के क्रमिक क्रियान्वयन की दिशा चुने हुए (Block of Statement) की ओर कर दी जाए तो इस शाखित क्रियान्वयन (branched execution) कहते है।
(3) लूपिंग या पुनरावृत्ति क्रियान्वयन (Looping or Repetitive Execution) जब एक अनेक कथनो के समूह (यौगिक कथन) को बार- बार दोहराना क्रियान्वित करवाया जाता है। तो इस क्रियान्वयन को लूपिंग या पुनरावृत्ति क्रियान्वयन (Repetitive Execution) कहते है।
Structure
Structure में एक या अधिक डाटा आयटम्स् होते है, जिन्हे मेम्बर कहा जाता है। यह एक इकाई के रुप में संगठित रहते है। एक स्ट्रक्चर में सभी एलीमेन्ट बायी डिफाल्ट पब्लिक होते है। स्ट्रक्चर मे स्पष्ट किये गये function का इसके मेम्बर्स के साथ कोई विशिष्ट संबंध हो भी सकता है, और नही भी। स्ट्रक्चर के लिए सामान्य सिन्टेक्स इस प्रकार है।
struct <user_defined_name>
{
data type member1;
data type member2;
data type membern;
};
इस स्ट्रक्चर मे की-वर्ड typedef की आवश्यकता होती है।
Function:- यह एक प्रकार उप-प्रोग्राम के समान कार्य करता है। प्रोग्रामिंग की प्रक्रिया को आसान तथा प्रोग्राम के कोड को बार बार दोहराने की जरूरत न हो इस लिए function का निर्माण करते है । अतः यदि किसी प्रोग्राम के कोड की बार बार जरूरत पड़ती है, तो function का निर्माण करते है। तथा जरूरत पड़ने पर function call कर लिया जाता है। उदाहरण के लिए यदि simple interest बार बार calculate करना हो तब simple interest का function बनायेंगे । C++ में built in function होते है, अर्थात् उपयोगकर्ता को इसे बनाना नहीं पड़ता तथा उपयोगकर्ता आवश्यकतानुसार user define function का भी निर्माण कर सकता है।
ऑब्जेक्ट को function में प्रेषित करने के लिए निम्नलिखित विधियों में से किसी एक उपयोग किया जाता है-
1. Pass by Value ( मान द्वारा प्रेषण ) 2. Pass by Reference ( पते द्वारा प्रेषण)
मान द्वारा प्रेषण (Pass by Value)
इस विधि में function को ऑब्जेक्ट की एक प्रति प्रेषित किया जाती है अतः function के अन्दर ऑब्जेक्ट में किये गये संशोधन का प्रभाव उस मूल ऑब्जेक्ट पर नहीं पड़ता है । जिसकी काॅपी प्रेषित pass की गयी ।
Without Class Program (call by value)
#include<iostream>
#include<conio.h>
void main()
{
int a,b;
clrscr();
cout<<"Enter any two numbers ";
cin>>a>>b;
cout<<"Before Swapping ";
cout<<"\n a="<<a<<"\n b="<<b;
void swap(int ,int);
cout<<"After Swapping ";
cout<<"\n a="<<b<<"\n b="<<a;
getch();
}
void swap(int x, int y)
{
int t;
t=x;
x=y;
y=t;
}
Program with Class (pass by value)
#include<iostream.h>
#include<conio.h>
class swap
{
int a,b;
public:
void solve(int, int)
{
int t;
t=a;
a=b;
b=t;
}
};
void main()
{
swap s;
int a,b;
clrscr();
cout<<"\nEnter any two numbers ";
cin>>a>>b;
cout<<"\nBefore Swapping ";
cot<<"\n a="<<a<<"\nb="<<b;
s.solve(a,b);
cout<<"\nAfter Swapping ";
cout<<"\na="<<b<<"\nb="<<a;
getch();
}
रिफ्रेन्स द्वारा प्रेषण (Pass by Reference)
इसमें ऑब्जेक्ट का पता function को प्रेषित किया जाता है । फलस्वरूप, function जो भी कार्य उस ऑब्जेक्ट पर करता है उसका प्रभाव उसके मूल ऑब्जेक्ट पर सीधे-सीधे पड़ता है , तथा साथ ही वह भी संशोधित हो जाता है । रिफ्रेन्स द्वारा प्रेषण ज्यादा सक्षम होता है , क्योकि इसमें पूरे ऑब्जेक्ट को प्रेषित करने के बजाए केवल उसका पता ही प्रेषित होता है ।
Program without class (call by reference )
#include<iostream.h>
#include<conio.h>
void main()
{
int a,b;
clrscr();
cout<<"\nEnter any two numbers ";
cin>>a>>b;
cout<<"\nBefore Swapping ";
cout<<"\na="<<a<<"\nb="<<b;
void swap(int *a,int *b);
swap(&a,&b);
getch();
}
void swap(int *x,int *y)
{
int t;
t=*x;
*x=*y;
*y=t;
cout<<"\na="<<*x<<"\nb="<<*y;
}
Program with class (call by reference )
विन्यास (Array)
जब भी परिवर्तनांकों का उपयोग किया जाता है, तब एक परिवर्तनांक को एक ही मान प्रदान किया है, परन्तु कई बार ऐसी स्थिति आती है कि एक ही प्रकार का परिवर्तनांक बार - बार, अलग - अलग मान लेकर प्रयोग किया जाता है; जैसे एक विद्यार्थी कोई परीक्षा देता है । परीक्षा में प्राप्तांक भिन्न - भिन्न विषयों के लिए भिन्न - भिन्न होंगे । इस स्थिति में विषय के भिन्न - भिन्न परिवर्तनांक लेने होंगे।
int sub1,sub2,sub3,........... sub n;
मुख्यतः तीन प्रकारों में विभाजित किया जा सकता है -
1. एकल-विमीय विन्यास (One-Dimensional Array)
2. द्वि-विमीय विन्यास (Two-Dimensional Array)
3. बहु-विमीय विन्यास (Multi-Dimensional Array)
एकल - विमीय विन्यास (One-Dimensional Array)
ऐसा विन्यास जिसमें केवल एक (subscript) का ही प्रयोग किया जाता है एकल-विमीय विन्यास कहलाता है ।
जैसे - int marks[5];
float avg[30];
char name[15];
#include<iostream.h>
#include<conio.h>
void main()
{
int a[5],i,j;
clrscr();
cout<<"Enter
any 5 numbers ";
for(i=0;i<5;i++)
{
cin>>a[i];
}
cout<<"\n5
Numbers are :\n";
for(i=0;i<5;i++)
{
cout<<a[i];
}
getch();
}
द्वि-विमीय विन्यास (Two-Dimensional Array)
ऐसा विन्यास जिसमें दो Subscripts का प्रयोग किया जाता है, द्वि-विमीय विन्यास (Two–Dimensional Array) कहलाता है ।
जैसे - int num[5][7];
float table[5][5];
Example:
#include<iostream.h>
#include<conio.h>
void main()
{
int a[2][2],i,j;
clrscr();
cout<<"Enter
2*2 matrix :";
for(i=0;i<2;i++)
{
for(j=0;j<2;j++)
{
cin>>a[i][j];
}
}
cout<<"\n2*2
matrix is :\n";
for(i=0;i<2;i++)
{
for(j=0;j<2;j++)
{
cout<<"\t"<<a[i][j];
}
cout<<"\n";
}
getch();}
बहु-विमीय विन्यास (Multi - Dimensional Array)
जब किसी विन्यास में दो या दो से अधिक Subscript का प्रयोग किया जाता है। उन्हें बहु-विमीय विन्यास (Multi - Dimensional Array) कहा जाता है।
जैसे - int three_d[2][3][5];
#include<iostream.h>
#include<conio.h>
void main()
{
int
a[2][2][2],i,j,k;
clrscr();
cout<<"Enter
2*2*2 matrix :";
for(i=0;i<2;i++)
{
for(j=0;j<2;j++)
{
for(k=0;k<2;k++)
{
cin>>a[i][j][k];
}
}
}
cout<<"\n2*2*2
matrix is :\n";
for(i=0;i<2;i++)
{
for(j=0;j<2;j++)
{
for(k=0;k<2;k++)
{
cout<<"\t"<<a[i][j][k];
}
cout<<"\n";
}
}
getch();
}
-------------------------------------------------------------------------------------
UNIT-III
Classes and Object
Class C++ का सबसे महत्वपूर्ण गुण है। कि C++ के अंदर Class के महत्व को इस प्रकार समझा जा सकता है। कि C++ का पहले निर्धारिण किया गया नाम ‘क्लास के साथ रखा गया था । C++ मे Class का प्रयोग सम्भवतः सी में Structure का उन्नत सिद्धांत है। Class User Defined Data Type के निर्माण तथा उसे कार्यान्वित करने का एक नया तरीका भी है। C++ जैसा कि एक सी का ही उन्नत संस्करण है।
क्लास का वर्णन करना (Specifying A Class)
क्लास ड़ाटा तथा इससे संबंधित Function को साथ बाॅधने (Bind) की एक विधी है। यह डाटा को बाहरी हस्तक्षेप से बचाने के उद्देश्य से छिपाने की व्यवस्था भी रखता है।
Class को दो प्रकार से Specify किया जा सकता है।
(A) Class
declaration
(B) Class
Function definition
क्लास घोषणा इसके सदस्यों (Members) के प्रकार तथा क्षेत्र (Scope) को स्पष्ट करता है क्लास फंक्शन परिभषा (Class function definitions) फंक्शन के कार्यन्वयन का वर्णन करता है । क्लास घोषणा (Class declaration) का सामान्य तरीका इस प्रकार है।
class < Class _ name >
{
private:
|
Variable declarations; Function declarations; |
public:
|
Variable declarations; Function declarations; |
};
यूनियन और क्लासेस (Union and Classes)
यूनियन को यूजर डिफाईन डाटा टाईप के रूप में स्पष्ट किया गया है । जिसकी सासाईज एक मेम्बर के रखने के लिये पर्याप्त हैए एक मेम्बर को यूनियन में किसी समय संग्रहित किया जा सकता है । बाॅय डिफाॅल्ट यूनियन के मेम्बर पब्लिक होते है यूनियन में कोई स्टेटिक डाटा मेम्बर नही होते है । यूनियन में कंस्ट्रक्टरर्स और डिस्क्टरर्स के साथ मेम्बर फंक्शन हो सकते है। परन्तु वर्चुअल फंक्शन (virtual function) नही होते है यूनियन में बेस क्लास नही हो सकती हे। एक कंस्ट्रक्टर अथवा एक डिस्ट्रक्टर्स अथवा एक यूजर डिफाइ्रन असाईनमेंट ऑपरेटर के साथ क्लास का एक ऑब्जेक्ट यूनियन का मेम्बर नही हो सकता है । यूनियन में कोई स्टेटिक डाटा मेम्बर नही हो सकता है।
सदस्य फंक्शन (Member Function)
क्लास के अंदर घोषित किये गये सदस्य फंक्शन (member function) कहलाते हैं। सदस्य फंक्शन निजी डाटा सदस्य तथा निजी फंक्शन का प्रयोग कर सकते हैं। किन्तु,सार्वजनिक सदस्य को क्लास के बाहर से एक्सेस किया जाता हैं।
|
private: Variable declarations (data) Function declarations public: Variable
declarations(data) Function declarations
|
प्रवेश प्रतिबंघित
प्रवेश अनुमति
उदाहरण स्वरुप एक सामान्य क्लास घोषणा को देखेगेंः
class sum
{ int number;
float rate;
public:
void getdata(int
n,float r);
void putdata(void);
सदस्य फंक्शन को परिभाषित करना ¼Finding Member Functions)-
क्लास के अंदर की परिभाषा (Inside the Class Definition)
Ex 1.इस उदाहरण में Commodity क्लास के अंदर फंक्शन परिभाषित करेंगें।
//Example of Member Function Definition
//Inside Class Declaration
class sum
{
private:
int a;
float rate;
public:
void getdata(int a,float r);
void putdata()
{
cout<<a;
cout<<r;
}};
bl class में दो public फंक्शन परिभाषित हैं getdata() और putdata()A उल्लेखनीय हैं कि फंक्शन के कोड भी class की परिभाषा में लिख दिये गये हैं। इसके विपरीत यदि फंक्शन आकार में बड़े होते हैं तो उन्हें class की परिभाषा के बाहर परिभाषा करना चाहिए । यद्यपि इस फंक्शन का प्रोटोटाइप class परिभाषा मे लिखना आवश्यक बाहरी फंक्शन को इनलाइन बनाना
(Making an Outside Function Inline):-
आब्जेक्ट ऑरिएन्टेड प्रोग्रामिगं के उददेश्यों में एक यह भी है कि क्लास परिभाषा (Class definition) sum कार्यानवयन के विवरण को अलग रखा जाय । इसीलिए सदस्य फंक्शन की परिभाषा क्लास से बाहर दी जाती है।
सदस्य फंक्शन को क्लास के बाहर परिभाषित कर सकते है तथा इसके लिए फंक्शन परिभाषा के हैडर लाइन पर क्वालिफायर inline का प्रयोग कर इसे inline बना सकते है।
उदाहरण -
#include<iostream.h>
#include<conio.h>
inline int sum(int n, int r) //definition
{
return(n+r);}
void main
int a,b;
clrscr();
cout<<"Enter any two numbers \n
";
cin>>a>>b;
cout<<"\sum ="<<sum(a,b);
getch();
}
सदस्य फंक्शन का नेस्टिंग (Nesting of Member Functions)
हम किसी क्लास के सदस्य फंक्शन को उस क्लास के ऑब्जेक्ट द्वारा डाॅट ऑपरेटर (. Operator) का प्रयोग कर काॅल भी कर सकते है। किन्तु इसका एक अपवाद है। एक सदस्य फंक्शन अपने नाम से उसी क्लास के दूसरे सदस्य फंक्शन के अंदर बुलाया जा सकता है। इसे सदस्य फंक्शन का नेस्टिंग कहते है। इस क्रिया पर पर आधारित इस प्रोग्राम को देखें -
//Program to find out the smaller number
#include<iostream.h>
class number
{
int a,b;
public:
void input(void);
void disp(void);
int smaller(void);
};
int number::input(void)
{ cout<<”input a and b ”<<”\n”;
cin >>a>>b;
}
int number::smaller(void)
{
if(a<b)
cout<<”A is smaller “;
return(a);
else
return (b);
}
void number:: disp(void)
cout<<”smaller number=”<< smaller()<<”\n”; // disp() function call to smaller()function
}
int main()
{
number A;
A.input();
A.disp();
return 0;}
Output a and b
10 and 12
Smaller value 10
निजी सदस्य फंक्शन (Private Member
Function)
प्रोग्राम विकास के दौरान कुछ फंक्शन ऐसे होते है जिन्हें बहुत ही निजी रखने की आवश्यकता होती है । ऐसे फंक्शन को हम प्रोग्राम के निजी भाग में रखते है । निजी सदस्य फंक्शन किसी दूसरे फंक्शन के द्वारा तब ही प्रयोग किया जाता है । जब वह उस क्लास का सदस्य हो। यहां तक कि कोई ऑब्जेक्ट भी निजी फंक्शन को ऑपरेटर की सहायता से कार्यान्वित नहीं कर सकता । उदाहरणस्वरूप इसे देखे-
class temp
{
int n;
void study();
public:
void read();
void write();
};
void main()
{
temp t1;
t1.study();
}
उपरोक्त कथन t1. study कार्य नहीं करेगा क्योंकि study निजी फंक्शन है तथा इसे काॅल नहीं किया जा सकता है। किन्तु कोई फंक्शन जैसे read ( ) के द्वारा प्रयोग मे लाया जा सकता है । जैसे -
void temp :: read(void)
Study(); //
इसमे केवल study को काॅल किया जा रहा है तथा कोई ऑब्जेक्ट प्रयोग नहीं किया जा रहा है।
क्लास में अनुविन्यास (Arrays within A Class)
किसी क्लास में अनुविन्यास (Arrays) इसके डाटा सदस्यों (data members) के रूप में प्रयुक्त (use) किये जा सकते है और ये क्लास की सूचना ऑब्जेक्ट मे से प्राप्त करते है । ऑब्जेक्टों के लिए अधिक मात्रा के डाटा का उपयोग करने के लिये क्लास में अनुविन्यास का प्रयोग किया जाता है। इसके लिए हम निम्नलिखित उदाहरण पर विचार करते है ।
उदाहरण: एक प्रोग्राम लिखना जिसमे किसी item की संख्या (number) और लागत (cost) को इनपुट किया जाये और बाद में इसे आउटपुट में प्रस्तुत किया जाये ।
#include <iostream.h>
#include <conio.h>
class item
{
int quantity[10];
char it_code[10];
float cost[10];
public:
void getdata(void);
void putdata(void);
};
int i,n;
}; void item :: getdata()
{
cout <<”\n Enter total No.of items”;
cin>>n;
for(i=0;i<n;i++)
{
cout<<”\n Enter Item Code:”;
cin>> it_code[i];
cout<<”\n Enter Quantity
of Item:”;
cin>>quantity[i];
cout<<”\n Enter Cost of
Item :”;
cin>> cost[i];
}}
void item :: putdata()
{
for(i=0;i<n;i++)
{
cout
<<”\n Item Ccode=”<< it_code[i];
cout<<”\n
Quantity of Item=”<< quantity[i];
cout<<”\n
total cost=”<< cost[i]*quantity[i];
}}
void main()
{
clrscr();
item x;
x.getdata();
x.putdata();
getch();
}// End of Main Function
ऑब्जेक्ट के लिए मेमोरी आंवटन (Memory Allocation for Objects)
ऑब्जेक्ट के लिए मेमोरी मे स्थान उस समय आवंटित किया जाता हैं जब घोषित करते हैं। यह कथन पूरी तरह सही नही हैं। वस्तुतः सदस्य फंक्शन बनाये जाते हैं ,मेमोरी मे तब ही संग्रहित किये जाते हैं। जब वह क्लास के एक अंग के रूप मे परिभाषित होते है । चूॅंकि सभी ऑब्जेक्ट जो एक विशेष क्लास से सम्बन्धित होते है । एक ही प्रकार के सदस्य फंक्शन का प्रयोग करते है तथा इस कारण सदस्य फंक्शन के लिए ऑब्जेक्ट निर्माण के समय अलग से मेमोरी मे स्थान नहीं बनाये जाते । केवल सदस्य वेरियेबल के लिए प्रत्येक ऑब्जेक्ट के लिए आवंटित किये जाते है यहाॅ पर ऑब्जेक्ट के लिए मेमोरी का आवंटन इसलिए किया जाता है क्योंकि सदस्य वेरियेबल्स विभिन्न ऑब्जेक्ट के लिए विभिन्न मान रखते है ।
स्थायी डाटा सदस्य (Static Data Member)
किसी क्लास के डाटा सदस्य को स्थायी कहा जाता है। स्थायी डाटा सदस्य व सदस्य वेरियेबल के निम्नलिखित गुण है-
इसके क्लास के पहले ऑब्जेक्ट का मान 0 (शून्य) माना जाता है । इसके अतिरिक्त कोई मान की अनुमति नहीं हैं
पूरे क्लास के लिए उस सदस्य की एक प्रति बनाई जाती है। तथा इसे उस क्लास के सभी ऑब्जेक्ट द्वारा साझा किया जाता है। इसके लिए ऑब्जेक्ट की संख्या चाहे जितनी भी हो।
यह केवल क्लास के अंदर दृश्य होता है।
स्थयी डाटा सदस्य व वेरियेबल का प्रयोग पूरे क्लास कें सामान्य मानों को बनाए रखने के लिए किया जाता है । उदाहरणस्वरूप स्थायी डाटा सदस्य एक गणक के रूप मे होता है जो सभी ऑब्जेक्ट के उपस्थिति को रिकार्ड करता है।
निम्नलिखित प्रोग्राम इस के उपयोग को प्रकट करता है ।
# include <iosteram.h>
class item
{
static int counter;
int number;
public:
void getdata(int p)
{
number=p;
counter ++;
}
void getcout()
{
cout<<”count:”;
cout<<counter<<”\n”;
}
};
int item::counter; //difination of static data
int main()
{
item x,y; //count is initialized to
zero
x.getcount(); //display
count
y.getcount();
x.getdata(10);
y.getcount(20);
cout<<”after reading data”<<”\n”;
x.getcount();
y.getcount();
return 0;
}
Output
Count:0
Count:0
After reading data
Count:2
Count:2
उपरोक्त प्रोग्राम में स्थायी वेरियेबल प्रारम्भ में शून्य होता है। जब ऑब्जेक्ट बनता है। Counter में एक की वृद्धि होती है जब डाटा एक ऑब्जेक्ट में दो बार पढ़ा जा रहा है, Counter दो बार वृद्धि होता है क्योंकि Counter की एक प्रति दोनों ऑब्जेक्ट के द्वारा साझा किया जाता है, दोनो आउटपुट कथन 2 मान को प्रदर्शित करते है।
यहाॅं ध्यान देने योग्य बात यह है कि प्रत्येक स्थायी सदस्य डाटा का प्रकार तथा क्षेत्र क्लास परिभाषा के बाहर परिभाषित किया जाना चाहिए । इसकी आवश्यकता इसलिए है क्योंकि स्थायी डाटा सदस्य ऑब्जेक्ट के भाग के रूप में संग्रहित न होकर अलग संग्रहित होते है । स्थायी डाटा सदस्य को क्लास वेरियेबल भी कहते है क्योंकि वे सीधे-सीधे क्लास से ही जुड़े होते है।
स्थायी सदस्य फंक्शन(Static Member function)
स्थायी सदस्य वेरियेबल की तरह, स्थायी सदस्य फंक्शन भी रख सकते है । कोई सदस्य फंक्शन जो स्थायी घोषित किये जाते है, निम्नलिखित गुणों को समाहित करते है-
स्थायी फंक्शन उस क्लास के दूसरे स्थायी डाटा या फंक्शन को एक्सेस कर सकते है ।
स्थायी सदस्य फंक्शन क्लास के नाम से प्रयोग किये जा सकते है जैसे -
निम्नलिखित प्रोग्राम में इन लक्षणों को कार्यान्वित किया गया है । Showcount() स्थायी फंक्शन उस समय तक बने ऑब्जेक्ट की संख्या को प्रदर्शित करता है तथा Counter स्थायी वेरियेबल बनाये गये ऑब्जेक्ट की संख्या की गणना करता है ।
प्रोग्राम -
#include <iosteram.h>
class run
{
int cd ;
static int counter;
public:
void setcd()
{
cd=++counter;
}
void showed()
{
cout<<”object number
:”<<cd<<”\n;
}
static void showcount()
{
cout <<”count:”<<counter
<<”\n;
}
};
int run::counter;
void main()
{
run t1,t2;
t1.setcd();
t2.setcd();
run::showcount();
run t3;
t3.setcd();
run::showcount();
t1.showcd();
t2.showcd();
t3.showcd();
return();
}
उपरोक्त program में यह कथन
Code =++Counter;
क्रियान्वित होता है जब code फंक्शन सक्रिय होता है और code का तत्काल मान code में जमा होता है । चॅूकि प्रत्येक ऑब्जेक्ट के code की अपनी प्रति होती है, code का मान अद्वितीय होता है ।
उपरोक्त प्रोग्राम का परिणाम इस प्रकार होगा -
Count :2
Count :3
Object number:1
Object number:2
Object number:3
ऑब्जेक्ट के अनुविन्यास (Array of Object)
C++ में क्लास, ऑब्जेक्टो के अनुविन्यास को व्यक्त कर सकती है जिससे ऑब्जेक्ट के वेरियेबल में अधिक मात्रा में मान संग्रहित किये जा सकते है और इनका उपयोग Public सदस्य फंक्शन में किया जा सकता है । ऑब्जेक्टो को इनके सूचकांक द्वारा स्थित व प्राप्त किया जाता है जिसका मान डाटा के टाइप के अनुसार होता है । उदाहरणार्थ -
क्लास की इस घोषणा में XX एक क्लास है जिसमें दो Private सदस्य "a" और "e" तथा Public सदस्य accept फंक्शन और give फंक्शन है । XX क्लास के द्वारा ऑब्जेक्टों के अनुविन्यास व्यक्त किये जा सकते है जिससे विभिन्न ऑब्जेक्टों में अधिक मात्रा में मान संग्रहित किये जा सकते है -
XX y {20};
यहाॅ XX क्लास अनुविन्यास y को व्यक्त करेगा, जिससे मेमोरी में 20 डाटा मान Private सदस्य के रूप में संग्रहीत किये जा सकते है । फंक्शन के काॅल करने से ऑब्जेक्टों का मान दिये जाते है, जैसे -
Y{1} .accept( ) ;
यह ऑब्जेक्ट की प्रथम मेमोरी स्थिति में प्रथम सदस्य का मान accept फंक्शन द्वारा प्राप्त करता है । इसी प्रकार मेमोरी की अन्य स्थितियों के लिए ऑब्जेक्ट के अन्य 15 मान भी प्राप्त किये जा सकते है ।
उदाहरण 5 एक प्रोग्राम लिखना जिसमें N संख्या में विद्यार्थियों के रिकार्ड ऑब्जेक्टो के अनुविन्यास में v इनपुट किये जाये और विद्यार्थियों की सूची निम्न प्रारूप छपे - List of Student
Student के रिकाॅर्ड का ढ़ाचा निम्न प्रकार होगा -
|
Name |
Roll No. |
Marks |
विद्यार्थियों को Grade निम्नलिखित नियमों से दिया जायेगा -
|
Marks |
Grade |
|
<200 >=200<240 >=240<320 >=320 |
D C B A |
हल: इसके लिये student नाम का क्लास उपयोग करेंगे, जिसमे विद्यार्थी का records संग्रहीत होगा औंर डाटा इनपुट करने के लिए, Grade की गणना करने के लिए एवं विद्यार्थी के डाटा प्रदर्शित करने के लिए उचित फंक्शन उपयोग करते है ।
क्लास का प्रारूप निम्न प्रकार होगा -
Student |
|
Name Roll
No. Marks Grade Read_data( ) computer_grade( ) display_data( ) |
#include<iostream.h>
#include<conio.h>
class emp
{
char name[30];
float salary;
public:
void getval();
void putval();
};
void emp::getval()
{
cout<<”\ntenter name:”;
cin>>name;
cout<<”\nt enter salary:”;
cin>>salary;
}
void emp::putval()
{
cout<<”\n\tName:”<<name;
cout<<”\n\tSalary:”<<salary<<”\n”;
}
const int size=2;
void main()
{
emp worker[size];
clrscr();
for(int i=0;<size;i++)
{
cout<<”\n\tdetails of manager”<<i+1<<”:\n”;
woreker[i].getval();
}
cout<<”\n”;
for(i=0;<size;i++)
{
cout<<”\n\t manager”<<i+1<<”:”;
woreker[i].putval();
}
getch();
}
Output
Details of manager 1:
Enter name: Sunita
Enter salary:5000
Detalails of manager 2:
Enter name: Sangeeta
Enter salary:4500
Manager 1:
Name: Sunita
Salary:5000
Manager 2:
Name: Sangeeta
Salary:4500
फंक्शन आग्र्यूमेन्ट के रूप में ऑब्जेक्ट (Object As Function Arguments)
C++ भाषा मे ऑब्जेक्ट पूर्व निर्मित डाटा टाइप के रूप में माना जाता है, और किसी फंक्शन में argument के रूप में प्रेषित किया जा सकता है ।
Example
Object as a Function Arguments
#include<iostream.h>
#include<conio.h>
class
date
{
int
a;
int
year;
int
month;
int
day;
int
result;
public:
void
gettime(void)
{
cout<<"enter
the year";
cin>>year;
cout<<"enter
the month";
cin>>month;
cout<<"enter
the day";
cin>>day;
}
void
puttime(void)
{
cout<<year<<"
years ";
cout<<month<<"
months and ";
cout<<day<<"
day "<<"\n";
}
void
dob(date d1,date d2)
{
if((d1.day>d2.day)&&(d2.month==4||d2.month==6||d2.month==9
||d2.month==11))
{
d2.day=d2.day+30;
d2.month=d2.month-1;
}
else
{
d2.day=d2.day+31;
d2.month=d2.month-1;
month=d2.month-d2.month;
d2.month=d2.month+12;
d2.year=d2.year-1;
day=d1.day-d2.day;
day=abs(day);
month=d1.month-d2.month;
month=abs(month);
year=d1.year-d2.year;
year=abs(year);
cout<<"\n";
}
}
};
int
main()
{
clrscr();
date
d1,d2,d3;
d1.gettime();
d2.gettime();
d3.dob(d1,d2);
cout<<"\nt1
= ";
d1.puttime();
cout<<"\nt2
= ";
d2.puttime();
cout<<"\nSub
of two years = ";
d3.puttime();
getch();
return 0; }
Constructor and Destructors
Introduction
Class कैसे कार्यविन्त होती है। सभी उदाहरणो में सदस्य फंक्शन का प्रयोग निजी वेरियेबल को प्रारंभिक मान प्रदान करता है । उदाहरणार्थ कोई कथन जैसे-
A. getedata ( ):
में getdata() फंक्शन ऑब्जेक्ट को प्रारम्भिक मान निर्धारित करता है । ठीक उसी प्रकार
a.getdata(100,129.99);
कन्स्ट्रक्टर (Constructor)
कन्स्ट्रक्टर एक विशेष सदस्य फंक्शन होता है जिसका कार्य क्लास के ऑब्जेक्ट को इनिशियलाइज करना है।इसका नाम क्लास के नाम के समान ही होता है। कन्सट्रक्टर उस समय अपना कार्य करता है जब इससे सम्बन्धित क्लास के ऑब्जेक्ट का निर्माण होता है । इसीलिए इसे कन्स्ट्रक्टर कहते है।
कन्स्ट्रक्टर के प्रकार
(1)डिफाॅल्ट कन्स्ट्रक्टर
ऐसा कन्स्ट्रक्टर जो कोई तर्क स्वीकार न करता हो, डिफाल्ट कंस्ट्रक्टर कहलाता है क्लास temp के लिए डिफाल्ट कन्स्ट्रक्टर temp::temp () है। यदि ऐसा कोई कन्स्ट्रक्टर परिभाषित न किया गया हो तो कम्पाइलर डिफाल्ट कन्स्ट्रक्टर प्रदान करता है। इसीलिए निम्न कथन -
temp t;
डिफाॅल्ट कंस्ट्रक्टर को सक्रिय कर t ऑब्जेक्ट का निर्माण करता है।
कन्स्ट्रक्टर फंक्शन के मुख्य गुण निम्नलिखित है-
1. ये सार्वजनिक खण्ड में घोषित किये जाने चाहिए।
2. ऑब्जेक्ट के निर्माण होने पर वे स्वतः ही कार्यान्वित होने चाहिए ।
3. ये किसी प्रकार का नाम नहीं लौटाते ।
4. इनके गुणों को वंशानुगत नहीं किया जा सकता है।
5. ये वर्चुअल नहीं हो सकते है।
#include<iostream.h>
#include<conio.h>
class integer
{
int m,n,o;
public:
integer(int,int);
void display(void)
{
cout<<"m=
"<<m<<"\n";
cout<<"n=
"<<n<<"\n";
o=m+n;
cout<<o;
}
};
integer::integer(int x,int
y)
{
m=x;
n=y;
}
int main()
{
clrscr();
integer int1(10,100);
cout<<"\n
object1"<<"\n";
int1.display();
getch();
return 0;
}
(2) पैरामीटरयुक्त कन्स्ट्रक्टर्स
वे कन्स्ट्रक्टर्स जो आग्र्यूमेन्टों की प्रति करते है, पैरामीटरयुक्त कन्स्ट्रक्टर्स कहलाते है । इनकी परिभाषा में हम आग्र्यूमेन्टों को सम्मिलित कर सकते है जिससे प्रोग्रामर एक ऑब्जेक्ट को तैयार करते समय ही ऑब्जेक्टों का प्रारम्भिक मान स्पष्ट कर सकता है ।
उदाहरण 2& C++ भाषा में एक प्रोग्राम लिखना जिसमें फैक्टोरियल N(N) की गणना की जाये जहाॅ N एक इंटीजर है।
N!=
1*2*3*.....N
हलः एक fact नाम का क्लास प्रयुक्त करेंगंे जिसका प्रारूप निम्न प्रकार होगा-
जहाॅं fact : क्लास का नाम है ।
fact % एक वेरियेबल है जिसमें factorual का मान संग्रहीत किया जायेगा
fact( ) % एक कन्स्ट्रक्टर है main फंक्शन प्रारंम्भिक मान प्राप्त करेगा ।
compute_fact( )% एक फंक्शन है जो एक पूर्णाक को फैक्टोरियल की गणना करके main() फंक्शन को प्रदान करता है।
उल्लेखनीय है कि उपर्युक्त प्रोग्राम में कन्स्ट्रक्टर्स के लिये आग्र्यूमेंट, ऑब्जेक्ट को तैयार करते समय प्रदान किया गया है। यह क्रिया निम्नलिखित कथन द्वारा की गयी है -
ऑब्जेक्ट तैयार करते समय कंस्ट्रक्टर फंक्शन में आग्र्यूमेन्ट प्रदान करने की विधि implicit call कहलाती है । इसके अलावा कंस्ट्रक्टर फंक्शन काॅल करने की एक अन्य विधि भी है जिसको उपर्युक्त उदाहरण के लिए निम्न व्यक्त किया जाता है।
फंक्शन काॅल करने की उपर्यूक्त विधि implicit call कहलाती हैं। कंस्ट्रक्टर फंक्शन काॅल करने की implicit call explicit call विधि से छोटी होती है। अतः प्रोग्रामर implicit call विधि का उपयोग अधिक करते है।
कंस्ट्रक्टर फंक्शन में आग्र्यूमेन्ट प्रेषित करने का प्रारूप इस प्रकार है।
<क्लास का नाम> <ऑब्जेक्ट का नाम> <आग्र्यूमेन्ट सूची>
#include<iostream.h>
#include<conio.h>
class integer
{
int m,n,o;
public:
integer(int,int);
void display(void)
{
cout<<"m=
"<<m<<"\n";
cout<<"n=
"<<n<<"\n";
o=m+n;
cout<<o;
}
};
integer::integer(int x,int
y)
{
m=x;
n=y;
}
int main()
{
clrscr();
integer int1(10,100);
cout<<"\n
object1"<<"\n";
int1.display();
getch();
return 0;
}
¼3½ काॅपी कंस्ट्रक्टर (Copy Constructor)
काॅपी कंस्ट्रक्टर ऐसा कंस्ट्रक्टर होता है, जिसकें द्वारा घोषणा के समय एक ऑब्जेक्ट का प्रारम्भिक मान दूसरे ऑब्जेक्ट के मानों द्वारा निर्धिारित किया जाता है। सरल शब्दों में कह सकते है कि यदि हम ऑब्जेक्ट obj1 का उपयोग कर रहे हैं और obj1 के अवयवों द्वारा नये ऑब्जेक्ट obj2 के प्रारम्भिक मान निर्धारित किये जाये तो काॅपी कंस्ट्रक्टर का उपयोग किया जाना अनिवार्य होता है। जैसे -
यहाॅ घोषणा (i) द्वारा क्लास का ऑब्जेक्ट obj1 तथा घोषणा (ii) द्वारा xyz क्लास का एक अन्य ऑब्जेक्ट obj2 घोषित किया जाता है। साथ ही obj2 ऑब्जेक्ट का प्रांरभिक मान obj1 के अवयवों के मान द्वारा निर्धारित हो जाता है। यद्यपि काॅपी कंस्ट्रक्टर किसी क्लास में पैरामीटर कंस्ट्रक्टर के रूप में निम्न प्रकार एक ऑब्जेक्ट ऑग्र्यूमेन्ट को प्राप्त कर सकता है जिसमें Pass by Reference विधि प्रयुक्त की गई है-
#include<iostream.h>
#include<conio.h>
class code
{
int id;
public:
code ()
{
}
code(int a)
{
id=a;
}
code(code & x)
{
id=x.id;
}
void display (void)
{
cout<<id;
}
};
int main()
{
clrscr();
code A(100);
code B(A);
code C=A;
code D;
D=A;
cout<<"\n id of
A:";A.display ();
cout<<"\n id of
B:";B.display ();
cout<<"\n id of
C:";C.display ();
cout<<"\n id of
D:";D.display ();
getch ();
return 0;
}
यहाॅ - ob ऑब्जेक्ट ob के पते को व्यक्त करता है, अतः xyz (xyz - ob) कथन आग्र्यूमेन्ट xyz - ob को pass by Reference विधि द्वारा प्रेषित किया जा रहा है। काॅपी कंस्ट्रक्टर में आग्र्यूमेंट को pass by value विधि द्वारा प्रेषित नहीं कर सकते है । यदि ऐसा किया जाता है तो कंस्ट्रक्टर स्वयं की प्रति स्वयं पर ही तैयार करता रहता है। और यह क्रिया तब तक दोहराता है जब तक कि कम्पाइलर मेमोरी में से हट नहीं जाता है। Address नाम के एक क्लास के निम्नलिखित उदाहरण पर विचार करते है-
उपर्यूक्त क्लास में दो कंस्ट्रक्टर्स है-
(i) पैरामीटर कंस्ट्रक्टर (ii) काॅपी कंस्ट्रक्टर
ये दोनों कंस्ट्रक्टर एक ही क्लास address को शेयर कर रहे है।
अभी तक दो प्रकार का कंस्ट्रक्टर के प्रयोग को देखा है। जैसे -
पहले कथन, कंस्ट्रक्टर स्वयं डाटा को मान प्रदान करता है। तथा दूसरे कथन में प्रोग्राम से उपयुक्त मान प्रदान करता है। C++ मे एक ही क्लास में उपरोक्त दोनों कंस्ट्रक्टर का प्रयोग कर सकते है। उदाहरणार्थ निम्न क्लास परिभाषा को देखे-
उपरोक्त एक integer ऑब्जेक्ट के लिए तीन कंस्ट्रक्टर को घोषित करता है। पहले कंस्ट्रक्टर में कोई तर्क नहीं हैं दूसरे मे दो integer तर्क है तथा तीसरे में एक इंटीजर ऑब्जेक्ट तर्क के रूप में है। उदाहरणार्थ, घोषणा-
integer I1:
स्वतः पहले कंस्ट्रक्टर को कार्यान्वित करता है तथा I1 के दोनो a तथा b को शून्य मान प्रदान करता है। इसी प्रकार कथन-
Integer I2(20,40);
दूसरे कंस्ट्रक्टर को काॅल करता है जो a तथा b का मान 20 तथा 40 करता है। अंततः कथन -
Integer I3(I2)
तीसरे कंस्ट्रक्टर को कार्यान्वित करता है। जो I2 के मानों को I3 मे काॅपी कर देता है । इस प्रकार I2 के सभी तत्वो को I3 काॅपी कंस्ट्रक्टर भी कहते है। जिसकी चर्चा कर चुके हैं। कंस्ट्रक्टर की इस प्रक्रिया को कंस्ट्रक्टर ओवरलोड़िग भी कहते है।
क्लास मे बहु कंस्ट्रक्टर (Multiple Construction in Class)
उदाहरण -
#include<iostream.h>
#include<conio.h>
class
complex
{
float
x,y;
complex()
complex(float
a)(x=y=a;)
complex(float
real, float image)
(x=real;
y=image;)
friend
complex sum(complex);
friend
void show (complex);
};
complex
sum(complex c1, complex c2)
{
complex
c3;
c3.x=c1.x+c2.x;
c3.y=c1.y+c2.y;
return
(c3);
}
void
show (complex c)
{
cout<<c.x<<"+"<<c.y<<"/n"
;
}
ऑब्जेक्ट का डायनामिक इनिशियालाइजेशन (Dynamic Initialization)
क्लास ऑब्जेक्ट को डायनामिक तरीके से भी मान निर्धारित किये जा सकते है। अर्थात् ऑब्जेक्ट का प्रारम्भिक मान क्रियान्वयन-समय मे भी दिया जा सकता है। इसका लाभ यह है कि इसे कई प्रारूप में दें सकते है ।
डायनामिक कंस्ट्रक्टर (Dynamic Initialization)
कंस्ट्रक्टर का प्रयोग भी मेमोरी आवंटन में ऑब्जेक्ट निर्माण के दौरान किया जा सकता है। यह सिस्टम को प्रत्येक ऑब्जेक्ट के लिए उपयुक्त मात्रा मे मेमोरी में स्थान देने में मदद करेगा जबकि ऑब्जेक्ट विभिन्न आकार के हो । इस प्रकार यह मेमोरी में स्थान में स्थान बर्बाद होने से बचाता है ऑब्जेक्ट निर्माण के समय उसे मेमोरी आंवटित करना ऑब्जेक्ट का डायनमिक निर्माण कहलाता है । इस कार्य के लिए new आपरेटर का प्रयोग किया जाता है । new को बेहतर ढंग से समझने के लिए उस प्रोग्राम को देखे ।
इस प्रोग्राम में दो कंस्ट्रक्टर है। पहला रिक्त कंस्ट्रक्टर वर्ड के ऐरे को घोषित करने के लिए है । दूसरे कंस्ट्रक्टर वर्ड कें लम्बाई को निर्धारित करता है, संग्रहित किये जाने वाले मेमोरी के लिए उपयुक्त स्थान घेरता है तथा स्वयं ही word का निर्माण भी करता है ध्यान देने योग्य बात यहाॅ है कि एक अतिरिक्त अक्षर की जगह आखिरी word के अक्षर '\0' के लिए निर्धारित की गई है ।
इसके सदस्य फंक्शन join (0 है जो दो शब्दों को जोड़ता है इसमें join 9 0 , length तथा name ऑब्जेक्ट को काॅल करते है जबकि a.length तथा a.name तर्क और टैक्स्ट के सदस्य है । main() फंक्शन तीन शब्दो को जोड़कर एक शब्द बनाता है । तथा परिणाम प्रदर्शित करता है।
#include<iostream.h>
#include<conio.h>
#include<string.h>
class
string
{
char
*name;
int
length;
public:
string()
{
length=0;
name=new
char[length+1];
}
string(char
*s)
{
length=
strlen(s);
name=new
char[length+1];
strcpy(name,s);
}
void
display(void)
{
cout<<name<<"\n";
}
void
join(string &a, string &b);
};
void
string::join(string &a, string &b)
{
length=a.length+b.length;
delete
name;
name=new
char[length+1];
strcpy(name,a.name);
strcat(name,b.name);
}
int
main()
{
char
*first ="MLC";
string
name1(first), name2("COMPUTER"),name3("KORBA"),s1,s2;
s1.join(name1,name2);
s2.join(s1,name3);
name1.display();
name2.display();
name3.display();
s1.display();
s2.display();
getch();
return
0;
}
डिस्ट्रकटर्स (Destructor)
कंस्ट्रक्टर्स के प्रितिलोम डिस्ट्रक्टर्स होते है, क्योंकि डिस्ट्रक्टर्स द्वारा तैयार ऑब्जेक्टों को आबंटित मेमोरी को रिक्त कर देता है।
डिस्ट्रकटर्स(Destructor) का नाम क्लास नाम के समान ही होता है। लेकिन इसमें पूर्वलग्न एक टिल्ड चिन्ह (~) होता है।
class xyz
{
public:
xyz( ); //Constructor
~ xyz ( ); //Dectructor
};
डिस्ट्रकटर्स(Destructor) फंक्शन, क्लास ही परिभाषा के अंदर अथवा बाहर दोनों ही स्थितियों परिभाषित किया जाता है। डिस्ट्रकटर्स (Destructor) में कोई आगग्र्यूमेंट प्रेषित नही किया जा सकता है और कोई परिणामी मान प्रदान नहीं करता है। डिस्ट्रकटर्स का मुख्य कार्य है , मेमोरी के आवंटित स्थान को रिक्त करना । कंस्ट्रक्टरों के कार्य के उपरांत ही डिस्ट्रकटरो का कार्य प्रारंभ होता है। क्योंकि ये कंस्ट्रक्टर द्वारा आवंटित मेमोरी को आगे उपयोग हेतु रिक्त करते है।
उदाहरण -
# include <iostream.h>
#include <conio.h>
int count=0;
class demo
{
public:
r demo();
~demo();
};
demo::demo()
{
count ++;
cout<<”\n”<<count<<”object created”;
}
demo::~demo()
{
cout<<”\n”<<count<<”object
destroyed”;
count--;
}
void main();
{
clrscr();
cout<<”\n\t now I am in main.<<”\n”;
demo r1,r2,r3,r4,r5;
{
cout<<”\n\n\t Enter block1\n";
demo r6;
}
{
cout<<”\n\n\t Enter block 2\n”;
demo r7;
}
cout<<”\n\n\t Again I am in main.\n”;
}
Output
Now I am in maim
1 Object Created
2 Object Created
3 Object Created
4 Object Created
5 Object Created
Enter block1
6 Object Created
6 Object Created
Enter block 2
6 Object Created
6 Object Created
Again I am in main
5 Object Created
4 Object Created
3 Object Created
2 Object Created
1 Object Created
Function in C++ में main( ) Function Operating System केा int type का मान लौटाता है।इसलिये सी++ main( ) को निम्नलिखित प्रोटोटाइप में परिभाषित करता है।
int main ( )
……
……
return 0;
}
चुकि फंक्शन का रिटर्न का प्रकार बाई डिफाल्ट ही int है, इसलिये ही main( ) function हैडर में int का प्रयोग अवाश्यक नहीं है। रिर्टन कथन रिर्टन( )नहीं रहने की स्थिति में ज्यादातर सी++ कम्पाइलर त्रुटि संदेश प्रदर्शित करते है। अतः प्रोग्रामिंग में main( ) का मान लौटाते (return)आवश्यक तथा अच्छा अभ्यास है।
Function Prototyping (फंक्शन प्रोटेाटाइप)-
फंक्शन प्रोटेाटाइप कम्पाइलर को फंक्शन इंटरफेस के संबंध में तर्क की संख्या (number of argument) तथा इसके प्रकार लौटाने वाला मान (return value) के प्रकार से संबंधित जानकारी प्रदान करता हेै। फंक्शन प्रोटेाटाइप के साथ फंक्शन की घोषणा तथा परिभाषा के समय टैम्पलेट का प्रयोग किया जाता है। जब फंक्शन की घोषणा तथा परिभाषा के समय टैम्पलेट के प्रयोग से यह सुनिश्चित करता है। कि तर्क सही-सही भेजे गये है तथा वापसी मान सहीं है अथवा नहीं।
फंक्शन प्रोटेाटाइप काॅलिंग प्रोग्राम में एक घोषणात्मक कथन होता है। जिसका प्रारूप निम्न होता है।
Type Function –name (argument-list);
उदाहरणः
float pressure(int a,int
b,float c);
Function में भेजे जाने वाले पैरामीटर (Parameters Passing In Function)
सामान्य फंक्शन प्रोग्राम मे एक ही कार्य को अनेक भागो में सम्पन्न कर सकते है। विभिन्न प्रकार के फंक्शनों को main( ) फंक्शन काॅल करता है लेकिन फंक्शन के मध्य सम्पर्क का सीमित रूप से इतना ही अध्ययन किया है कि फंक्शन काॅल मे ग्लोबल वेरियेबल का उपयोग कर आग्र्यूमेन्ट प्रयुक्त किये जा सकत है।
काॅल्ड फंक्शन और काॅलिंग फंक्शन के मध्य सम्पर्क स्थापित करने के लिए पैरामीटर और रिटर्न कथन का प्रयोग किया जाता है । काॅल्ड फंक्शन मे परिभाषित पैरामीटर फाॅर्मल या डमी पैरामीटर कहलाते है, जबकि काॅलिंग फंक्शन मे परिभाषित पैरामीटर वास्तविक पैरामीटर कहलाते है ।
पैरामीटर युक्त फंक्शनों को काल करने की दो विधियाॅं है-
(1) काॅल बाई वैल्यू (2) काॅल बाई रेफरेन्स
(1) काॅल बाई वैल्यू (call by value)- इसे समझने के लिए हम निम्नलिखित उदाहरण पर दृष्टि डालते है-
अब एक प्रोग्राम को देखते है जिसके main( ) फंक्शन से एक पैरामीटर को addone ( ) फंक्शन मे भेजा जाता है। addone() पैरामीटर में एक की वृद्धि कर देता है। आउटपुट में main( ) फंक्शन के वेरियेबल और फंक्शन से लौटाए मान को आउटपुट में छापा गया है-
यहाॅं x वास्तविक पैरामीटर है और a फाॅर्मल पैरामीटर है। फंक्शन काॅल होने पर वास्तविक पैरामीटर अपना मान फाॅर्मल पैरामीटर को दे देते है फंक्शन क्रियान्वयन के दौरान फार्मल पैरामीटर के मान में परिवर्तन से वास्तविक पैरामीटर का मान अपरिवर्तित रहता है। इसीलिए x=10 दोनों आउटपुट मे छपा है । अतः वास्तविक पैरामीटर और फार्मल पैरामीटर मेमोरी में दो अलग-अलग स्थानो पर होते है।
(2) काॅल बाई रेफरेन्स(Call by Reference) - एक एड्रैस ऑपरेटर होता है जो किसी वेरियेबल के साथ प्रयुक्त होने पर उस वेरियेबल का एड्रैस मेमोरी को व्यक्त करता है, जैसे कोई वेरियेबल है तो -ंवेरियेबल मेमोरी मे एड्रैस होगा ।
काॅल बाई रेफरेन्स विधि में फंक्शन फार्मल पैरामीटर व एड्रैस ऑपरेटर - के साथ वेरियेबल लिख जाते है जैसे - int addone(&a)
काॅल बाई रेफरेन्स विधि में फार्मल पैरामीटर मे वास्तविक पैरामीटर के एड्रैस संग्रहीत होते जाते है न कि उनके मान ।
call by reference:-
#include<iostream.h>
#include<conio.h>
void
main()
{
int
a,b;
clrscr();
cout<<"Enter
any 2 nos. :";
cin>>a>>b;
int
swap(int *,int *);
swap(&a,&b);
getch();
}
int
swap(int *m,int *n)
{
int
t;
t=*m;
*m=*n;
*n=t;
cout<<"a="<<*m<<"b="<<*n;
return
0;
}
रिफ्रेन्स के द्वारा वापसी (Return by reference )
फंक्शन रिफ्रेन्स को काॅल करने के साथ ही वापस भी कर सकता है। जैसे इस उदाहरण को देखें -
चूॅकि big( ) का वापसी रूप int - है, फंक्शन x या y को रिफ्रेन्स वापस करता है। तब big(a, b) फंक्शन काॅल a या उनके मान के आधार पर यह रिफ्रेन्स पहुॅचायेगा। अर्थात् फंक्शन काॅल असाइनमेन्ट कथन की बायी ओर आ सकता है । जैसे इस कथन में -
इनलाइन फंक्शन (inline function)
फंक्शन निर्देशो का एक ऐसा समूह होता है जिसे अन्य फंक्शनों में इसके नाम के द्वारा काॅल किया जा सकता है कार्य सम्पन्न होने के बाद प्रोग्राम का नियंत्रण पुनः काॅलिंग फंक्शन में स्थानान्तरित हो जाता है और प्रोग्राम का सामान्य प्रवाह चलता रहता है अतः फंक्शन के काॅल की क्रिया में निम्नलिखित गतिविधियाॅ सम्पन्न होती है-
(1) register की स्थिति को एक stack में संग्रहीत करना ।
(2) काॅल किये गये फंक्शन में आग्र्यूमेन्ट प्रेषित करना ।
(3) कार्य सम्पन्न होने के बाद register को स्थिति प्रदान करना ।
(4) काॅल किये गये फंक्शन द्वारा परिणामी मान ध्यान रखना ।
फंक्शन को काॅल करने की कार्यविधि प्रोग्राम के क्रियान्वयन की दृष्टि से जटिल हो सकती है। फंक्शन काॅल करने की जटिलता को समाप्त करने के लिए सी++ मे लाइन फंक्शन प्रयुक्त किये जाते है । एक इनलाइन फंक्शन मैक्रो के समान कार्य करता है जिसमें फंक्शन बाॅडी के सम्पूर्ण टैक्स को कम्पाइलर, प्रोग्राम मे किसी भी स्थान पर प्रतिस्थापित कर सकता है।
#include <Iostream.h>
#inclide<conio.h>
inline float multi (float
x,float y)
{
return(x*y)
}
void main()
{
float a,b;
clrscr();
cout<<”\n Enter two values:”;
cin>>a>>b;
cout<<”\n Multiplication is”;
cout<<mul(a,b);
getch();
}
Output
Enter two values:5 7
Multication is 35
इनलाइन फंक्शन को प्रोग्राम मे काॅल करने से पूर्व परिभाषित करना आवश्यक है। उल्लेखनीय है कि इनलाइन फंक्शनों को ओवरलोड भी किया जा सकता है। इनलाइन फंक्शन प्रयोग करने के लाभ निम्नलिखित है-
(1) मैक्रों की अपेक्षा अधिक उपयोगी है।
(2) फंक्शनों को काॅल करने की जटिलता समाप्त करते है।
(3) प्रोग्राम पढ़ने मे सरल हो जाता है।
परन्तु इनलाइन फंक्शन की अपनी सीमाएॅ भी है । यह बहुत बड़ी हो जाने पर कम्पाइलर इसे उपेक्षित भी कर सकता है। अतः जानना आवश्यक है inline की-वर्ड का प्रयोग कम्पाइल को आदेश नहीं देता बल्कि यह मात्र आग्रह होता है जो कम्पालर स्थिति को देखते हुए क्रियान्वित करता है । इनलाइन फंक्शन प्रोग्राम को तेजी से क्रियान्वित करने के साथ-साथ मेमोरी मे अधिक स्थान घेरता है।
डिफाल्ट तर्क (Default Argument)
सी++ किसी फंक्शन को बिना तर्क निश्चित किये हुए भी काॅल कर सकता है इस स्थिति मे फंक्शन एक डिफाल्ट मान पैरामीटर को देता है जो फंक्शन काॅल के तर्क के साथ समानता नहीं रखता । डिफाल्ट मानों को फंक्शन के घोषणा के समय निर्धारित किया जाता है। कम्पाइलर प्रोटोटाइप से तर्क की संख्या का पता लगाता है तथा प्रोग्राम को उतने ही डिफाल्ट मान के लिए सूचित करता है। निम्नलिखित उदाहरण डिफाल्ट मान के साथ प्रोटोंटाइप को दर्शाता है-उपरोक्त प्रोटोटाइप rate को 0.15 का डिफाल्ट मान घोषित करता है आगे का फंक्शन काॅल जैसे-principal को 2000 तथा period को 7 मान प्रदान करता है तथा rate के लिए 0.15 डिफाल्ट मान के रूप में ही रख देता है।
Const तर्क (const Argument)
सी++ मे, फंक्शन मे const तर्क इस प्रकार घोषित किया जा सकता है-
इस तर्क का कार्य यह है कि यह कम्पाइलर को बताता है कि फंक्शन के तर्क में कोई बदलाव न किया जाय। जब कभी इसके तर्क मे बदलाव होता है, कम्पाइलर त्रुटि प्रेषित करता है इसका प्रयोग मुख्यतः रिफ्रेन्स या प्वाइन्टर के द्वारा भेजने में होता है।
फंक्शन ओवरलोडिंग (Function Overloading)
float
area (float len, float wid);
#include(iostream.h>
#include<conio.h>
int volume(int);
double valume(double,int);
long volume(long,int,int);
void main()
clrscr();
cout<<”\n The Volume of
cube is:”;
cout<<volume(10)<<endl;
cout<<n The volume of
cubic is:”;
cout<<valume(10l,5,7)<<endl;
cout<<”\n The volume of
cylinder is :”;
cout<<volume(2,5,4)<<endl;
getch();
}
int volume(int s)
{
return(s*s*s);
}
double value(double r,int h)
{
return(3.14*r*r*h);
}
long volume (long l,int b,int
h)
{
return (l*b*h);
}
output
The volume of cube is:1000
The volume of cubic is :350
The volume of cylinder is:78.5
ऑपरेटर ओवरलोडिंग(Operator Overloading)
ऑपरेटर ओवरलोडिंग की सहायता से +,-,*,/ जैसे ऑपरेटर और क्लासेस और इन्यूमरेशन जैसे यूजर डिफाईड टाईप्स को परिभाषित किया जा सकता है। और उपयोग में लाया जा सकता है। ऑपरेटर्स से डिफाईन करके ,क्लास के उपयोग को मूलभूत डाटा टाइप क उपयोग के समान आसान और सीखने योग्य बनाया जा सकता है।
ऑपरेटर ओवरलोडिंग के उपयोग को स्पष्ट करने के लिये Function Class निर्मित करते है। पहले,उन ऑपरेटर्स को निर्धारित करे जो फंक्शन से जुडे़ है और उसी क्लास में शामिल हो। +,-,*,/ जैसे दिये गये है। C++ इनमें से किसी भी बिल्ट इन ऑपरेटर को क्लास में ओवरलोड करने की अनुमति देती है, परंतु केवल उन्ही को वास्तव में ओवरलोड किया जाना चाहिये जिसमें एक विशेष क्लास के लिये एक आंतरिक अर्थ हो। उदाहरण के लिये,यद्यपि हमारी फंक्शन क्लास के लिये % ऑपरेटर को ओवरलोड किया जा सकता है,परंतु इसका अर्थ अस्पष्ट हागा और यह क्लाॅस के यूजर्स को दुविधा में डालेगा। %1/2 का स्पष्ट अर्थ नहीं है।
ओवरलोडिंग ऑपरेटर के लिये हम क्लास में एक मेम्बर सदस्य बनाते है। तथा जिसे हम क्लाॅस के आब्जेक्ट से जरूरत पड़ने पर उस ऑपरेटर मेम्बर फंक्शन को काॅल करते है। यह एक स्पेशल मेम्बर फंक्शन होता हैं। तथा यह अन्य फंक्शन के सिन्टेक्स की तरह नहीं होता है।
Return_Type Operator_to _be _overloaded(Parameters);
Operaters Key-Word के पुर्व में फंक्शन का Return Type अवश्य होना चाहिये जो कम्पाईलर को यह सूचना देता है कि ऑपरेटर की ओवरलोडिंग करना हैं। उदाहरण के लिये
1½ void operator ++¼½;// is equal to void increment¼½;
2½
int sum ¼int x,int y½;//is equal to int operator¼int x,int y½;
आॅपरेटर ओवरलोडिंग के नियमः-
1) C++ कम्पाईलर मे पहले से निर्दिष्ट ऑपरेटर्स का ही उपयोग किया जाता हैं। यूजर नये ऑपरेटर्स को निर्मित नही कर सकता हैं।
2) यूजर ऑपरेटर टेम्लेट्स को बदल नही सकता हैं।
3) किसी भी ऑपरेटर की ओवरलोडिंग से उसके वास्तविक अर्थ से भिन्न अर्थ नही मिलता हैं।
4) यूनेरी ऑपरेटर्स को इसलिये ओवरलोड किया जाता हैं कि मेम्बर फंक्शन कोई स्पष्ट ऑरग्यूमेन्ट नही लेते हैं और न ही कोई वेल्यू प्रदान करते हैं। जब उन्हे एक फ्रेन्डस् फंक्शन के लिये ओवरलोड किया जाता हैं,तो ये कोई रिफ्रेन्स ऑरग्यूमेन्ट जैसे संबधित क्लास का नाम,नही लेते हैं।
मित्र तथा वास्तविक फंक्शन (Friend and Virtual function)
C++ में दो नये प्रकार के फंक्शन मित्र फंक्शन तथा वास्तविक फंक्शन का प्रयोग किया गया है। मित्र फंक्शन (friend function) दो अलग-अलग क्लास के object पर क्रिया करने के लिये प्रयोग किया जाता है।
class ABC
{
……
public:
………
friend void
xyz(void);
};
इस प्रकार के फंक्शन को घोषित करने के लिये friend की-वर्ड का प्रयोग किसा जाता है।
वास्तविक फंक्शन (Virtual function) का प्रयोग सी++ में पाॅलीमोर्फिज्म (Polymorphism) के गुणो का प्रयोग करने के लिये करते है।
किसी वर्ग के Private आंकड़ा सदस्य तथा सदस्य फंक्शन को वर्ग के बाहर access नहीं कर सकते है अर्थात् किसी एक वर्ग का ऑब्जेक्ट किसी अन्य वर्ग के private आंकड़ा सदस्य तथा ऑब्जेक्ट को access नहीं कर सकता है, परन्तु कभी-कभी ऐसी परिस्थितियां आती है कि दो वर्गो को एक ही फंक्शन अथवा एक ही कार्य को अलग-अलग इनपुट लेकर सम्पन्न कराना होता है।
इस समस्या का समाधान प्रोग्रामिंग भाषा ‘सी++’ एक की वर्ड friend उपलब्ध कराकर करती है एक ऐसा सदस्य फंक्शन,जो एक से अधिक वर्गो में एक जैसा ही कार्य करें, उस फंक्शन को friend की वर्ड से वर्ग के अन्दर घोषित करते है तथा उसे वर्ग के बाहर सामान्य function की भांति परिभाषित करते है इस प्रकार इस सदस्य फंक्शन के द्वारा दोनों वर्गो के private सदस्यों को access किया जा सकता है।
सूत्रध्यान friend function को परिभाषित करने के लिए अब न तो friend की वर्ड का प्रयोग किया जाता है न ही scope resolution operator (::) का ।
उस प्रकार हम कह सकते है, कि वे फंक्शन जो friend की-वर्ड के साथ वर्ग के अन्दर घोषित किए जाते है, friend फंक्शन कहलाते है।
यद्यपि friend फंक्शन, सदस्य फंक्शन नहीं होते है परन्तु इन्हें private आंकड़ा सदस्यों तथा सदस्य फंक्शन को access करने का पूर्ण अघिकार प्राप्त होता है तथा इन्हे सामान्य फंक्शन की भांति बुलाया जाता है।
Program for friend function:-
#include<iostream.h>
#include<conio.h>
class
sec;
class
scase
{
int
a; //data member
int
b;
public:
void
setvalue() //member function
{
a=40;b=40;
//80,100,110,130
}
//friend
float sub(scase s);
friend
void add(scase,sec);
};
class
sec
{
int
x;
int
y;
public:
void
setvalue()
{
x=60;y=70;
}
//friend
float sub(scase s);
friend
void add(scase,sec);
};
void
add(scase s1,sec s2)
{
int m,n,o,p;
m=s1.a+s2.x;
n=s1.b+s2.y;
o=s1.a+s1.b;
p=s2.x+s2.y;
cout<<"\n the sum of x & a
= "<<m;
cout<<"\n the sum of b & y
= "<<n;
cout<<"\n the sum of a & b
= "<<o;
cout<<"\n the sum of x & y =
"<<p;
}
void main()
{
clrscr();
scase e1;
e1.setvalue();
sec e2;
e2.setvalue();
add(e1,e2);
getch();
}
------------------------------------------------------------------------------------------
UNIT-IV
Inheritance:- Extending Classes Introduction -
Introduction-
Inheritance, class के बाद C++ का सबसे शक्तिशाली तथा अधिक उपयोग किया जाने वाला गुण है। Inheritance नये व्युत्पन्न class (derived classes) तैयार करने की प्रक्रिया को कहते है। व्युत्पन्न क्लास पहले से बने क्लासो के द्वारा उत्पन्न किये गये होते है तथा उनमें मुख्य क्लासों के सभी गुणों को समावेश होता है।इन्हेरिटेन्स के कई उपयोगिताओं में सबसे प्रमुख क्लास के कोड़ का पुर्नउपयोग से सम्बन्धित है । मुख्य क्लास एक बार बनने तथा त्रुटिरहित होने के बाद उसे यथावत छोड़ दिया जाता है तथा आवश्यकता होेने पर इसका प्रयोग कई स्थितियों मे कर सकते है। इसी क्रिया को कोड का पुर्नउपयोग कहते है । यह प्रक्रिया प्रोग्राम निर्माण की विश्वसनीयता भी बनाये रखता है। क्योकि इसमें बार एक ही कार्य को कई स्थानो पर करने के लिए मुख्य क्लास नहीं बनान पड़ता।
इन्हेरिटेन्स की सहायता से लाइब्रेरी क्लासो का उपयोग भली-भाॅति किया जा सकता है। कोई भी प्रोग्रामर किसी दूसरेे प्रोग्रामर के बनाये हुए क्लासों से किसी विशेष परिस्थिति के तहत क्लासो का निर्माण तथा प्रयोग कर सकता है।
Derived क्लास को परिभाषित करना
व्यूत्पन्न क्लास को इसके आधार क्लास से सम्बन्धित करने के अतिरिक्त इसके गुणों के साथ परिभाषित कर सकते है। व्युत्पन्न क्लास को परिभाषित करने का सामान्य विधि निम्नलिखित है-
Class derived-class-name: visibility-mode base-class-name
{
………….
}
उपरोक्त मे प्रथम लाइन का काॅलम यह दर्शाता है कि व्युत्पन्न क्लास का नाम आधार क्लास के इस नाम से लिया गया है। इसमे Visibility mode ऐच्छिक है यहाॅ private या public या protected हो सकता है जोकि यह दर्शाता है कि आधार क्लास के लक्षणों को निजि रूप से लाया गया है अथवा सार्वजनिक रूप से Visibility mode न लिखने की स्थिति मे कम्पाइलर इसे private मानता है।
class ABC: private DEF
{
ABC ds lnL;
};
Class ABC: public DEF
{
ABC ds lnL;
};
Class ABC: DEF
{
ABC ds lnL;
};
class derived_class_name: private/public/protected
base_class_name
{
private: // data memter & methods
public: // data member & methods
protected: // data members & methods
};
जब व्युत्पन्न क्लास,आधार क्लास को निजी तौर पर प्राप्त करता है तब आधार क्लास का ’सार्वजनिक सदस्य’ व्युत्पन्न क्लास का निजी सदस्य बन जाता है। फलस्वरूप आधार क्लास के सार्वजनिक सदस्य केवल व्युत्पन्न क्लास के सदस्य फंक्शन के द्वारा एक्सेस किये जा सकते है। वे व्युत्पन्न क्लास के ऑब्जेक्ट के लिए प्रतिबंधित होते है। तथापि क्लास का सार्वजनिक सदस्य अपने ऑब्जेक्ट के द्वारा (.) के लिए अनुमति नहीं होता है।
लेकिन जब आधार क्लास सार्वजनिक रूप से प्राप्त नहीं किया जाता है इसलिए आधार क्लास का सार्वजनिक सदस्य व्युत्पन्न क्लास का भी सार्वजनिक सदस्य का भी सार्वजनिक सदस्य बन जाता है तथा वे व्युत्पन्न क्लास के ऑब्जेक्ट के लिए अनुमति होता है। दोनेा स्थितियों मे निजी सदस्य वंशानुगत में प्राप्त नहीं किया जाता है इसीलिए आधार क्लास का निजी सदस्य, व्युत्पन्न क्लास का सदस्य नहीं बन पाता है।
एकल वंशानुक्रम(Single Inheritance)
एकल इन्हेरिटेन्स पर आधारित एक प्रोग्राम पर विचार करते है इस प्रोग्राम मे क्लास A आधार है तथा इससे व्युत्पन्न क्लास C है क्लास A में एक निजी डाटा सदस्य, एक सार्वजनिक डाटा सदस्य तथा तीन सार्वजनिक सदस्य फंक्शन है तथा क्लास C में एक निजी डाटा सदस्य तथा दो सार्वजनिक सदस्य फंक्शन है।
// [Single inheritance: Public]//
# include<iostream.h>
classA
{ int a; //private; not
inheritable
public:
int
b; // public; ready
for inheritance
void
get_ab ( );
int
get_a (void);
void
show_a(void);
};
class C: public A //
public derivation
{
int c;
public:
void mul(void);
void
display (void);
};
//……………functions defined……..
voidA:: get_ab (void)
{ a=5;b=10;}
int A::get_a( )
{ return a;}
void A:: show _a( )
{ cout<< “a=”<<a<<”\n”; }
void c:: mul ( )
{ c=b * get_a ( ); }
void C:: display ( )
{
cout<<”a=”<<get_a
()<<”\n”;
cout<<”b=”<<b
<<”\n”;
cout<<”c=”<<c<<”\n”’
}
//………….main program…………
int main( )
{
C c;
c.get_ab
( );
c.mul (
);
c.show_a ( );
c.display ( );
c.a=20;
c.mul (
);
c.display ( );
return 0; }
bldk ifj.kke bl
izdkj izdV gksxk&
a=5
b=5
c=10
d=50
a=5
b=20
c=100
इसमें क्लास C आधार क्लास A का सार्वजनिक व्युत्पति है इसलिए C, A के सभी सार्वजनिक सदस्यों का वंशानुक्रम मे प्राप्त कर लेता है तथा उसकी विजिबिलिटी को बनाये रखता है इस कारण से आधार क्लास A का सार्वजनिक सदस्य, व्युत्पन्न क्लास का सार्वजनिक सदस्य है। जैसा कि पिछले खण्ड मे बताया जा चुका है कि क्लास A के निजी सदस्यों को C द्वारा वंशानुक्रम स्वरूप प्राप्त नहीं किया जा सकता है । इस प्रक्रिया में क्लास C में इसके घोषणा के समय के अपेक्षाकृत अधिक सदस्य हो जायेंगे।
उपरोक्त प्रोग्राम में व्युत्पति का आधार सार्वजनिक था अब आने वाले प्रोग्राम को देखे जिसमें निजी तौर पर क्लास व्युत्पन्न किया गया है।
निजी सदस्य को योग्य बनाना(Making A Private Member Inheritable)
आधार क्लास के निजी सदस्य को वंशानुक्रम के माध्यम से नहीं प्राप्त किया जा सकता है जिसके कारण यह व्युत्पन्न क्लास मे प्रत्यक्षतः उपलब्ध नहीं हो पाता है। परन्तु हमें आधार क्लास के निजि डाटा की आवश्यकता पड़ सकती है। इसके लिए निजी सदस्य के दृष्टिक्षेत्र को सार्वजनिक बना देते है ऐसा करने से डाटा गोपन का गुण समाप्त हो जाता है तथा प्रोग्राम के सभी फंक्शन अभिगम्य हो जाते है।
सी++ एक तीसरा दृष्टिक्षेत्र माॅडिफायर protected प्रदान करता है जो इन्हेरिटेन्स में एक सीमित उद्देश्य को पूरा करता है । घोषित सदस्य, सदस्य फंक्शन के द्वारा अपने ही क्लास मे या इससे तत्काल किसी क्लास मे अभिगम्य होता है। यह फंक्शन के द्वारा इन क्लासो से बाहर गमन नहीं किया जा सकता है।
जब कोई सुरक्षित (protected) सदस्य सार्वजनिक रूप से वंशानुगति प्राप्त करता है तब यह व्युत्पन्न क्लास मे भी सुरक्षित बन जाता इसीलिए व्युत्पन्न क्लास के सदस्य फंक्शन द्वारा अभिगम्य होता है। यह आगे उत्तराधिकारी के लिए भी तैयार होता है एक सुरक्षित सदस्य जिसने निजी रूप में उत्तराधिकार प्राप्त किया है, व्युत्पन्न क्लास मे निजी बन जाता है। यद्यपि, यह व्युत्पन्न क्लास के सदस्य फंक्शन के लिए उपलब्ध होता है इसे आगे इन्हे नहीं किया जा सकता।
क्लास निजी तथा सुरक्षित सदस्यों को निम्न स्थितियों में फंक्शन के द्वारा एक्सेस किया जा सकता है-
1. एक फंक्शन जो उस क्लास का मित्र हो ।
2. क्लास का सदस्य फंक्शन जो क्लास का मित्र हो ।
3. व्युत्पन्न क्लास का सदस्य फंक्शन।
मित्र क्लास का मित्र फंक्शन तथा सदस्य फंक्शन निजी तथा सुरक्षित डाटा का सीधे-सीधे एक्सेस कर सकते है जबकि व्युत्पन्न क्लास का सदस्य फंक्शन केवल सुरक्षित डाटा को एक्सेस करने मे सक्षम होता है किन्तु वह निजी डाटा का आधार क्लास के सदस्य फंक्शनो की सहायता से अभिगमन कर सकता है कि कैसे एक्सेस कन्ट्रोल कार्यविधि विभिन्न परिस्थितियों में कार्य करता है ।
बहुस्तरीय उत्तराधिकार (Multilevel Inheritance)
वंशानुक्रम में आधार क्लास से व्युत्पन्न क्लास तथा फिर उस व्युत्पन्न क्लास से अगली उत्पत्ति को बहुस्तरीय वंशानुक्रम कहा जा सकता है। जैसे- उदाहरण स्वरूप क्लास A आधार क्लास है जिससे व्युत्पन्न क्लास B है जो क्लास C का आधार क्लास है क्लास B दोनों A और C क्लास के लिए मध्यवर्ती आधार क्लास का रूप है क्योकि यह क्लास A और क्लास C के बीच लिंक का कार्य करता है तथा इसी प्रकार श्रंखला ABC को वंशानुक्रम मार्ग कहा जायेगा ।
बहुस्तरीय वंशानुक्रम के साथ व्युम्पन्न क्लास को इस प्रकार घोषित करते है-
उदाहरण स्वरूप कोई अंक तालिका का प्रोग्राम तैयार कर रहे है जिसमें तीन क्लास बनाया गया है roll क्लास विद्यार्थियों का क्रमांक संगृहित करता है उंतो विद्यार्थियों के दो विषयों का प्राप्तांक रखता है तथा result क्लास विद्यार्थियों का प्राप्तांक तथा क्रमांक बहुस्तरीय माध्यम से प्राप्त करता है।
उदाहरण -
//Example of multilevel inheritance
#include<iostream.h>
#include<conio.h>
class stu
{
protected:
int roll_number;
public:
void get_number(int);
void put_number();
};
void stu::get_number(int a)
{
roll_number=a;
}
void stu ::put_number()
{
cout<<”\n\t roll number
:”<<roll_number<<”\n;
}
class test:public stu
{
protected:
float m1;
float m2;
public:
void get_marks(float,float);
void put_marks();
};
void test ::get_marks(float x,float y)
{
m1=x;
m2;
}
void text::put_marks()
{
cout<<”\n marks in sub1
:”<<m1<<”\n”;
cout<<”marks in sub2
:”<<m2<<”\n;
cout<<”
---------- :”;
}
class result::public test
{
float total;
public:
void display();
};
void result::display()
{
total=m1+m2;
put_number();
put_marks();
cout<<”\n\t total
:”<<total<<”\n”;
}
void main()
{
clrscr();
result s;
s.get_number(111);
s.get_marks(75,65);
s.display();
getch();
}
Output
Roll number :111
Marks in sub1:75
Marks in sub2:65
--------
Total:140
बहुल वंशानुक्रम(Multiple Inheritance)
कोई क्लास दो या दोे से अधिक क्लासो के गुणों को वंशागत कर सकता है जिसे बहुल वंशागत प्राप्त कर सकता है जिसे बहुत वंशानुक्रम कहते है । बहुल वंशानुक्रम कई क्लासों के लक्षणों को एकत्रित कर नये क्लास को परिभाषित करता है । इसकी परिभाषा किसी बच्चा की तरह होता है जो अपने माता तथा पिता दोनो के गुणों को स्वयं में समाहित करता है।
//Example of multiple inheritance
#include <iosteam.h>
#include<conio.h>
class man
{
protected:
int m;
public:
void get_n(int);
};
class pop::public man,public nan
{
public:
void display();
};
void man::get_n(int x)
{
m=x;
}
void nan::get_n(int y)
{
n=y;
}
void pop ::display()
{
cout <<”\n\tm=”<<”\n”;
cout<<”\n\tn=”<<n<<”\n;
cout<<” ----------“;
cout<<”\n\tn*n=”<<m*n<<”\n;
cout<<” --------“;
}
void main()
{
clrscr();
pop p;
p.get_m(111);
p.get_n(75);
p.display();
getch();
}
Output
M=111
N=75
--------
M*n=8325
---------
श्रेणीबद्ध वंशानुक्रम (Hierarchical Inheritance)
वंशानुक्रम को प्रोग्राम के श्रेणीबद्ध रूपरेखा तैयार करने मे भी किया जाता है। इस विधि में एक स्तर के गुणों को उसके नीचे के कई द्वारा साझा किया जा सकता है
सी++ मे ऐसी समस्याओं को क्लास ढाॅचा में आसानी से बदला जा सकता है । आधार क्लास के सभी गुण उसके व्युत्पन्न क्लासों मे समान्य होगा। व्युत्पन्न क्लास का निर्माण आधार क्लास के गुणो को वंशानुगत प्राप्त कर दिया जा सकता है। प्रत्येक व्युत्पन्न क्लास उससें उत्पन्न क्लास के लिए आधार क्लास होगा ।
संकर वंशानुक्रम (Hybrid Inheritance)
कभी-कभी कुछ स्थितियों मे प्रोग्राम को तैयार करने के लिए दो या इससे भी अधिक वंशानुक्रम की आवश्यकता पड़ती है। उदाहरण स्परूप किसी कम्पनी के कर्मचारियों का प्रोमोशन उसके बिक्री सफलता के अलावा उसके वफादारी के आधार पर किया जाएगा। वफादारी के लिए एक क्लास loyalty अलग से बनाया गया तथा उसे दूसरे क्लासो के साथ सम्बन्धित किया जाएगा।
Example-//Example of hybrid inheritance
#include<iostram.h>
#include<conio.h>
class stu
{
protected:
int
roll_number;
public:
void
get_number(int);
void
put_number();
};
void
stu::get_number(int a)
{
roll_number=a;
}
void
stu::put_number()
{
cout<<”\n\troll
number
:”<<roll_number<<”\n”;
}
class
test:public stu
{
protected:
float m1;
float m2;
public:
void
get_marks(float,float);
void
put_marks();
};
void
test::get_marks(float x,float y)
{
m1=x;
m2=y;
}
void test
::put_marks()
{
cout<<”\n
marks in sub1:”<<m1<<”\n;
cout<<”marks
in sub2:<<m2<<”\n;
cout<<” ---------“;
}
class sport
{
protected:
char grade;
public:
void
get_grade(char s)
{
grade=s;
}
void
put_grade()
{
cout<<”\ngrade
in sports:”<<grade <<”\n\n;
}
};
class result:public
test ,public sport
{
float
total;
public:
void
display();
};
void
result::display()
{
total=m1+m2;
put_number();
put_marks();
cout<<”\n\t
total:”<<total<<”\n”;
cout<<”
---------\n”;
put_grade();
}
void main()
{
clrscr();
result s;
s.get_number(111);
s.get_marks(75,65);
s.get_grade(‘a’);
s.display();
getch();
}
Output
Roll number
:111
Marks in
sub1 :75
Marks in
sub2 :65
----------
Total :140
----------
Grade in
sports : A
इंहैरिटेन्स के केस मे कंस्ट्रक्टर एवं डिस्ट्रक्टर(Constructor &
Destructor in case of Inheritance)-
जैसा कि जानते है अगर प्रोग्राम में constructor या destructor define नहीं करते है तो compiler स्वयं इसे provide करता है यहां constructor या destructor Inheritance में उपयोग करने के अलग-अलग तरीको का अध्ययन करेंगे।
1. Base class में constructor define किया गया है किन्तु derived class में define नही किया गया ।
Base में base class में define किया गया constructor, derived class से invoke बुलाया जा सकता है । निम्न उदाहरण से इसे स्पष्ट किया किया गया है।
2. Base class तथा derived class दोनों में constructor तथा destructor को define करना।
Base class में यदि constructor तथा destructor define किये जाते है तो derived class constructor को call किया जाता है । तो पहले इसके member का constructor execute होता है अर्थात पहले base class का constructor execute होगा फिर derived का constructor execute होगा। फिर base का constructor execute होगा।
बहुरुपण (Polymorphism)-
Polymorphism Object oriented programming का एक महत्वपूर्ण है। जैसा कि पहले भी पड़ चुके है पाॅलिमाॅर्फिज्म का अर्थ होता है रूपो वाला । की पाॅलिमाॅर्फिज्म ओवरलोडेड फंक्शन तथा आपरेटरो के प्रयोग से कार्यान्वित होता है। ओवरलोडेड सदस्य फंक्शन का तर्क के मिलान के बाद संक्रिया बनाने के लिये चुने जाते है। यह सूचना कम्पाइलर टाइम के दौरान प्राप्त होती है। कम्पाइलर करते समय एक विशेष काॅल के लिये उपयुक्त फंक्शन का चुनाव करता है। इसे प्रक्रिया को स्टैटिक या अरली बाइन्डिंग कहते है।
उदा & Class A
{
int x;
public:
void show(
){……….}
};
class B:
publicA
{
int y;
public:
void show(
){………}
};
अतः प्रोग्राम के कियान्वयान के दौरान उपयुक्त सदस्य फंक्शन का चयन कर लेना चाहिए।इस क्रिया को रन टाइम पाॅलिफाॅर्मिज्म कहते है।
बहुरुपण मुख्यतः दो प्रकार के होते हैं-
1.
Compile Time Polymorphism
2.
Run Time Polymorphism
Compile time polymorphism- Overloding की थी जिसमें प्रोग्राम भाषा सी++ में एक नाम के एक से अधिक फंक्शन प्रोग्राम में बना सकते है। जब इन्हे प्रयोग करने के लिये बुलाया जाता है। तब कम्पाइलर उस फंक्शन के लिये argument संख्या व उनके प्रकार को मिलता है। इस प्रकार फंक्शन बुलाने की क्रिया को compiler time में पूरा कर लिया जाता है।
Run Time Polymorphism-
अनेक बार ऐसी स्थिति आती है कि दो वर्ग,जिनमें हम उत्तराधिकारी कर रहे है, में आधार वर्ग तथा व्युत्पन्न वर्ग दोनों में एक ही नाम एवं prototype वाला फंक्शन प्रयोग किया गया हो। अब यह फंक्शन overload फंक्शन भी नहीं कहा जा सकता, क्योंकि समान नाम व prototype वाले ये दोनों फंक्शन्स को यह ज्ञात नहीं हो पाता है कि इनमें से किस फंक्शन को call किया जाना है ऐसी स्थिति में वांछित फंक्शन को प्रोग्राम के run time पर चुनकर call कराया जाता है और यह क्रिया Run Time Polymorphism कहलाती है ।
Pointer to Object(ऑब्जेक्ट प्वाइंटर)
प्वाइंटर क्लास के द्वारा बनाये गये ऑब्जेक्ट को इंगित करता है। जैसे इस कथन को देखें
sum a;
जहाॅ sum एक क्लास ऑब्जेक्ट जिसका ऑब्जेक्ट a है। इसी प्रकार provision का ही एक प्वाइंटर it-pr परिभाषित कर सकते है इस प्रकार
sum *it_pr;
ऑब्जेक्ट प्वाइंटर रन टाइम में ऑब्जेक्ट के निर्माण में उपयोगी सिद्ध होते है इसके अतिरिक्त हम ऑब्जेक्ट प्वाइंटर का प्रयोग किसी ऑब्जेक्ट के सार्वजनिक सदस्यों को एक्सेस करने में भी कर सकते है निम्नलिखित विधि से एक क्लास item को परिभाषित करते है-
अब sum वेरियेबल x और x का प्वाइंटर pr घोषित करते है। इस प्रकार-
sum x;
sum *pr=&x;
pr प्वाइंटर का मान x के पते address पर संगृहीत हो जाता है।
हम sum के सदस्य फंक्शनों को दो प्रकार से दर्शा सकते है- पहला डाॅट, (.) ऑपरेटर या ऑब्जेक्ट के माध्यम से तथा ऐरो (->) ऑपरेटर या ऑब्जेक्ट प्वाइन्टर से। निम्न कथन -
चूॅकि pr, x का ही एक उपनाम (alias) है। इसे इस प्रकार भी प्रयोग कर सकते है-
(*pr). Show();
ऑब्जेक्ट का निर्माण प्वाइंटर तथा new ऑपरेटर का प्रयोग करके भी कर सकते है जैसे -
sum *pr= new sum
उपरोक्त कथन ऑब्जेक्ट संरचना डाटा सदस्यों के लिए काफी मेमोरी घेरता है तथा pr में मेमोरी स्थान के पता को एसाइन करता है । तब pr निम्न प्रकार से सदस्य को संकेत करता है।
pr= show ( ):
ऑब्जेक्ट के ऐरे (Array of Objects) भी प्वाइंटर की सहायता से बना सकते है। उदाहरण के लिए यह कथन -
sum *pr=new sum {10}
sum के 10 ऑब्जेक्ट के ऐरे के लिए मेमोरी मे जगह बनाता है । निम्न प्रोग्राम ऑब्जेक्ट प्वाइंटर पर आधारित है-
उपरोक्त प्रोग्राम में एक ही आकार के दो ऑब्जेक्ट के लिए गति के रूप से स्थान तैयार किया गया है । परन्तु ऐसी स्थिति हमेशा नहीं हो सकती। उदाहरण के लिए क्लास के वैसे ऑब्जेक्ट जिसमे स्ट्रिंग एक हीं आकार के नहीं होगें । ऐसी स्थिति में हम ऑब्जेक्ट प्वांइटर के ऐरे को परिभाषित कर सकते है। जो एक-एके ऑब्जेक्ट को एक्सेस करने के लिए प्रयोग किया जा सकता जा सकता है। निम्नलिखित प्रोग्राम ऑब्जेक्ट के ऐरे पर आधारित है।
दिस प्वाइंटर (This Pointer)
सी++ this की वर्ड का प्रयोग एक ऑब्जेक्ट को व्यक्त करने के लिए करता है । जो किसी सदस्य को बुलानें का कार्य करता है। this प्वाइंटर उस ऑब्जेक्ट को इंगित करता है जिसके this फंक्शन का आहृवान call किया गया है । उदाहरण के लिए -
निजी वेरियेबल (Private Variable) X का प्रयोग सीधे सदस्य फंक्शन के अंदर हो सकता है। इस प्रकार- x=123;
इस कार्य को this की सहायता से इस प्रकार कर सकते है-
this->*=123;
व्युत्पन्न क्लास प्वाइंटर (Pointer to Derived Class)
आधार क्लास के लिए करने अतिरिक्त व्युत्पन्न के लिए भी कर सकते हैं। आधार क्लास का ऑब्जेक्ट प्वाइंटर व्युत्पन्न क्लास के ऑब्जेक्ट प्वाइंटर के टाइप-अनुकुल होता है । इसीलिए, एक प्वाइंटर वेरियेबल विभिन्न क्लासों से सम्बन्धित ऑब्जेक्ट को इंगित करने के लिए किया जाता है । उदाहरण के लिए क्लास आधार क्लास है तथा इससे व्युत्पन्न क्लास B के लिए प्वांइटर हो सकता हैं।
निम्न घोषणात्मक कथनों देखें-
A*cptr //क्लास A वेरियेबल का प्वांइटर
A a; // आधार ऑब्जेक्ट
B b ; //व्युत्पन्न ऑब्जेक्ट
cpt=&a; //cptr a ऑब्जेक्ट को इंगित करता है।
cptr को ऑब्जेक्ट b को इंगित करने लायक बना सकते है। इस प्रकार
cptr=&b; //cptr b ऑब्जेक्ट को इंगित करता है।
किन्तु cptr के द्वारा व्युत्पन्न क्लास B के सार्वजनिक सदस्यों को अभिगमन करने मे समस्या है। cptr का प्रयोग कर, केवल वैसे सदस्यों को एक्सेस कर सकते है जो क्लास A से वंशानुगत है वैसे सदस्यों को एक्सेस नहीं किया जा सकता जो क्लास B से मूलतः सम्बन्धित है ऐसी स्थिति मे जब B का कोई सदस्य A के किसी सदस्यो मिलता हुआ नाम रखता हो, तब cptr के द्वारा उस सदस्य का कोई भी निर्देशन आधार-क्लास के सदस्य को ही एक्सेस करेगा।
यद्यपि सी++ में कोई आधार प्वांइटर उस आधार क्लास से उत्पन्न क्लास के ऑब्जेक्ट को इंगित कर सकता है, प्वांइटर व्युत्पन्न क्लास के सभी सदस्यों को सीधे-सीधे एक्सेस करने के लिए प्रयोग मे नहीं लाया जा सकता । व्युत्पन्न प्रकार के लिए प्वाइंटर के रूप मे प्रयोग करना पड़ता है।
निम्नलिखित प्रोग्राम व्युत्पन्न ऑब्जेक्ट प्वांइटर के प्रयोग किये जाने को स्पष्ट करता है-
कथन का प्रयोग किया गया है। पहला जब bptr आधार ऑब्जेक्ट को इंगित करता है तथा दूसरा जब bptr से व्युत्पन्न ऑब्जेक्ट को इंगित कराया जाता है। लेकिन दोनों बार BCD*::show( ) फंक्शन को ही क्रियान्वित किया गया तथा आधार ऑब्जेक्ट की सामग्री को प्रदर्शित किया गया है। किन्तु यह कथन
bptr-> show( );
((BCD*)bptr)->show( );
//bptr BCD टाइप डालता है।
व्युत्पन्न ऑब्जेक्ट के डाटा को प्रकट करता है अर्थात् कोई आधार प्वाइंटर व्युत्पन्न ऑब्जेक्ट की किसी भी संख्या को इंगित करने के लिए तैयार किया जा सकता है परन्तु यह व्युत्पन्न क्लास के सदस्यों को सीधे-सीधे एक्सेस नहीं कर सकता है।
वर्चुअल फंक्शन (Virtual Function)
जब कोई फंक्शन एक ही नाम का दोनों क्लास आधार तथा व्युत्पन्न में प्रयोग करते है। तब आधार क्लास का फंक्शन वर्चुअल घोषित किया जाता है। वर्चुअल घोषणा के लिए हम वर्चुअल की-वर्ड का प्रयोग करते है। यह आधार प्वाइन्टर के द्वारा विभिन्न ऑब्जेक्ट को इंगित कराकर वर्चुअल फंक्शन के विभिन्न संस्करणों को कार्यान्वित कर सकते है। निम्नलिखित प्रोग्राम वर्चुवल फंक्शन के प्रयोग की विधि को दर्शाता है।
// Virtual Function
#include <iostream.h>
class B
{
public:
{
viod disp()
{
cout<<”\n Display
base:”;
}
virtual void sh()
{
cout<<”\n show base”;
}
class D:public B
{
public:
void disp( )
{
cout<<”\n Display
derived”;
}
void sh( )
{
cout<<”\n show
derived”;
}
};
int main( )
{
BOB;
DOD;
B *bptr;
cout<<”\n bptr pointer
to Base\”;
bptr=&OB;
bptr->disp ( ); //calls base version
bptr->sh( ); //call base
version
cout<<”\n\nbptr
pointsb to derived \n;
bptr=&OD;
bptr->disp( ); //call base version
bptr->sh( ); //calls
derived version
return 0;
}
Out put
Bptr pointr to base
Display base
Show base
Bptr pointer to derived
Display base
Show derive
वर्चुअल फंक्शन के नियम -
जब वर्चुअल फंक्शन का निर्माण लेट बाइन्डिंग के कार्यान्वयन के लिए किया जाता है तब कुछ मुख्य नियमों का ध्यान कम्पाइलर के आवश्यकतानुसार रखना चाहिये।
1. वर्चुअल फंक्शन आवश्यक रूप से किसी क्लास का सदस्य हो।
2. इन्हे स्थिर सदस्य नहीं होना चाहिये।
3. वे ऑब्जेक्ट प्वाइंटर का प्रयोग कर एक्सेस किये जाए।
4. आधार क्लास में ही वर्चुअल फंक्शन की परिभाषा होनी चाहिए ।
5. वर्चुअल फंक्शन दूसरे क्लास का मित्र हो सकता है।
6. वर्चुअल फंक्शन के नाम तथा प्रोटोटाइप दोनों ही क्लास में एक जैसे होने चाहिए अन्यथा कम्पाइलर इसे ओवरलोड समझकर छोड़ देगा।
7. यदि एक वर्चुअल फंक्शन आधार मे परिभाषित है तो इसे क्लास मे परिभाषित किये जाने की आवश्यकता नहीं। इस स्थिति में काॅल आधार फंक्शन को कार्यान्वित कर देता है।
शुद्ध वर्चुअल फंक्शन (Pure Virtual Function)
सामान्य तौर पर वर्चुवल फंक्शन आधार क्लास के अंदर घोषित किये जाते है तथा इसे पुनः परिभाषित व्युत्पन्न क्लास मे किया जाता है आधार क्लास के अंदर फंक्शन शायद ही किसी कार्य को सम्पन्न करते है। यह केवल इसमें जगह छेकते है अथवा इन्हे कुछ न करने वाला फंक्शन आम बोल चाल की भाषा मे कहतें है इस प्रकार के फंक्शन को इस प्रकार परिभाषित किया जाता है-
virtual viod display ( ) =0;
ऐसे फंक्शन शुद्ध वर्चुअल फंक्शन कहलाते है। शुद्ध वर्चुअल फंक्शन वह फंक्शन है जो आधार क्लास में घोषित किया जाता है तथा जिसका आधार क्लास से कोई सम्बन्ध नहीं होता है। ऐसी स्थिति में कम्पाइलर व्युत्पन्न क्लास में इसे पुनः परिभाषित करने का निर्देश देती है या फिर इसे शुद्ध वर्चुअल फंक्शन के रूप परिभाषित कर दिया जाता है।
अर्ली बाईड़िंग (Early Binding)-
Compiler time के दौरान फंक्शन का चयन अर्ली बाईड़िग अथवा स्टेटिक लिंकेज कहलाता है। काम्पालईयान टाइम के दौरान सी$$ कम्पाइलर यह निर्धारित करता है। कि फंक्शन अथवा उसके रिर्टन टाइम को पास कीये गये पैरामीटर्स आधार पर कौन से फंक्शन का उपयोग करना है। इस तरह से कम्पाइलर आधरित सब्सटिट्यूशन को स्टेटिक लिंकेज कहा जाता है।
लेट बाइड़िग (Late Binding)-
एक्जिक्यूशन टाईम के दौरान फंक्शन का चयन, लेट बाइड़िग अथवा डायनेमिक बाइड़िग अथवा डायनेमिक लिंकेज कहा जाता है। लेट बाइड़िग के लिये कुछ ओवर हेड की आवश्यकता होती है। परंतु इससे पाॅवर और कार्यक्षमता में लचीलापन बढ़ता है। लेट बाइड़िग को वर्चुअल फंक्शन के माध्यम से कार्यान्वित किया जाता है। Class के Object को उस Class के Pointer अथवा रेफरेंस के रूप में डिक्लेयर किया जाना चाहिए।
----------------------------------------------------------------------------------------------
UNIT V
ADVANCE TOPICS
Graphics in C++
C++ में फाइल प्रबन्धन व संचालन
फाइल, सम्बन्धित आकड़ो का समूह होता है, जो डिस्क में एक निश्चित स्थान पर स्थित होता है। इसे एक नाम दिया जाता है, जिसे फाइल का नाम कहा जाता है। फाइल मे संचित आकड़ो को पढ़ा जा सकता है तथा उन्हे सम्पादित भी किया जा सकता है। इस प्रकार के प्रोग्राम के द्वारा दो निम्नांकित कार्य कर सकते हैंः-
1 प्रोग्राम तथा Console Unit के मध्य ऑकड़ा हस्तान्तरण
2 प्रोग्राम तथा Disk पर स्थित फाइल के मध्य ऑकड़ा हस्तान्तरण
प्रोग्रामिंग भाषा सी++ मे फाइल प्रबन्धन console input /output के समान ही हैं। इसमें प्रोग्राम और फाइल के बीच interface के रुप में file stream का प्रयोग किया जाता है। जो stream प्रोग्राम को ऑकड़े प्रदान करती है, उसे input stream तथा जो stream प्रोग्राम से फाइल्स तक ऑकडे पहुचाते का कार्य करती है; उसे Output Stream कहा जाता है।
फाइल को खोलना तथा बन्द करना (Opening and Closing a File):
प्रोग्रामिंग भाषा सी++ में यदि हमंे किसी डिस्क फाइल का प्रयोग करना है, तो इसे खोलने से पहले stream बनाना आवश्यक होता हैं।
सामान्यतः फाइल से सम्बन्धित तीन stream प्रयोग की जाती है।-
Input stream
Output
Stream
Input/Output
streams
इनपुट stream बनाने के लिए ifstream वर्ग तथा आउटनुट stream बनाने के लिए ofstream वर्ग का प्रयोग किया जाता है यदि इनपुट तथा आउटपुट दोनों कार्य करने है। तब fstream वर्ग का प्रयोग करते है।
एक बार stream बनाने के बाद फाइल को stream से जोडा जाता है, तब फाइल काम करने योग्य बनती है, अर्थात फाइल में काम करने के लिए, पहले सम्बन्धित stream बनानी पड़ती है, फिर उस फाइल से लिंक कराना होता हैं, तब फाइल काम करने योग्य बनती है। फाइल खोलने का कार्य निम्नांकित दो प्रकार से किया जाता है-
1 Stream वर्ग का Constructor बनाकर तथा
2 Open() फंक्शन का प्रयोग करके
कन्स्ट्रक्टर का प्रयोग करके फाइल को खोलना(Opening File
Using Constructor)
जैसा कि किसी वर्ग का constructor उस वर्ग के ऑब्जेक्ट को बनाते समय ही प्रारंभिक मान प्रदान कर देता है अर्थात उसे initialize कर देता है, उसी प्रकार stream वर्ग का constructor फाइल stream ऑब्जेक्ट को प्रारंभिक मान प्रदान करता है, इसमे फाइल का नाम पास कराया जाता हैं। इनपुट stream बनाने के लिए निम्न सुत्रानूसार लिखते हैं-
सुत्र-
जैसा कि किसी वर्ग का constuctor उस वर्ग के ऑब्जेक्ट को बनाते समय ही प्रारंभिक मान प्रदान कर देता है अर्थात उसे initialize कर देता है, उसी प्रकार stream वर्ग का constructor फाइल stream ऑब्जेक्ट को प्रारंभिक मान प्रदान करता है, इसमे फाइल का नाम पास कराया जाता हैं। इनपुट stream बनाने के लिए निम्न सुत्रानूसार लिखते हैं-
सुत्र- ifstream in_file (“file_name”);
इसी प्रकार जब फाइल में लिखना होता है, तब फाइल को output stream द्वारा जोड़ा जाता है। जैसेः-ofstream out_file("file_name");
Example-:
#include <iostream.h>
#include<conio.h>
void main ( );
{
clrscr ();
ofstream fout (“student”);// connect student file to
output stream
char name[30];
char ch;
int mark=0;
for(int i=0;<3;i++)
{
cout<<”\n enter”<<i+1<<”student
name:”;
cin.get(name,30);cout<<”enter mark:”;
cin>>mark;
cin.get(ch); //to
clear the buffer
fout<<name<<”\n<<marks<<”|n;
}
fout.close();
Ifstream fin(“student”); //connect to input stream
fin.seekg(0); //comes file pointer at
the beginning of the file
cout<<”\n”;
for(i=0;;i<3;i++)
{
fin.get (name,30); //read
from file
fin.get(ch);
fin>>mark;
fin.get(ch);
cout<<”student name:”<<name;
cout<<”\t marks:”<<marks”\n”;
}
fin.close( );
getch();
}
Output
Enter 1 student name: Shanti
Enter mark:85
Enter 2 student name: Ram Jain
Enter mark:89
Enter 3student name: Ashish Kumar
Enter mark:95
Student name : Shanti mark:85
Student name: Ram Jain mark:89
Student name: Ashish Kumar mark:95
Open ( ) का प्रयोग करके फाइल को खोलनाः
Opening
file Using Open( )
कई बार ऐसी परिस्थिति आती है कि एक से अधिक फाइल्स का प्रयोग करना पड़ता है। यदि प्रोग्रााम में एक ये अधिक फाइल्स को एक साथ खोलना है और उनमें एक साथ काम करना हैं,तो उपरोक्त विधि के अनुसार सबके लिए पृथक पृथक stream बनानी होगी,जो कि समस्याजनक हो सकता है। ऐसे में प्रोग्रामिंग भाषा ’सी++’ एक ही stream पर ही इन फाइल्स पर एक-एक करके कार्य करने की सुविधा प्रदान करती है।
जैसै%& ifstream filein;
filein.open (“student.dat”);
……………………….
………………………..
filein.close ( );
filein.open (“course.dat”)
………………………..
………………………..
filein.close ( );
Example-:
#include<iostream.h>
#include<conio.h>
void main( )
{
clrscr();
ofstream fout;
fout.open(“stu”); //Open stu file & Connect to
Stream
fout<<”\t mansi
goyal\n”<<”\tshiva \n”n<<”\t ravi kumar\n”;
fout.close();
fout.open(“mark”);
fout<<”\t79.45\n”<<”\t64.56\n”<<”\t80.67”;
fout.close();
char line[30];
ifstream fin;
fin.open(“stu”);
fin.open(“stu”);
cout<<”content of stu
file are given below\n”;
fin.getline(line.30);
cout<<line<<”\n”;
fin.getline(line,30);
cout<<line<<”\n;
fin.getline<<(line,30);
cout<<line<<”\n”;
fin.close();
fin.open(“mark”);
cout<<”\n the contents
of mark file \n”;
fin.getline(line,30);
cout<<line<<”\n;
fin.getline (line,30)//given
below
Mansi Goyal
Shiva
Ravi Kumar
The contents of mark file
79.45
64.56
80.67
फाइल का अंत ज्ञात करना
जब किसी आकड़ा फाइल में कार्य करते है, तब फाइल की शुरुआत तथा अन्त का पता लगाना आवश्यक होता है। फाइल के अन्त का पता लगाने के लिए eof( ) सदस्य फंक्शन का प्रयोग किया जाता हैं, जिसका प्रोटोटाइप निम्नानुसार है&
int eof ();
जब फाइल pointer फाइल के अन्त में पहुंच जाता है, तब यह non zero मान return से
& ifstream fin;
fin open
(“stu”;ios::in ! ios :: binary);
while (! Find.eof ())
{
……….
……….
}
If (fun eof ())
cout<<”end of the
file reached !\n”;
उपरोक्त उदाहरण में फाइल पर कार्य तब तक चलेगा, जब तक कि फाइल का अन्त नहीं मिलता है।
Graphics in C++
प्रोग्रामिंग भाषा
प्रोग्रामिंग भाषा ‘सी++‘ टैक्स्ट के साथ Graphic को भी support करती है। इसमें Graphic बनाने के लिए पहले यह ज्ञात होना चाहिए कि माॅनीटर स्क्रीन Graphic mode को support करती है अथवा नहीं अर्थात् Graphic बनाने के लिए माॅनीटर का इन Graphics चित्रो को support करना आवश्यक होता है। Graphics बनाने के लिए प्रोग्रामिंग भाषा ‘सी++’ दो प्रकार के मोड्स उपलब्घ कराती है-टैक्स्ट मोड तथा ग्राफिक मोड। इससे पहले मोड्स के बारे मे जानकारी प्राप्त करते है।
विभिन्न मोड्स
जैसा कि प्रोग्रामिंग भाषा सी++ मुख्यतः दो प्रकार मोड़ ग्राफिक्स के लिए उपलब्ध कराती है-टैकस्ट मोड तथा ग्राफिक मोड। टैक्स मोड मे केवल टैक्स्ट की form को ही बदल सकते है, परन्तु ग्राफिक मोड में विभिन्न प्रकार के ग्राफिक्स बना सकते है।
टैक्स्ट मोड(Text Mode)
जो टैक्स ASCII की calling द्वारा माॅनीटर स्क्रीन पर प्रदर्शित होता है उसे ही टैक्स्ट मोड मे देख सकते है । टैक्स्ट मोड मे माॅनीटर स्क्रीन को दो प्रकारो मे विभाजित किया गया है। पहला 25 rows and 40 columns तथा दूसरा 25 rows and 80 columns टैक्स्ट मोड श्वेत- श्याम अथवा मोनोक्रोम माॅनीटर्स के लिए केवल दो रंग तथा रंगीन माॅनीटर के लिए सोलह रंगो को support करता है। टैक्स्ट मोड के ग्राफिक फंक्शन को प्रयोग करने से पहले, प्रोग्राम मे इनके लिए conio.h हैडर फाइल को include करना आवश्यक होता है। ये फंक्शन निम्न प्रकार है-
Textmode(int)
यह फंक्शन स्क्रीन पर row तथा column set करने के लिए प्रयोग किया जाता है।
उसका सामान्य सूत्र निम्न प्रकार है-
सूत्र- Textmode(int_mode);
जहां पर mode एक int प्रकार का स्थिर मान (Constant value) argument है. यह मान 0,1,2 तथा 3 हो सकता है। यहां पर int mode के स्थान पर 0 के लिए BW40, 1 के लिए C40,2 के लिए BW80 तथा 3 के लिए C80 भी टाइप किया जा सकता है।
जैसे- textmode(2)
या textmode(BW80);
clrscr()
यह फंक्शन माॅनीटर स्क्रीन पर स्थित आंकडा़े आदि को साफ करके को cursor को (1,1) पर स्थित कर देता है। इसका प्रयोग निम्न सूत्रानुसार किया जाता है-
सूत्र- clrscr( ) ;
यह फंक्शन cursor को निर्दिष्ट स्थिति (location) पर पहुचाने के लिए प्रयोग किया जाता है। इसमे दो argument को pass किया जाता है, जिनमे से पहला column के लिए तथा दूसरा row के लिए होता है। इसका प्रयोग निम्न सूत्रानुसार किया जाता है-
gotoxy(int,int)
यह फंक्शन cursor को निर्दिष्ट स्थिति पर पहुचाने के लिए प्रयोग किया जाता है इसमें दो arguments को pass किया जाता है, जिनमे से पहला column के लिए तथा दूसरा row के लिए होता है। इसका प्रयोग निम्न सूत्रानुसार किया जाता है -
सूत्र& gotoxy(int x, inty);
जैसे- gotoxy(5,10);
उपरोक्त स्टेटमेन्ट के द्वारा cursor को पांचवे काॅलम तथा दसवीं पंक्ति (row) पर ले जाया गया है।
उदाहरणः-
#include<iostream.h>
#include<conio.h>
void main
()
{
clrscr();
text mode(BW 40);
cout<<”MLC INSTITUTE KORBA ”;
getch();
textmode(C40);
gotoxy(5,10);
cout<<”MLC COMPUTER INSTITUTE,
KORBA”;
getch();
textmode(BW 80);
gotoxy(25,20);
cout<<” MLC COMPUTER INSTITUTE,
KORBA”;
getch();
}
text background (int)
कोई भी माॅनीटर स्क्रीन text को प्रदर्शित करने के लिए दो layers का प्रयोग करती है, पहली बैकग्राउण्ड तथा दूसरी फोरग्राउण्ड । बैंकग्राउण्ड स्क्रीन पर text को फोरग्राउण्ड के रूप में लिखा जाता है।
टैक्स्ट की बैंकग्राउण्ड को रंग बदलने के लिए textbackground(int) फंक्शन का प्रयोग किया जाता है। इसका प्रयोग निम्न सूत्रानुसार किया जाता है.
सूत्र. textbackground(int_color);
यहां पर argument int_color int प्रकार का मान जो कि 0 से 15 के मघ्य होता है, लेता है।
जैसे - textbackground(6);
उपरोक्त स्टेटमेन्ट के द्वारा टैक्स्ट में int_color के लिए निर्घारित 0 से 15 के मघ्य के मान से कौन सा रंग बनता है, यह निम्नांकित
insline ()
यह फंक्शन cursor की वर्तमान स्थिति(location) पर एक नई लाइन insert करने के लिये प्रयोग किया जाता है।
सूत्र& insline( );
जैसे&gotoxy(5,10);
insline( );
उपरोक्त स्टेटमेंन्ट में पहला स्टेटमेंन्ट कर्सर को पांचवे काॅलम व दसवीं row पर ले जाएगा तथा दूसरा स्टेटमेंन्ट एक खाली लाइन insert कर देगा।
textcolor()
यह फंक्शन टैक्स्ट के फाॅरग्राउण्ड अर्थात टैक्स्ट का रंग बदलने के लिए प्रयोग किया जाता है। इसका प्रयोग निम्न सूत्रानूसार किया जाता है.
सूत्र& textcolor(int_color);
यहां पर argument int_color int प्रकार का मान जो कि 0 से 15 के मध्य होता है़,लेता है।
जैसे& textcolor(3);
उपरोक्त स्टेटमेंन्ट के द्वारा टैक्स्ट को cyan रंग प्रदान किया गया है़।
उदाहरणः-
#include<iostream.h>
#include<graphics.h>
#include<conio.h>
void main()
{
int m,n;
clrscr();
textcolor(3);
textbackground(5);
gotoxy(5,2);
cprintf(“\nEnter two numbers in a line:”);
cin>>n>>m;
gotoxy(10,10);
textbackground(5);
textcolor(3);
cprintf(“\nEntered numbers are %d and %d”,n,m);
getch();
}
deline()
यह फंक्शन एक लाइन मिटाने के लिए प्रयोग किया जाता है। इसका प्रयोग निम्न सूत्रानुसार किया जाता है.
सूत्र deline():
जैसे& gotoxy (5,10):
deline()
ग्राफिक्स मोड (GRAPHIC MODE)
इसके मोड में text के साथ साथ ग्राफिक्स भी देख सकते हैं। ग्राफिक्स मोड का मूलभूत तत्व, मुख्यतः picture elements (जिन्हें pixel भी कहते हैं) होते हैं। माॅनीटर स्क्रीन के resolution को pixel में ही मापा जाता है।
Pixel से ही अच्छे माॅनीटर की पहचान होती है। भिन्न भिन्न मानीटर्स के लिए पिक्सल्स की संख्या भिन्न होती है। ग्राफिक मोड के ग्राफिक फंक्शन्स को प्रयोग करने से पहले, प्रोग्राम में इनके लिए graphic.h हैडर फाइल को include करना आवश्यक होता है। ग्राफिक फंक्शन निम्न प्रकार हैं-
initgraph (int, int, char)
इस फंक्शन का प्रयोग ग्राफिक सिस्टम को initilize करने अर्थात् प्रारम्भिक मान प्रदान करने, graphic driver को load करने तथा video mode (जो graphic function प्रयोग करते है।) को निर्धारित करने के लिये किया जाता है। Graphic Driver को path द्वारा निर्धारित (set) किया जाता है।
जैसे-
int driver, mode;
driver=1;
mode=4;
initgraph(&drive,&mode,”Driver_file_name_with_path”);
Restoercrtmode()
यह फंक्शन intigraph() फंक्शन को call करने से पहले किये गए निर्धारित को store करके रखता है।
सूत्र- Restorecrtmode();
setpalatter(int,int)
यह फंक्शन ग्राफिक के बैकग्राउण्ड रंग को CGA mode में set करता है।
इस फंक्शन का प्रयोग निम्नाकिंत सूत्रानुसार किया जाता है।
सूत्र& setpalatte (int index, int color);
जैसे& setpalette (0, green);
उपरोक्त स्टेटमेंट बैकग्राउण्ड के रंग को ग्रीन निर्धारित कर देता है।
moveto(int, int)
यह फंक्शन माॅनीटर स्क्रीन पर कर्सर को दिए गए co-ordinate pixel पर पहुचा देता है। इस फंक्शन का प्रयोग निम्नाकिंत सूत्रानुसार किया जाता है-
सूत्र & moveto (int x, int y);
जैसे & moveto (100, 150);
उपरोक्त स्टेटमेन्ट में कर्सर को 100 वें काॅलम तथा 150 वीं रो के मिलने वाले बिन्दु पर पहुचाया गया है।
lineto (int, int)
यह फंक्शन मॅानीटर स्क्रीन पर कर्सर की वर्तमान स्थिति को इस फंक्शन में दिए गए x,y co-ordinate तक एक रेखा तैयार करता है। इस फंक्शन का प्रयोग निम्नाकिंत सूत्रानुसार किया जाता हैं।
सूत्र& lineto(int x, int y);
जैसे & lineto (18, 150);
line(int,int,int,int)
यह फंक्शन मॅानीटर स्क्रीन पर, इस फंक्शन में पहले दिए गए दो integer मानों के रेखा का प्रारभिंक बिन्दु मानकर, बाद में दिए गए दो integer मानों को रेखा का अंतिम बिन्दु मानकर, रेखा तैयार करता है। इस फंक्शन का प्रयोग निम्नांकित सूत्रानुसार किया जाता है।
सूत्र line (int x1, int y1, int x2, int y2);
जैसे line (10, 50, 10, 150)
उपरोक्त स्टेटमेन्ट में इस फंक्शन का प्रयोग एक ऊध्र्वाधर रेखा तैयार करने के लिए किया गया हैं।
उदाहरण-
#include<graphics.h>
#include<conio.h>
void main( )
{
int driver,mode;
clrscr();
Driver=DETECT;
initgraph(&driver,&mode,"");
line(80,10,80,500); //Draw a
vertical line
line(10,100,700,100); //Draw a
Horizontal line
line(55c,10,550,500); //Draw a
vertical line
line(10,403,700,403); //Draw a
Horizontal line
moveto(80,100); //Moves
Cursor to 10th column 100th row
line to(550,403); //Draw
a Diagonal line
line to (80,403); //Draw
a Diagonal line
getch();
}
Circle(int,int,int)
यह फंक्शन माॅनीटर स्क्रीन पर,इस फंक्शन में पहले दिये गये दो integer मानो को वृत का केन्द्र बिन्दु मानकर , बाद में दिये integer मान को वृत की त्रिज्या ; (radius) मानकर वृत (circle) तैयार (draw) करता है।
उदाहरण-
#include<graphics.h>
#include<conio.h>
void main()
{
int driver,mode;
clrscr();
Driver=DETECT;
initgraph(&driver,&mode,” “);
setcolor(3);
for (int i=25;i<250;i+=25)
circle(315,240,i) //Draw
Circles With radius difference of 25
pixels up to 249 pixels
getch();
}
सूत्र&line (int x,int y,int r);
arc(int,(int,int,raidus)&
यह फंक्शन माॅनीटर स्क्रीन पर, इस फंक्शन में पहले दिये दो integer मानों को चाप का केन्द्र बिन्दु मानकर, बाद में दिये गए दो integer मानों को चाप का प्रारंभिक एवं अन्तिम बिन्दु को चाप का प्रारम्भिक तथा अन्तिम बिन्दु, जो कि अंशो में दिया जाता है, मानकर, पांचवें integer मान को चाप की त्रिज्या मानकर, चाप तैयार करता है।
इस फंक्शन का प्रयोग निम्नांकित सूत्रानुसार किया जाता हैं-
सूत्र & arc (int x, int y, int start, int end, int radius);
यहॅा पर start तथा end दोनों मान अंशो degree में प्रदान किए जातें है।
जैसें - arc(100, 100, 0,90, 20);
उपरोक्त स्टेटमेंन्ट के द्वारा 100 वें column तथा 100 वीं row के मिलनें वालें बिन्दु को केन्द्र मानकर, 20 pixel की त्रिज्या का 0 degree से 90 degree तक का एक चाप बन जाएगा ।
ellipse (int x, int y, int start, int end, intx_rad, int y_rad):-
यह फंक्शन माॅनीटर स्क्रीन पर, इस फंक्शन में पहले दिए गए दो integer मानों को दीघ् वृत्त का केन्द्र बिन्दु मानकर, बाद में दिए गए दो integer मानो को दीर्घवृत्तीय चाप का प्रारंभिक एंव अन्तिम बिन्दु को चाप का प्रांरम्भिक तथा अन्तिम बिन्दु, जोकि अंशो में दिया जाता है, मानकर, पाॅचवें तथा छठे integer मान को दीर्घवृत्त की क्षैतिज तथा ऊध्र्वाधर त्रिज्या मानकर, दीर्घवृत्त तैयार करता है।
इस QaD’ku का प्रयोग निम्नाकिंत सूत्रानुसार किया जाता है-
सूत्र - ellipse (int x, int y, int start, int end, int x_rad, int y_rad):-
यहां पर start तथा end दोनों मान अंशो degree में प्रदान किए जाते है।
जैसे - ellipse(100] 50] 0] 360] 30] 15)
setfillstyle (int, int):-
यह फंक्शन किसी भी आकृति में पैटर्न भरने तथा आकृति की सीमा रेखा के रंग का निर्धारण करने के लिए प्रयोग किया जाता हैं। इस फंक्शन का प्रयोग निम्नानुसार किया जाता हैः-
सूत्र - setfillstyle (int pattrrn, int color);
यहां पर पैटर्न का स्थिर मान 0 से 11 के मध्य होता है।
जैसे -setfillstyle (2, 5);
floodfill (int x, int y, int border):-
यह फंक्शन किसी बन्द आकृति में रंग भरने के लिए प्रयोग किया जाता हैं। यदि आकृति बन्द नहीं है, तो यह पूरी स्क्रीन पर दिया गया रंग भर देता हैं।
इस फंक्शन का प्रयोग निम्नाकिंत सूत्रानुसार किया जाता हैः-
सूत्र - floodfill (int x, int y, int border)
जैसेs - setcolor (3);
circle
(100,100,50);
floodfill
(100, 100, 3);
उपरोक्त स्टेटमेन्ट्स में एक वृत्त बनेगा जिसमे color code 3 भरा होगा ।
setlinestyle (int, unsigned, int):-
यह फंक्शन किसी रेखा की स्टाइल तथा रेखा की मोटाई का निर्धारण करने के लिए प्रयोग किया जाता है। इस फंक्शन का प्रयोग निम्नाकिंत सूत्रानुसार किया जाता है।
सूत्र - setlinestyle (int style, unsigned pattern, int width);
रेखा का style निम्नाकिंत में से कोई भी एक हो सकता है-
SOLID_LINE
DOTTED_LINE
CENTRE_LINE
DASHED_LINE
USERBIT_LINE
रेखा का style निम्नाकिंत में से कोई भी एक हो सकता है-
NORM_WIDTH
THICK_WIDTH
जैसेs & setlinestyle
(centre_line,I, O, NORM_WIDTH);
Lineto
(100, 150);
Example:-
#include<graphics.h>
#include<conio.h>
void main()
{
clrscr();
int driver=DETECT, mode;
initgraph (&driver, &mode,” ”);
setlinestyle (SOLID_LINE, 0, 3);
// you can see all line styles replacing SOLID_LINE.
Rectangle (450, 350, 150,
150);
Circle (100, 250, 50);
Circle (500, 250, 50);
Line (300, 200, 350, 300);
Line (300, 200, 250, 300);
Line (350, 300, 250, 300);
getch( );
}
Working with Files
Data File को किसी प्रोग्राम के द्वारा भी डिवाइस पर स्टोर किया जा सकता है तथा दूसरे प्रोग्राम के द्वारा उसे पढ़ा या सुधारा जा सकता है तथा आउटपुट डाटा फाईल के रूप में दूसरी फाईल को स्टोर किया जा सकता है जिसे भविष्य में उपयोग में ले सकते है। डाटा संचार करने के दो तरीके होते है।
1- Consol Unit (Keyboard, Screen0 और Program के मध्य डाटा ट्रांसफर.
2- Program और Disk file के मध्य डाटा ट्रांसफर दूसरे तरीके को इस अध्याय में विस्तार से पढ़ेगें।
Data File दो प्रकार की होती है।
1- Sequential Access File
2- Random Access File
1- Sequential Access File :
इसमे data अथवा text को उसी तरह पढ़ा जाता है। जिस तरह उसमें लिख गया है। दैनिक जीवन में Audio Tpe Recoder के सेट में डाले गये गाने क्रम बद्ध रूप से सुनते है तथा Forward और Rewind butten के द्वारा मनचाहे गाने पर पहुचते है इसी प्रकार Sequential file में किसी विशेष डाटा को ढूढ़ना है तो उस फाइल के शुरूआत में पहुचकर क्रमबद्ध तरीके से एक के बाद एक ढूढते हुए उस विशेष डाटा या text पर पहुंचेगे जो चाहिए, दूसरे शब्द मे यह कह सकते है कि यदि चाहा गया विशेष data file की शुरूआत मे हो ढूढने मे समय कम लगेगा और फाइल के अन्त में होते समय अधिक लगेगा। डाटा को ढूढनें में लगने वाले समय को Access tiome कहा जाता है Binary file, Sequential file के अन्तर्गत आती है।
2- Random Access File:
इसमें Data को randomly तरीके से access और process किया जा सकता है दैनिक जीवन में हम इसकी Audio CD से तुलना कर सकते है जिसमे gee न चाहा गाना सरलता से Access कर सकते है चाहे वह किसी भी क्रम मे रखा गया है Random Access file में प्रारम्भ में रखा गया डाटा या अन्त मे रखा गया डाटा तुरंत access किया जा सकता है।
फाईलो को ओपन और क्लोज करना
C++ इनपुट और आउटपुट क्लास पैकेल फाईल I/O को उसी तरह व्यवस्थित करता है। जिस तरह वह अन्य स्टंडर्ड इनपुट और आउटपुट फाईलो को व्यवस्थित करता है। c++ मे फाइलों को पढ़ने और लिखनें के लिए निम्नलिखित पद्धतियाॅं प्रयुक्त होती है
ifstream- एक निर्दिष्ट फाईल से ऑब्जेक्ट की स्ट्रीम को पढ़ना ।
ofstream- एक निर्दिष्ट फाईल पर ऑब्जेक्ट की स्ट्रीम को लिखनां ।
fstream- एक निर्दिष्ट फाईल पर ऑब्जेक्टस की एक स्ट्रींग को पढ़नें और लिखनें के लिए इसका उपयोग करना होता ।
हेडर फाईल fstream.h एक नई क्लास है, जो आधारभूत फाईल ऑपरेशन रूटिन्स और फंक्शनस से मिलकर बनी है।fstream,ifstream और ostream को डिराईव्ड क्लास कहा गया है, क्योकि इस क्लास मे ऑब्जेक्ट्स को <iostream.h> नामक आधारभूत इनपुट और आउटपुट क्लास मे पहले से डिफाईन किया जा चुका है।
फाइल ओपन करना
किसी एक फाइल को दो तरह से ओपन किया जा सकता है । पहला कंस्ट्रक्टर द्वारा और दूसरा Open( ) फंक्शन द्वारा।
निम्नलिखित उदाहरण यह दर्शाते है कि C++ मे फाइलों को पढ़नें और लिखनें के लिए कैसे ओपन किया जाता है। डिस्क में से फाइल को ओपन करने के उद्देश्य से एक फाइल पाॅईटर निर्मित करने के लिए मेंबर फंक्शन का उपयोग किया जाता है।
(a) ifstream:
हेडर फाईल ifstream.h को istream की बेस क्लास से डिराईव किया गया है और इसका उपयोग फाईल से ऑब्जेक्ट्स की स्ट्रीम को पढ़ने के लिए होता है।
उदाहरण के लिए, निम्न लिखित प्रोग्राम सेग्मेंट यह यह दर्शाता है कि निर्दिष्ट फाईल से स्ट्रीम ऑब्जेक्ट की क्लास को पढ़ने के लिए फाईलो केा कैसे ओपन किया जाता है।
(b) ofstream :
हेडर फाईल ofstream को ostream की बेस क्लास से डिराईव किया गया है और इसका उपयोग एक फाईल मे ऑब्जेक्ट के स्ट्रीम को लिखने के लिये किया गया है।
उदाहरण के लिए, निम्नलिखित प्रोग्राम सेग्मेंट यह दर्शाता है कि एक निर्दिष्ट फाईल पर स्ट्रीम ऑब्जेक्ट्स की क्लास को लिखने के लिए फाईल को कैसे ओपन किया जाता है।
(c) fstream:
हेडर फाईल fstream.h को iostream की बेस क्लास से डिराईव किया गया है और इसका उपयोग एक फाईल में ऑब्जेक्ट्स की स्ट्रींम को लिखने और पढ़ने या दोनो के लिए किया जाता है । include<fstream.h> अपने आप हेडर फाईल iostream.h को शामिल करता है।
उदाहरण के लिए, निम्नलिखित प्रोग्राम का सेग्मेंट यह दर्शाता है कि एक निर्दिष्ट फाईल पर स्ट्रीम ऑब्जेक्ट की क्लास को पढ़ने और लिखने के लिए फाईल को कैसे ओपन किया जाता है।
Assignment Questions
//Program for calculator in C++
#include<iostream.h>
#include<conio.h>
class calculate
{
int a,b,c;
void add(int a, int b);
void sub(int a, int b);
void multi(int a, int b);
void div(int a, int b);
};
void calculate :: add(int a, int b)
{
int c;
c=a+b;
cout<<"\nAddition of two number is :"<<c;
}
void calculate :: sub(int a, int b)
{
int c;
c=a-b;
cout<<"\nSubtraction of two number is :"<<c;
}
void calculate :: multi(int a, int b)
{
int c;
c=a * b;
cout<<"\nMultipication of two number is :"<<c;
}
void calculate :: div(int a, int b)
{
int c;
c=a / b;
cout<<"\nDivision of two number is :"<<c;
}
void main()
{
int a,b,c;
clrscr();
cout<<"\nEnter any two Numbers :";
cin>>a>>b;
calculate obj;
obj.add(a,b);
obj.sub(a,b);
obj.multi(a,b);
obj.div(a,b);
getch();
}
================================================
Q2 WAP to show swapping of two numbers using C++
#include<iostream.h>
#include<conio.h>
class swap
{
public:
void swap1(int a, int b)
{
int c;
c=a;
a=b;
b=c;
cout<<"\nAfter Swapping values of a= "<<a<<"b= "<<b;
}
};
void main()
{
int a,b;
clrscr();
cout<<"\nEnter two numbers a & b :";
cin>>a>>b;
cout<<"\nBefore swapping values of a + "<<a<<" b= "<<b<<"\n";
swap s;
s.swap1(a,b);
getch();
}
================================================
Q3 WAP to calculate Volume of Cube, Cylinder, Rectangular box using three Function Overloading in C++
#include<iostream.h>
#include<conio.h>
class function
{
publlic:
//Volume of cube V=s*s*s
//Volume of Cylinder V=3.14*r*2*h
//Volume of Rectangle V=l*h1*w
int cube(int s)
{
return(s*s*s);
}
float cylinder(float r, float h)
{
return (3.14*r*2*h);
}
double rect(double h1,long int l, int w)
{
return(l*h1*w);
}
};
void main()
{
int s, l, w;
float r, h;
double h1;
clrscr();
function obj;
obj.cube(s);
cout<<"\n Enter any number for Volume of Cube :";
cin>>s;
cout<<"\nCube:"<<s*s*s;
cout<<"\n Enter the Radius and Height of Cylinder :";
cin>>r>>h;
obj.cylinder(r,h);
cout<<"\n Cylinder :"<<(3.14*r*2*h);
cout<<"\n Enter the Length Height and Width of Volume of Rectangle: ";
cin>>l>>h1>>w;
obj.rect(l,h1,w);
cout<<"\n Cylinder :" <<(l*h1*w);
getch();
}
================================================================
Q4 WAP using Virtual Function in C++
#include<iostream.h>
#include<conio.h>
#include<string.h>
class book1
{
protected:
char title[80];
float price;
int quantity;
public:
book1(char *s,float a,int q)
{
strcpy(title,s);
price=a;
quantity=q;
}
virtual void disply()
{ }
};
class book : public book1
{
int pages;
public:
book(char *s, float a, int p, int q) : book1(s,a,q)
{
pages=p;
}
void display();
};
class tape : public book1
{
float time;
public:
tape(char *s, float a, float t, int q) : book1(s,a,q);
{
time=t;
}
void display();
};
void book :: display()
{
long int total;
cout<<"\n Title :"<<title;
cout<<"\n Pages :"<<pages;
cout<<"\n Price :"<<price;
cout<<""\n Quantity :"<<quantity;
total=price*quantity;
cout<<"\n Total :"<<total<<" Rs. ";
}
void tape :: display()
{
long int total;
out<<"\n Title :"<<title;
cout<<"\n Play Time :"<<time<<" mins";
cout<<"\n Price :"<<price;
cout<<""\n Quantity :"<<quantity;
total=price*quantity;
cout<<"\n Total :"<<total<<" Rs. ";
}
int main()
{
char * title=new char[30];
float price,time;
int pages, quantity;
clrscr();
cout<<"\nEnter Book Details \n";
cout<<"Title :";
cin>>title;
cout<<"Price:";
cin>>price;
cout<<"Pages :";
cin>>pages;
cout<<"Quantity :";
cin>>quantity;
book book2(title, price, pages, quantity);
cout<<"\nEnter Tape Details \n";
cout<<"Title :";
cin>>title;
cout<<"Price:";
cin>>price;
cout<<"Play Time (mins) :";
cin>>time;
cout<<"Quantity :";
cin>>quantity;
tape tape2(title, price, time, quantity);
book* list[2];
list[0]=&book2;
list[1]=&tape2;
cout<<"\n Media Details :";
cout<<"\n.........Book.......";
list[0]->display();
cout<<"\n...... Tape .......:";
list[1]->ddisplay();
return 0;
getch();
}
================================================================
Q5 WAP using Copy Constructor
#include<iostream.h>
#include<conio.h>
class excopy
{
int num;
public:
excopy() //Constructor
{}
excopy(int a) //Constructor
{
num=a;
}
excopy (excopy &x) //Copy Constructor
{
num=x.num;
}
void display()
{
cout<<num;
}};
int main()
{
clrscr();
excopy A(100); //object A is created and intialized
excopy B(A); //Copy constructor
excopy C=A; //copy constructor and call again
excopy D; //D is created but not initialized
D=A; // Copy constructor not called
cout<<"\n number of A ";
A.display();
cout<<"\n number of B ";
B.display();
cout<<"\n number of C ";
C.display();
cout<<"\n number of D ";
D.display();
getch();
return 0;
disp(int x)
getch();
return 0;
}
====================================
Q10 WAP in C++ to demonstrate the creation and use of
#define maxvalue 10
#define counter 11
void main()
{
float value[maxvalue];
int i,low,high;
int group[counter]={0,0,0,0,0,0,0,0,0,0,0};
===============================================================
Q6 WAP to show multiple Inheritance in C++
#include<iostream.h>
#include<conio.h>
class student
{
protected:
int rollnum;
public:
void getnum(int);
void putnum(void);
};
void student :: getnum(int a)
{
rollnum=a;
}
void student :: putnum(void)
{
cout<<"\nRoll Number:"<<rollnum<"\n";
}
class test
{
protected:
float sub1,sub2;
public:
void getmarks(float,float);
void putmarks(void);
};
void test :: getmarks(float x,float y)
{
sub1=x;
sub2=y;
}
void test :: putmarks()
{
float total;
cout<<" Marks in Subject 1= "<<sub1<<"\n";
cout<<"Marks in Subject 2= "<<sub2<<"\n";
total=sub1+sub2;
cout<<"Total "<<total<<"\n";
}
class result : public student, public test
{
float total;
public:
void display(void);
};
void result :: display(void)
{
putnum();
putmarks();
}
int main()
{
int rollnum;
float sub1,sub2;
clrscr();
result stuobj;
cout<<"\nEnter for Student ";
cin>>rollnum;
stuobj(getnum(rollnum);
cout<<"\nEnter two Subjects Marks :";
cin>>sub1>>sub2;
stuobj.getmarks(sub1,sub2);
stuobj.display();
return 0;
}
================================================================
Q7 WAP to find mean value of two numbers using Friend Function in C++
#include<iostream.h>
#include<coniio.h>
//Friend function it has object as arguments
class example
{
int a,b;
public:
void inputdata()
{
cout<<"\n Enter any two numbers :";
cin>>a>>b;
}
friend float mean(example e);
};
float mean(example e)
{
return(e.a+e.b)/2.0;
}
int main()
{
example obj;
obj.inputdata();
cout<<"\n Mean Value :"<<mean(obj)<<"\n";
getch();
return 0;
}
===============================================================
Q8 WAP using inline Function in C++
#include<iostream.h>
#include<conio.h>
class function1
{
int a,b;
public:
float add(int a, int b);
float sub(int a, int b);
float multi(int a, int b);
float div(int a, int b);
};
inline float add(int a,int b)
{
return(a+b);
}
inline float sub(int a, int b)
{
return(a-b);
}
inline float multi(int a, int b)
{
return(a*b);
}
inline float div(int a, int b)
{
return(a/b);
}
int main()
{
int a,b;
clrscr();
cout<<"\nEnter any two Numbers :";
cin>>a>>b;
cout<<"\nAddition of two numbers : "<<add(a,b)<<"\n";
cout<<"Subttraction of two numbers : "<<sub(a,b)<<"\n";
cout<<"Multiplication of two numbers : "<<multi(a,b)<<"\n";
cout<<"Division of two numbers : "<<div(a,b)<<"\n";
getch()
}
================================================================
Q9 WAP to demonstrate the use Local, Static and Global Object using C++
#include<iostream.h>
#include<conio.h>
class local
{
public:
static s;
void
{
cout<<”\nx=”<<x;
}
};
local g;//creating global object g
int main()
{
local L;
local s;
clrscr();
L.disp(5); //call using local object
s.disp(15); //call using local object
g.disp(10); //using global object
Dynamic Object
#include<iostraem.h>
#include<conio.h>
#include<stdio.h>
class book
{
char booknama[20], authorname[20];
float price, quantity, total;
public:
void read()
{
cout<<"\nEnter Book Name :";
gets(bookname);
cout<<"\nEnter Author Name :";
gets(authorname);
cout<<"\nEnter Price :";
cin>>price;
cout<<"\nEnter Quantity :";
cin>>quantity;
total=price*quantity;
}
void display()
{
cout<<bookname<<"\t\t"<<authorname<<"\t\t"<<price<<"\t\t";
cout<<quantity<<"\t"<<total<<endl;
}
};
void main()
{
book *b;
int num,i;
clrscr();
cout<<"\nEnter Numbers of Order :";
cin>>num;
b=new book[num];
for(i=0;i<num ; i++)
{
b[i].read();
}
cout<<"Book Name "<<"\t"<<"Author Name "<<"\t"<<
"Price "<<"\t"<<"Quantity ";
cout<<"\n-------------------------------------------------------------";
for(i=0;i<num;i++)
{
b[i].display();
delete b;
}
getch();
}
===========================================
Q11 Derive the two classes son and daughter and, demonstrate Polymorphism in action?
#include<iostream.h>
#include<conio.h>
class father
{
protected:
int age;
public:
father(int a) //constructor
{
age=a;
}
virtual void ans()
{
cout<<"\nI am Father. My age is :"<<age;
}
};
class son: public father
{
private:
int age1;
publlic:
son(int x, int y):father(y)
{
age1=x;
}
void ans()
{
cou<<endl<<"\nI am son .My age is :"<<age1;
}
};
class daughter : public father
{
private:
int age2;
public:
daughter (int c, int d): father(d)
{
age2=c;
}
void ans()
{
cout<<"\nI am daughter. My age is :"<<age2;
}
};
void main()
{
clrscr();
father f (65);
son s(25,1);
daughter(22,2);
f.ans();
s.ans();
d.ans();
father *p;
p=&s;
p->ans();
p=&d;
p->ans();
getch();
}
========================================================
//Array in c++
#include<iostream.h>
#include<conio.h>
for(i=0;i<maxvalue;i++)
{
cin>>value[i];
++group[(int)(value[i])/10];
cout<<"\n";
cout<<" Group
Range Frequency \n\n";
for(i=0;i<counter ; i ++)
{
low=i*10;
if(i==10)
high=100;
else
high=low+9;
cout<<"%2d %3d
to %3d %d\n", i+1,low,
high, group[i];
}
getch();
}
========================================================
//Check whether Number is Even or Odd
#include<iostream.h>
#include<conio.h>
class evenodd
{
int num;
public:
void input();
void odd();
void even();
};
void evenodd :: input()
{
cout<<"\nenter any number for checking Even or Odd :";
cin>>num;
}
void evenodd :: odd()
{
if(num%2!=0)
{
cout<<"\n Number is odd ";
}
}
void evenodd :: even()
{
if(num%2==0)
{
cout<<"\nNumber is Even ";
}}
void main()
{
evenodd obj;
clrscr();
obj.input();
obj.odd();
obj.even();
getch();
}
============================================================
//Dynamic initialization of constructor
#include<iostream.h>
#include<conio.h>
class deposite
{
long int pamt;
int year;
float rate;
float rval;
public:
deposite()
{
}
deposite(long int p, int y,float r=0.10);
deposite(long int p,int y,int r);
void disp(void);
};
deposite :: deposite(long int p,int y,float r)
{
pamt=p;
year=y;
rate=r;
rval=pamt;
for(int i=1;i<=y;i++)
{
rval=rval*(1.0+r);
}
}
deposite :: deposite(long int p,int y,int r)
{
pamt=p;
year=y;
rate=r;
rval=pamt;
for(int i=1;i<=y;i++)
{
rval=rval*(1.0+float(r)/100);
}
}
void deposite :: disp(void)
{
cout<<"\nPrincipal Amount ="<<pamt;
cout<<"\nReturn Value ="<<rval;
}
void main()
{
deposite d1,d2,d3;
long int p;
float r;
int y;
int R;
clrscr();
cout<<"\n Enter amount ,period, interest rate percent "<<"\n";
cin>>p>>y>>R;
d1=deposite(p,y,R);
cout<<"\nEnter amount, period, interest rate decimal "<<"\n";
cin>>p>>y>>r;
d2=deposite(p,y,r);
cout<<"\nEnter amount,period "<<"\n";
cin>>p>>y;
d3=deposite(p,y);
cout<<"\nDeposite 1";
d1.disp();
cout<<"\nDeposite 2";
d2.disp();
cout<<"\nDeposite 3"
d3.disp();
getch();
}
============================================================
//Constructor sum of two numbers
#include<iostream.h>
#include<conio.h>
class sum
{
int a,b;
public:
sum(int x,int y)
{
cout<<"\nEnter any two numbers :";
cin>>a>>b;
x=a;
y=b;
cout<<"\na="<<x;
cout<<"\nb="<<y;
}
void disp(void)
{
int c;
c=a+b;
cout<<"\nSum="<<c;
}
};
void main()
{
int a,b;
clrscr();
sum s=sum(a,b);
s.disp();
getch();
}
//E.Balaguru book 5.1 question solution
//bank
deposite program
#include<iostream.h>
#include<conio.h>
class
bank
{
char cust_name[20];
int acc_no;
char acctype;
public:
void value();
void deposite();
void withdraw();
void disp();
};
void
bank :: value()
{
cout<<"\nEnter
customer Name ";
cin>>cust_name;
cout<<"\nEnter
Account Number ";
cin>>acc_no;
cout<<"\nEnter
Type of Account C or S ";
cin>>acctype;
}
void
bank :: deposite()
{
float
depo,bal_amt,tot1=0;
cout<<"\nBalance
Amount ";
cin>>bal_amt;
cout<<"\nDeposite
Amount ";
cin>>depo;
switch
(acctype)
{
case
'C':
case
'c':
bal_amt=bal_amt+depo;
cout<<"\nTotal
Balance Amount "<<bal_amt;
tot1=bal_amt;
break;
case
'S':
case
's':
bal_amt=bal_amt+depo;
cout<<"\nTotal
Balance Amount "<<bal_amt;
tot1=bal_amt;
break;
}
}
void
bank :: withdraw()
{
float
bal,wamt,tot1,tot2;
cout<<"\nTotal
Bal :"<<tot1;
cout<<"\nHow
much withdraw ";
cin>>wamt;
if(wamt>tot1)
{
cout<<"\nYou
can't withdraw Amount :"<<tot1;
}
else
{
bal=tot1-wamt;
cout<<"\nAfter
Withdraw Balance Amount "<<bal;
}
}
void
bank :: disp()
{
float
bal;
cout<<"\nName
:"<<cust_name;
cout<<"\nAfter
Withdraw Balance:"<<bal;
}
void
main()
{
bank
b;
clrscr();
b.value();
b.deposite();
b.withdraw();
b.disp();
getch();
}
=======================================================
//E.Bala
guru swamy 8.3
#include<iostream.h>
#include<conio.h>
#include<iomanip.h>
#include<string.h>
class
staff
{
public:
int
code;
char
name[50];
public:
void
getinfo(char *n,int c)
{
strcpy(name,n);
code=c;
}
};
class
teacher : public staff
{
protected:
char
subject[50],publicat[50];
public:
void
getdetails(char *s,char *p)
{
strcpy(subject,s);
strcpy(publicat,p);
}
void
disp(void)
{
cout<<"\n"<<"Name"<<setw(15)<<"Code"<<setw(15)<<"Subject"<<setw(25)<<
"Publication"<<endl;
cout<<"\n"<<name<<setw(12)<<code<<setw(15)<<subject<<setw(25)<<publicat<<endl;
}
};
class
office : public staff
{
protected:
char
grade[25];
public:
void
getdetails(char *g)
{
strcpy(grade,g);
}
void
disp(void)
{
cout<<"\n"<<"Name"<<setw(15)<<"Code"<<setw(25)<<"Category
"<<endl;
cout<<"\n"<<name<<setw(12)<<code<<setw(22)<<grade<<endl;
}
};
class
typist : public staff
{
protected:
float
speed;
public:
void
getspeed(float s)
{
speed=s;
}
};
class
regular : public typist
{
protected:
float
wages;
public:
void
getwages(float w)
{
wages=w;
}
void
disp(void)
{
cout<<"\n"<<"Code"<<setw(9)<<"Name"<<setw(20)<<"Speed"<<setw(18)<<"Wages"<<endl;
cout<<"\n"<<code<<setw(9)<<name<<setw(20)<<speed<<setw(18)<<wages<<endl;
}
};
class
casual : public typist
{
protected:
float
wages;
public:
void
getwages(float w)
{
wages=w;
}
void
disp(void)
{
cout<<"\n"<<"Code"<<setw(9)<<"Name"<<setw(20)<<"Speed"<<setw(18)<<"Wages"<<endl;
cout<<"\n"<<code<<setw(9)<<name<<setw(20)<<speed<<setw(18)<<wages<<endl;
}
};
void
main()
{
teacher
t;
clrscr();
t.getinfo("Sharma",250);
t.getdetails("C++","Tata
Mc");
office
o;
o.getinfo("Surabhi",111);
o.getdetails("First");
typist
p;
p.getinfo("Sharma",112);
p.getspeed(12.56);
regular
r;
r.getinfo("aaa",56);
r.getspeed(56.89);
r.getwages(12500);
casual
ct;
ct.getinfo("AAA",145);
ct.getspeed(23.56);
ct.getwages(10000);
cout<<"\nAbout
Teacher ";
t.disp();
cout<<"\nAbout
Officer ";
o.disp();
cout<<"\nAbout
Regular Typist ";
r.disp();
cout<<"\nAbout
Casual Typist ";
ct.disp();
getch();
}
=======================================================
//Multiple Inheritance
#include<iostream.h>
#include<conio.h>
class level1
{
protected:
int a;
public:
void geta(int);
};
class level2
{
protected:
int b;
public:
void getb(int);
};
class level3 : public level1, public level2
{
public:
void disp(void);
};
void level1 :: geta(int x)
{
a=x;
}
void level2 :: getb(int y)
{
b=y;
}
void level3 :: disp(void)
{
cout<<"\n a="<<a;
cout<<"\n b="<<b;
cout<<"\n a+b ="<<a+b;
}
int main()
{
level3 L;
int a,b;
clrscr();
L.geta(20);
L.getb(50);
L.disp();
getch();
return 0;
}
=====================================================
//Multilevel Inheritance
#include<iostream.h>
#include<conio.h>
class stu
{
protected:
int roll;
public:
void getnum(int);
void putnum(void);
};
void stu :: getnum(int r)
{
roll=r;
}
void stu :: putnum()
{
cout<<"\nRoll Number :"<<roll;
}
class test :public stu
{
protected:
float mark1;
float mark2;
public:
void getmark(float,float);
void putmark(void);
};
void test :: getmark(float a,float b)
{
mark1=a;
mark2=b;
}
void test :: putmark()
{
cout<<"\nMark 1="<<mark1;
cout<<"\nMark 2="<<mark2;
}
class result : public test
{
float tot;
public:
void disp(void);
};
void result :: disp(void)
{
tot=mark1+mark2;
putnum();
putmark();
cout<<"\nTotal ="<<tot;
}
int main()
{
result r;
clrscr();
r.getnum(100);
r.getmark(75.0,60.0);
r.disp();
getch();
return 0;
}
===============================================
//Hybrid Inheritance
#include<iostream.h>
#include<conio.h>
class stu
{
protected:
int roll;
public:
void getroll(int r)
{
cout<<"\nEnter Roll Number :";
cin>>r;
}
void putroll(void)
{
int r;
cout<<"\nRoll number :"<<r;
}
};
class mark : public stu
{
protected:
float mark1,mark2,mark3;
public:
void getmarks(float,float,float)
{
cout<<"\nEnter marks of three subjects marks :";
cin>>mark1>>mark2>>mark3;
}
void putmarks(void)
{
cout<<"\nMark 1"<<mark1;
cout<<"\nMark 2"<<mark2;
cout<<"\nMark 3"<<mark3;
}
};
class practical
{
protected:
float practmark;
public:
void getprac(float p)
{
cout<<"\nEnter Practical Marks ";
cin>>p;
}
void putprac(void)
{
cout<<"\nPractical Marks :"<<practmark;
}
};
class result : public mark , public practical
{
float total;
public:
void disp(void);
};
void result :: disp(void)
{
total=mark1+mark2+mark3;
putroll();
putmarks();
putprac();
cout<<"\nTotal Marks Obtained :"<<total;
}
void main()
{
result R;
int r;
float m1,m2,m3;
float p;
clrscr();
R.getroll(r);
R.getmarks(m1,m2,m3);
R.getprac(p);
R.disp();
getch();
}
================================================
//Single Inheritance for Simple Interest
#include<iostream.h>
#include<conio.h>
class base
{
int p;
public:
int r,t;
void getdata();
int getp(void);
void disp(void);
};
class der : public base
{
int si;
public:
void simple(void);
void ans(void);
};
void base :: getdata(void)
{
cout<<"\n Enter Principal Amount Rate and Time ";
cin>>p>>r>>t;
}
int base :: getp()
{
return p;
}
void base :: disp()
{
cout<<"\nPrincipal Amount="<<p;
}
void der :: simple()
{
si=getp()*r*t/100;
}
void der :: ans()
{
cout<<"\nPrincipal Amount="<<getp();
cout<<"\nRate="<<r;
cout<<"\nTime="<<t;
cout<<"\nSimple Interest="<<si<<" Rs.";
}
void main()
{
der d;
clrscr();
d.getdata();
d.simple();
d.disp();
d.ans();
d.r=3;
d.t=2;
d.simple();
d.ans();
getch();
}
================================================================
//Single Inheritance
#include<iostream.h>
#include<conio.h>
class A
{
int a;
public:
int b;
void getdata();
int geta(void);
void disp(void);
};
class B : public A
{
int c;
public:
void add(void);
void ans(void);
};
void A :: getdata(void)
{
cout<<"\n Enter any two numbers ";
cin>>a>>b;
}
int A :: geta()
{
return a;
}
void A :: disp()
{
cout<<"\na="<<a;
}
void B :: add()
{
c=b+geta();
}
void B :: ans()
{
cout<<"\na="<<geta();
cout<<"\nb="<<b;
cout<<"\nc="<<c;
}
void main()
{
B s;
clrscr();
s.getdata();
s.add();
s.disp();
s.ans();
s.b=30;
s.add();
s.ans();
getch();
}
================================================================
//Marksheet Program by class
#include<iostream.h>
#include<conio.h>
#include<iomanip.h>
class mark
{
char stu_name[25];
int os,ms,funda,c,tally;
float tot,per;
public:
void input();
void calc();
void output();
void divi();
};
void mark ::input()
{
clrscr();
cout<<"\nEnter your name :";
cin>>stu_name;
cout<<"\nenter Fundamental marks :";
cin>>funda;
cout<<"\nenter Operating system marks :";
cin>>os;
cout<<"\nenter C++ marks :";
cin>>c;
cout<<"\nenter Microsoft Office marks :";
cin>>ms;
cout<<"\nenter Tally marks :";
cin>>tally;
}
void mark :: calc()
{
tot=funda+os+ms+c+tally;
per=(tot/500)*100;
}
void mark :: output()
{
cout<<"\nYour name :"<<stu_name;
cout<<"\nFundamental marks :"<<funda;
cout<<"\nOperating System marks :"<<os;
cout<<"\nC++ marks :"<<c;
cout<<"\nMicrosoft Office marks :"<<ms;
cout<<"\nTally marks :"<<tally;
cout<<"\nTotal Marks Obtained :"<<tot;
cout.precision(3);
cout.width(10);
cout<<"\nPercent :"<<per;
}
void mark :: divi()
{
if (per>=60)
{
cout<<"\nFirst Division ";
}
else
if (per>=45)
{
cout<<"\nSecond Division ";
}
else
if (per>=33)
{
cout<<"\nThird Division ";
}
else
{
cout<<"\nFail ";
}
}
void main()
{
char ans;
mark m1;
clrscr();
do
{
m1.input();
m1.calc();
m1.output();
m1.divi();
cout<<"\nDo you want to continue....y/n ";
cin>>ans;
}while(ans=='y' || ans=='Y');
clrscr();
}
================================================
//E bala guru 7.3
#include<iostream.h>
#include<conio.h>
#include<string.h>
class arth
{
float num;
public:
arth(float num)
{
this->num=num;
}
float operator +(arth a)
{
return(num+a.num);
}
float operator -(arth a)
{
return(num-a.num);
}
float operator / (arth a)
{
return(num/a.num);
}
float operator *(arth a)
{
return(num * a.num);
}
void disp()
{
cout<<num;
}
};
void main()
{
arth a1(20),a2(10);
clrscr();
cout<<"\na=20 b=10 ";
cout<<"\na + b="<<a1+a2;
cout<<"\na - b="<<a1-a2;
cout<<"\na * b="<<a1*a2;
cout<<"\na / b="<<a1/a2;
getch();
}
======================================================
//Copy Constructor
#include<iostream.h>
#include<conio.h>
class code
{
int id;
public:
code()
{
}
code(int a)
{
id=a;
}
code(code &x) //copy constructor
{
id=x.id;
}
void disp(void)
{
cout<<id;
}
};
void main()
{
code ob1(50);
code ob2(ob1);
code ob3=ob1;
code ob4;
ob4=ob3;
clrscr();
cout<<"\nObject 1:";
ob1.disp();
cout<<"\nObject 2:";
ob2.disp();
cout<<"\nObject 3:";
ob3.disp();
cout<<"\nObject 4:";
ob4.disp();
getch();
}
===========================================================
//Simple Interest program by inline function
#include<iostream.h>
#include<conio.h>
inline float si(float p,float r,float t)
{
float s;
cout<<"\nEnter amount, rate and time :";
cin>>p>>r>>t;
s=(p*r*t)/100;
return (s);
}
void main()
{
float p,r,t;
clrscr();
cout<<"Simple Interest "<<si(p,r,t);
getch();
}
========================================================
//Searching of string in my list through Array
of Pointer
#include<iostream.h>
#include<conio.h>
#include<string.h>
#include<ctype.h>
void
main()
{
int
i=0;
char
*ptr[15]={"Reading","Dancing","Singing","Programming"};
char
str[20],*ptr1[20];
char
ans;
clrscr();
do
{
for(i=0;i<4;i++)
{
cout<<ptr[i];
cout<<"\n";
}
cout<<"\nEnter
your hobby:";
cin>>str;
cout<<"\nString
="<<str;
for(i=0;i<4;i++)
{
if(!strcmp(str,ptr[i]))
{
cout<<"\nYour
Hobby is in my list "<<str;
cout<<endl;
break;
}
}
if(i==4)
{
cout<<"\nYour
Hobby is not in my list ";
cout<<endl;
}
cout<<"\nDo
you want to continue y/n....";
cin>>ans;
}while(ans=='y'||ans=='Y');
}
No comments:
Post a Comment