Difference between revisions of "Advanced-Cpp/C2/Constructor-And-Destructor/Gujarati"
From Script | Spoken-Tutorial
Jyotisolanki (Talk | contribs) |
PoojaMoolya (Talk | contribs) |
||
| Line 19: | Line 19: | ||
| 00:10 | | 00:10 | ||
|કન્સ્ટ્રકટરોનાં પ્રકારો | |કન્સ્ટ્રકટરોનાં પ્રકારો | ||
| − | |||
|- | |- | ||
| 00:12 | | 00:12 | ||
| − | | '''Destructors''' (ડીસ્ટ્રકટર્સ) | + | | '''Destructors''' (ડીસ્ટ્રકટર્સ), આપણે આ બધું કેટલાક ઉદાહરણોની મદદથી કરીશું. |
| − | + | ||
| − | + | ||
| − | + | ||
| − | + | ||
|- | |- | ||
| Line 163: | Line 158: | ||
| 02:08 | | 02:08 | ||
|અહીં આપણે '''scope resolution operator''' (સ્કોપ રીઝોલ્યુશન ઓપરેટર) વાપરીને કન્સ્ટ્રકટર એક્સેસ કરી શકીએ છીએ. | |અહીં આપણે '''scope resolution operator''' (સ્કોપ રીઝોલ્યુશન ઓપરેટર) વાપરીને કન્સ્ટ્રકટર એક્સેસ કરી શકીએ છીએ. | ||
| − | |||
|- | |- | ||
| Line 363: | Line 357: | ||
|- | |- | ||
| 05:09 | | 05:09 | ||
| − | | '''Enter''' દબાવો. | + | | '''Enter''' દબાવો. ટાઈપ કરો '''dot slash def''' |
| − | + | ||
| − | + | ||
| − | + | ||
| − | + | ||
|- | |- | ||
Revision as of 10:42, 23 February 2017
| Time | Narration |
| 00:01 | C++ માં Constructors (કન્સ્ટ્રકટર્સ) અને Destructors (ડીસ્ટ્રકટર્સ) પરનાં સ્પોકન ટ્યુટોરીયલમાં સ્વાગત છે. |
| 00:07 | આ ટ્યુટોરીયલમાં આપણે આપેલ વિશે શીખીશું, |
| 00:09 | Constructors (કન્સ્ટ્રકટર્સ) |
| 00:10 | કન્સ્ટ્રકટરોનાં પ્રકારો |
| 00:12 | Destructors (ડીસ્ટ્રકટર્સ), આપણે આ બધું કેટલાક ઉદાહરણોની મદદથી કરીશું. |
| 00:17 | આ ટ્યુટોરીયલ રેકોર્ડ કરવા માટે, હું વાપરી રહ્યો છું |
| 00:20 | ઉબુન્ટુ ઓપરેટીંગ સીસ્ટમ આવૃત્તિ 11.10, |
| 00:23 | g++ કમ્પાઈલર આવૃત્તિ 4.6.1 |
| 00:28 | ચાલો કન્સ્ટ્રકટરોનાં પરીચયથી શરૂઆત કરીએ. |
| 00:31 | Constructor (કન્સ્ટ્રકટર) એ એક મેમ્બર ફંક્શન છે. |
| 00:33 | તે ક્લાસ નામ જેવું જ નામ ધરાવે છે. |
| 00:37 | કન્સ્ટ્રકટરો વેલ્યુઓ પાછી આપી શકતા નથી. |
| 00:40 | જેમ એક ઓબજેક્ટ બને છે ત્યારે તે આપમેળે બોલાવવામાં આવે છે. |
| 00:44 | કન્સ્ટ્રકટરોનાં પ્રકારો : |
| 00:46 | Parameterized Constructors (પેરામીટરાઈઝ્ડ કન્સ્ટ્રકટર્સ) |
| 00:49 | Copy Constructors (કોપી કન્સ્ટ્રકટર્સ) |
| 00:50 | અને Default Constructors (ડીફોલ્ટ કન્સ્ટ્રકટર્સ) |
| 00:53 | ચાલો Destructors (ડીસ્ટ્રકટર્સ) પર જઈએ. |
| 00:56 | 'ડીસ્ટ્રકટરોનો ઉપયોગ ફાળવણી કરેલ મેમરીને રદ્દ કરવા માટે થાય છે. |
| 00:59 | જ્યારે એક ઓબજેક્ટ નષ્ટ પામે છે ત્યારે તેને બોલાવવામાં આવે છે. |
| 01:02 | ડીસ્ટ્રકટર કોઈપણ આર્ગ્યુંમેંટ લેતું નથી અને તેનાં કોઈપણ રીટર્ન પ્રકારો નથી. |
| 01:07 | કન્સ્ટ્રકટરો અને ડીસ્ટ્રકટરો પર ઉદાહરણ જોઈએ, |
| 01:11 | એડીટર પર મેં પહેલાથી જ કોડ ટાઈપ કરી દીધો છે, હું તે ખોલીશ. |
| 01:15 | આપણી ફાઈલનું નામ cons હાયફન dest ડોટ cpp છે તેની નોંધ લો. |
| 01:20 | આ પ્રોગ્રામમાં આપણે કન્સ્ટ્રકટરનો ઉપયોગ કરી બે ક્રમાંકોનો સરવાળો કરીશું. |
| 01:25 | ચાલો અત્યારે હું કોડ સમજાવું. |
| 01:27 | iostream તરીકે આ આપણી હેડર ફાઈલ છે |
| 01:30 | અહીં આપણે std namespace વાપર્યું છે. |
| 01:33 | આપણી પાસે છે ક્લાસ Addition. a અને b આ ઇન્ટીજર વેરીએબલો છે. |
| 01:38 | આ ક્લાસ Addition નાં પ્રાઈવેટ મેમ્બરો છે. |
| 01:42 | અહીં આપણી પાસે Public specifier (પબ્લિક સ્પેસીફાયર) છે. |
| 01:44 | આપણી પાસે છે કન્સ્ટ્રકટર Addition |
| 01:47 | કન્સ્ટ્રકટરનું નામ ક્લાસ નામની જેવું જ છે. |
| 01:52 | અહીં આપણે બે આર્ગ્યુંમેંટો પસાર કરી છે. |
| 01:54 | હવે આપણે એક ડીસ્ટ્રકટર વ્યાખ્યિત કર્યું છે. |
| 01:57 | આ માટે આપણે વાપરીએ છીએ ઝૂલતું ડેશ ચિન્હ અને તે આગળ ડીસ્ટ્રકટરનું નામ. |
| 02:02 | આ છે પબ્લિક ફંક્શન add (એડ). |
| 02:05 | આ a અને b નો સરવાળો પાછો આપે છે. |
| 02:08 | અહીં આપણે scope resolution operator (સ્કોપ રીઝોલ્યુશન ઓપરેટર) વાપરીને કન્સ્ટ્રકટર એક્સેસ કરી શકીએ છીએ. |
| 02:12 | a અને b આ પ્રાઇવેટ મેમ્બરો છે. |
| 02:15 | પ્રાઇવેટ મેમ્બરોને એક્સેસ કરવા માટે આપણે x અને y વાપરીએ છીએ. |
| 02:19 | આપણે એક્સેસ કરીએ છીએ ડીસ્ટ્રકટર. |
| 02:21 | આમાં આપણે પ્રીંટ કરીએ છીએ Memory Deallocation (મેમરી ડીએલોકેશન). |
| 02:25 | આ આપણું મુખ્ય ફંક્શન છે. |
| 02:28 | અહીં આપણે ક્લાસ Addition નું ઓબજેક્ટ obj બનાવીએ છીએ. |
| 02:32 | ત્યારબાદ આપણે 3 અને 4 તરીકે બે આર્ગ્યુંમેંટો પસાર કરીએ છીએ. |
| 02:36 | x માં 3 સંગ્રહીત થશે અને y માં 4 સંગ્રહીત થશે. |
| 02:40 | આનો અર્થ એ કે a ની વેલ્યુ 3 છે અને b ની વેલ્યુ 4 છે. |
| 02:45 | એવા કન્સ્ટ્રકટર જેની પાસે આર્ગ્યુંમેંટો છે તેને પેરામીટરાઈઝ્ડ કન્સ્ટ્રકટર કહેવાય છે. |
| 02:50 | તેથી આ વાળું એ પેરામીટરાઈઝ્ડ કન્સ્ટ્રકટર છે. |
| 02:53 | અહીં આપણે ઓબજેક્ટ obj નો ઉપયોગ કરીને ફંક્શન add બોલાવીએ છીએ. |
| 02:58 | અને આપણે સરવાળાને પ્રીંટ કરીએ છીએ. |
| 03:00 | આ આપણું રીટર્ન સ્ટેટમેંટ છે. |
| 03:02 | પ્રોગ્રામ એક્ઝીક્યુટ કરીએ. |
| 03:05 | તમારા કીબોર્ડ પર Ctrl, Alt અને T કી એકસાથે દાબીને ટર્મિનલ વિન્ડો ખોલો. |
| 03:12 | કમ્પાઈલ કરવા માટે ટાઈપ કરો, g++ space cons hyphen dest dot cpp space hyphen o space cons |
| 03:21 | Enter દબાવો |
| 03:23 | ટાઈપ કરો dot slash cons |
| 03:25 | Enter દબાવો |
| 03:27 | આઉટપુટ આપેલ રીતે દ્રશ્યમાન થાય છે |
| 03:29 | Sum is 7 અને Memory Deallocation |
| 03:33 | હવે ચાલો ડીફોલ્ટ કન્સ્ટ્રકટર્સ પર એક ઉદાહરણ જોઈએ. |
| 03:37 | આપણા પ્રોગ્રામ પર પાછા આવો. |
| 03:39 | કોડ મેં પહેલાથી જ ટાઈપ કરી દીધો છે. |
| 03:41 | આપણી ફાઈલનું નામ default dot cpp છે તેની નોંધ લો |
| 03:45 | જો ક્લાસમાં કન્સ્ટ્રકટર જાહેર કરાયો નથી તો, |
| 03:48 | કમ્પાઈલર ક્લાસ માટે ડીફોલ્ટ કન્સ્ટ્રકટર ધારી લે છે. |
| 03:53 | ચાલો હું કોડ સમજાવું. |
| 03:55 | iostream તરીકે આ આપણી હેડર ફાઈલ છે. |
| 03:58 | અહીં આપણે std namespace વાપર્યું છે. |
| 04:02 | ત્યારબાદ આપણી પાસે છે class Subtraction (ક્લાસ સબટ્રેક્શન). |
| 04:04 | ત્યારબાદ આપણી પાસે a અને b પબ્લિક તરીકે જાહેર થયેલ છે. |
| 04:08 | અહીં આપણી પાસે sub ફંક્શન છે. |
| 04:10 | આપણે બે આર્ગ્યુંમેંટો int a અને int b પસાર કરી છે. |
| 04:15 | આ બે ક્રમાંકો a અને b ની બાદબાકી પાછી આપે છે. |
| 04:19 | આ ડીફોલ્ટ કન્સ્ટ્રકટર છે. |
| 04:22 | અહીં આપણે સ્કોપ રીઝોલ્યુશન ઓપરેટર ઉપયોગ કરીને ડીફોલ્ટ કન્સ્ટ્રકટર એક્સેસ કરીએ છીએ. |
| 04:27 | આ આપણું મુખ્ય ફંક્શન છે. |
| 04:29 | આમાં આપણે વેરીએબલ x વ્યાખ્યિત કર્યું છે. |
| 04:34 | અહીં આપણે ક્લાસ subtraction નું object s બનાવીએ છીએ. |
| 04:39 | ત્યારબાદ આપણે object s વાપરીને ફંક્શન sub બોલાવીએ છીએ. |
| 04:42 | અને 8 અને 4 તરીકે બે આર્ગ્યુંમેંટો પસાર કરીએ છીએ. |
| 04:47 | ત્યારબાદ વેરીએબલ x માં પરિણામ સંગ્રહીત થાય છે. |
| 04:51 | અને અહીં આપણે તફાવતને પ્રીંટ કરીએ છીએ. |
| 04:54 | આ આપણું રીટર્ન સ્ટેટમેંટ છે. |
| 04:56 | હવે ચાલો પ્રોગ્રામ એક્ઝીક્યુટ કરીએ. |
| 04:58 | આપણા ટર્મિનલ પર પાછા આવીએ. |
| 05:01 | ચાલો કમ્પાઈલ કરીએ ટાઈપ કરો g++ space default dot cpp space hyphen o space def |
| 05:09 | Enter દબાવો. ટાઈપ કરો dot slash def |
| 05:12 | 'Enter દબાવો. |
| 05:14 | આપેલ રીતે આઉટપુટ પાછું મળે છે |
| 05:16 | Difference is 4 |
| 05:18 | આપણા પ્રોગ્રામ પર પાછા આવીએ. |
| 05:20 | અહીં તમે જોઈ શકો છો કે આર્ગ્યુંમેંટો ફંક્શન અંતર્ગત પસાર કરી છે. |
| 05:25 | અને આપણા પહેલાનાં ઉદાહરણમાં આપણે આર્ગ્યુંમેંટો ઓબજેક્ટ અંતર્ગત પસાર કરી છે. |
| 05:30 | અને અહીં આપણે ઓબજેક્ટનો ઉપયોગ કરીને આર્ગ્યુંમેંટો પસાર કરી છે. |
| 05:34 | હવે ચાલો આપણી સ્લાઈડ પર પાછા જઈએ. |
| 05:38 | ચાલો સારાંશ લઈએ, આ ટ્યુટોરીયલમાં આપણે શીખ્યા, |
| 05:41 | Constructors (કન્સ્ટ્રકટર્સ) ઉ.દા. Addition |
| 05:43 | Parameterized Constructor (પેરામીટરાઈઝ્ડ કન્સ્ટ્રકટર) ઉ.દા. Addition obj (3, 4); |
| 05:48 | Destructors (ડીસ્ટ્રકટર્સ) ઉ.દા. ~Addition |
| 05:52 | Default Constructor (ડીફોલ્ટ કન્સ્ટ્રકટર) ઉ.દા. Subtraction |
| 05:55 | એસાઇનમેંટ તરીકે, Division નામનો એક ક્લાસ બનાવો. |
| 05:59 | ક્લાસ માટે એક કન્સ્ટ્રકટર બનાવો. |
| 06:01 | અને ફંક્શન divide બનાવો જે આપેલ બે ક્રમાંકોને ભાગ કરે. |
| 06:06 | નીચે આપેલ લીંક પર ઉપલબ્ધ વિડીયો નિહાળો. |
| 06:09 | તે સ્પોકન ટ્યુટોરીયલ પ્રોજેક્ટનો સારાંશ આપે છે. |
| 06:11 | જો તમારી પાસે સારી બેન્ડવિડ્થ ન હોય તો, તમે વિડીયો ડાઉનલોડ કરીને જોઈ શકો છો. |
| 06:16 | સ્પોકન ટ્યુટોરીયલ પ્રોજેક્ટ ટીમ, સ્પોકન ટ્યુટોરીયલોનાં ઉપયોગથી વર્કશોપોનું આયોજન કરે છે. |
| 06:21 | જેઓ ઓનલાઈન પરીક્ષા પાસ કરે છે તેઓને પ્રમાણપત્રો આપે છે. |
| 06:25 | વધુ વિગતો માટે, કૃપા કરી, |
| 06:27 | contact@spoken-tutorial.org પર લખો. |
| 06:31 | સ્પોકન ટ્યુટોરીયલ પ્રોજેક્ટ ટોક ટુ અ ટીચર પ્રોજેક્ટનો એક ભાગ છે. |
| 06:36 | જેને આઈસીટી, એમએચઆરડી, ભારત સરકાર મારફતે શિક્ષણ પર નેશનલ મિશન દ્વારા આધાર અપાયેલ છે. |
| 06:42 | આ મિશન પર વધુ માહિતી નીચે દર્શાવેલ લીંક પર ઉપલબ્ધ છે. |
| 06:47 | IIT Bombay તરફથી હું, ભરત સોલંકી વિદાય લઉં છું. અમને જોડાવાબદ્દલ આભાર. |
