Theory
વિચારથી લખાયેલા code સુધી
સિદ્ધાંત તમને આવડે છે: class એ નકશો છે, object એ એ નકશામાંથી બનેલી ખરેખરી વસ્તુ (class અને object ના પાઠનું Student નું ઉદાહરણ).
હવે canteen ના till ને એનો પહેલો ખરેખરો ઘટક જોઈએ છે: એક Item. દરેક item ને નામ અને ભાવ હોય છે, અને એણે બિલ પર પોતાને છાપવું પડે છે.
આજે તમે એ class લીટીએ લીટીએ લખો છો, અને એ બે વિરામચિહ્ન શીખો છો જે નક્કી કરે છે કે એ compile થાય કે નહીં: એક અર્ધવિરામ અને એક ::.
Formula
પરીક્ષાને જોઈતું હાડપિંજર
class ClassName {
private:
// member variables (the data)
public:
// member functions (the behaviour)
}; <- this semicolon is NOT optional
Member variables વત્તા member functions = members. આ ખોખું બરાબર લખવું એ કોઈ પણ "class declare કરો" ના પ્રશ્નમાં મફતના marks છે.
Practical
Item class, પૂરો અને પ્રામાણિક
#include <iostream>
#include <cstring>
using namespace std;
class Item {
private:
char name[30]; // member variable
double price; // member variable
public:
void setData(const char itemName[], double itemPrice) {
strcpy(name, itemName); // defined INSIDE the class
price = itemPrice;
}
void display(); // only declared here...
};
// ...and defined OUTSIDE, attached with the scope resolution operator ::
void Item::display() {
cout << name << " Rs " << price << endl;
}
int main() {
Item chai; // object created from the class
chai.setData("Chai", 12.5); // members reached with the dot
chai.display(); // prints: Chai Rs 12.5
return 0;
}
Theory
દરેક લીટી શા માટે છે
char name[30]; double price;એ member variables છે: દરેક Item object ને એમની પોતાની નકલ મળે છે.setData(...)એ class ના શરીરની અંદર વ્યાખ્યાયિત member function છે (આવાં functions inline ગણાય છે).- Class ની અંદરનું
display();ફક્ત એક declaration છે, એક વચન. void Item::display() { }એ વચન બહાર પાળે છે.Item::ઉપસર્ગ (scope resolution operator) compiler ને કહે છે કે આ display એ Item નું છે, મુક્ત જગતનું નહીં.
Think first
મનમાં એને અનુસરો
main() બીજો object બનાવે છે: Item dosa; dosa.setData("Dosa", 40); dosa.display();
Tap કરતાં પહેલાં: dosa નો ભાવ બદલવાથી chai નો ભાવ ખોરવાય છે? અને શા માટે કે શા માટે નહીં?
Show the answer
ના. દરેક object member variables ની અલગ નકલ ધરાવે છે: chai નાં name/price અને dosa નાં name/price જુદી memory માં વસે છે. Member functions એક જ વાર અસ્તિત્વમાં હોય છે અને વહેંચાયેલાં હોય છે, પણ એ હંમેશા એ object પર કામ કરે છે જેણે એમને બોલાવ્યાં (ટપકાની આગળનો object). એટલે dosa.display() એ Dosa Rs 40 છાપે છે જ્યારે chai એ Chai Rs 12.5 જ રહે છે.
Quiz
આ code compile થતો નથી: class Item { public: void show(); } void show() { cout << "hi"; } કયા બે સુધારા જોઈએ?
- Class ના બંધ થતા કૌંસ પછી અર્ધવિરામ ઉમેરો, અને function ને void Item::show() તરીકે વ્યાખ્યાયિત કરો
- public specifier કાઢી નાખો, અને show નું નામ બદલીને display કરો
- show() ને class ની ઉપર ખસેડો, અને return 0 ઉમેરો
- ફક્ત અર્ધવિરામ ખૂટે છે; function ની વ્યાખ્યા જેમ છે તેમ બરાબર છે
Show the answer
Class ના બંધ થતા કૌંસ પછી અર્ધવિરામ ઉમેરો, અને function ને void Item::show() તરીકે વ્યાખ્યાયિત કરો
બે અલગ ભૂલો: class નું શરીર }; થી પૂરું થવું જ જોઈએ (ખૂટતું અર્ધવિરામ એ class declare કરવાની સૌથી સામાન્ય ભૂલ છે), અને બહારની વ્યાખ્યા Item::show() હોવી જ જોઈએ, નહીં તો તમે show નામનું એક અસંબંધિત મુક્ત function વ્યાખ્યાયિત કર્યું છે જ્યારે member વ્યાખ્યાયિત વગરનું જ રહી જાય છે. વિકલ્પ D બધાને લલચાવે છે: મુક્ત function compile થાય છે, પણ class ની અંદર આપેલું વચન ક્યારેય પળાતું નથી.
Watch out
વિરામચિહ્નના બે ફાંદા
`};` પછીનું અર્ધવિરામ: એ ભૂલી જવાથી ગૂંચવતી ભૂલો આવે છે જે તમારી file ની પછીની લીટી તરફ આંગળી ચીંધે છે, class તરફ નહીં. Class પછી તરત વિચિત્ર ભૂલ દેખાય, ત્યારે પહેલાં અર્ધવિરામ તપાસો.
ખુલ્લી વ્યાખ્યાઓ: class ની બહારનું void display() {} એ નવું મુક્ત function છે, તમારો member નહીં. ફક્ત void Item::display() {} class સાથે જોડાય છે. બાકી બધું બરાબર હોય તોય ખૂટતા Item:: માટે પરીક્ષકો marks કાપે છે.
Theory
આ class હવે વધવાનો છે
Item જાણી જોઈને સાદો છે. હવે પછીના પાઠોમાં એને એની શ્રેણી માટે enum મળે છે (નાસ્તો, ભોજન, પીણું), પછી constructors જેથી એ સર્જાય એ જ ક્ષણે પોતાને શરૂ કરી લે, અને પછી inheritance ના કુટુંબમાં એક સ્થાન. આ પાઠનું હાડપિંજર માથામાં રાખો: આ વિષયનો દરેક વધુ સમૃદ્ધ class એ જ ખોખું છે, વધુ members સાથે.
Summary
Key takeaways
- class Name { specifiers, members }; થી declare કરો અને છેલ્લું અર્ધવિરામ ક્યારેય ન ભૂલો.
- Member variables data રાખે છે; દરેક object ને એમની પોતાની નકલ મળે છે.
- Member functions વર્તન વ્યાખ્યાયિત કરે છે: class ની અંદર (inline) કે બહાર ClassName:: સાથે.
- :: એ scope resolution operator છે: એ બહારની વ્યાખ્યાને એના class સાથે જોડે છે.
- Name obj; થી objects બનાવો અને ટપકાથી members સુધી પહોંચો: obj.function().
- Memory hook: ખોખું, અર્ધવિરામ, અને ઘરે આવવા માટે ::.