View source for Advanced-Cpp/C2/Constructor-And-Destructor/Gujarati

{| border = 1

|'''Time'''
|'''Narration'''

|-
| 00:01
| '''C++''' માં '''Constructors''' (કન્સ્ટ્રકટર્સ) અને '''Destructors''' (ડીસ્ટ્રકટર્સ) પરનાં સ્પોકન ટ્યુટોરીયલમાં સ્વાગત છે.   

|-
| 00:07
| આ ટ્યુટોરીયલમાં આપણે આપેલ વિશે શીખીશું,

|-
| 00:09
|'''Constructors''' (કન્સ્ટ્રકટર્સ)

|-
| 00:10
|કન્સ્ટ્રકટરોનાં પ્રકારો


|-
| 00:12
| '''Destructors''' (ડીસ્ટ્રકટર્સ)

|-
| 00:13
| આપણે આ બધું કેટલાક ઉદાહરણોની મદદથી કરીશું.  

|-
| 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''' દબાવો.

|-
| 05:10
| ટાઈપ કરો '''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''' તરફથી હું, ભરત સોલંકી વિદાય લઉં છું. અમને જોડાવાબદ્દલ આભાર.

|}