Difference between revisions of "C-and-C++/C2/Functions/Gujarati"
From Script | Spoken-Tutorial
Jyotisolanki (Talk | contribs) |
Jyotisolanki (Talk | contribs) |
||
| Line 583: | Line 583: | ||
|- | |- | ||
|10.43 | |10.43 | ||
| − | | | + | | એસાઈનમેંટ તરીકે |
|- | |- | ||
Revision as of 17:01, 9 July 2013
| Time' | Narration
|
| 00.01 | Functions in C and C++' પરનાં સ્પોકન ટ્યુટોરીયલમાં સ્વાગત છે. |
| 00.07 | આ ટ્યુટોરીયલમાં આપણે શીખીશું, , |
| 00.10 | ફંક્શન' શું છે |
| 00.12 | ફંક્શનનાં સિન્ટેક્ષ |
| 00.15 | return statement' નું મહત્વ |
| 00.18 | ફંક્શનો પર કેટલાક ઉદાહરણ. |
| 00.20 | આપણે કેટલીક સામાન્ય એરર અને તેના ઉકેલો પણ જોશું. |
| 00.25 | આ ટ્યુટોરીયલને રેકોર્ડ કરવાં માટે, હું વાપરી રહ્યી છું ઉબુન્ટુ ઓપરેટીંગ સીસ્ટમ આવૃત્તિ 11.10 |
| 00.33 | gcc અને g++ કમ્પાઈલર આવૃત્તિ 4.6.1' |
| 00.40 | ફંક્શનોનાં રજૂઆત સાથે ચાલો શરૂઆત કરીએ |
| 00.43 | ફંકશન એક સ્વયં પર્યાપ્ત પ્રોગ્રામ છે જે અમુક ચોક્કસ કાર્યને એક્ઝેક્યુટ કરે છે |
| 00.50 | દરેક પ્રોગ્રામ એક અથવાં એકથી વધારે ફંક્શનો ધરાવે છે |
| 00.56 | એકવાર એક્ઝેક્યુટ થયા પછીથી નિયંત્રણ પોતાની એ જગ્યાએ ફરી પાછું આવશે જ્યાંથી એ એક્સેસ થયું હતું |
| 01.03 | હવે આપણે ફંક્શન માટેનાં સિન્ટેક્ષ જોઈશું |
| 01.18 | ret-type' ડેટા પ્રકારને વ્યાખ્યાયિત કરે છે જે ફંક્શન પાછું આપે છે |
| 01.12 | fun_name' ફંક્શનનું નામ છે |
| 01.16 | parameters' વેરીએબલ નામોની યાદી અને એનાં પ્રકારો છે |
| 01.20 | ફંક્શન માટેનું બીજું એક સિન્ટેક્ષ છે ret_type function name પેરામીટર લીસ્ટ વિના.
|
| 01.30 | આને આર્ગ્યુંમેંટ વિનાનાં ફંક્શનો તરીકે સંબોધાય છે. |
| 01.35 | અને આ આર્ગ્યુંમેંટ સાથેનાં ફંક્શનો તરીકે સંબોધાય છે. |
| 01.40 | ચાલો આપણા પ્રોગ્રામ પર જઈએ |
| 01.43 | મેં એડીટર પર પહેલાથી જ પ્રોગ્રામ ટાઈપ કર્યું છે |
| 01.46 | ચાલો હું તેને ખોલું. |
| 01.50 | આપણા ફાઈલનું નામ void function.c છે એની નોંધ લો, આ પ્રોગ્રામમાં આપણે ફંક્શનનાં મદદથી બે ક્રમાંકોનાં સરવાળાની ગણતરી કરીશું. |
| 02.03 | ચાલો હું કોડ સમજાવું.
|
| 02.06 | આ આપણી હેડર ફાઈલ છે |
| 02.09 | કોઈપણ ફંક્શનને ઉપયોગ કરતાં પહેલા તે વ્યાખ્યાયિત થયેલ હોવી જ જોઈએ |
| 02.14 | અહીં અમે add કહેવાતા એક ફંક્શનને જાહેર કર્યું છે |
| 02.18 | નોંધ લો કે add ફંક્શન કોઈપણ આર્ગ્યુંમેંટ વિનાનું છે |
| 02.22 | અને રીટર્ન પ્રકાર void છે |
| 02.25 | ફંક્શનો બે પ્રકારનાં છે |
| 02.27 | પ્રથમ છે વપરાશકર્તાએ વ્યાખ્યાયિત કરેલ ફંક્શન જે છે આપણું add ફંક્શન અને |
| 02.33 | Pr-defined ફંક્શન જે કે printf અને મુખ્ય ફંક્શન છે |
| 02.39 | અહીં આપણે a અને b ને 2 અને 3 વેલ્યુઓ અસાઈન કરીને પ્રારંભ કરી છે |
| 02.47 | ત્યારબાદ આપણે a વેરીએબલ c જાહેર કર્યું છે |
| 02.51 | આપણે a અને b ની વેલ્યુઓને ઉમેરી છે |
| 02.53 | પરીણામ c માં સંગ્રહીત થયું છે |
| 02.57 | પછી આપણે પરીણામ પ્રીંટ કરીશું. |
| 03.00 | આ આપણું મુખ્ય ફંક્શન છે |
| 03.03 | મુખ્ય ફંક્શનની અંદર, આપણે add ફંક્શનને બોલાવીએ છીએ |
| 03.07 | સરવાળાની ક્રીયા પૂરી થશે અને પરીણામ પ્રીંટ થશે. |
| 03.13 | હવે Save પર ક્લિક કરો |
| 03.15 | ચાલો આપણે પ્રોગ્રામને એક્ઝેક્યુટ કરીએ |
| 03.17 | તમારા કીબોર્ડ પર Ctrl, Alt અને T કી એકસાથે દાબીને ટર્મીનલ વિન્ડો ને ખોલો |
| 03.28 | કમ્પાઈલ કરવાં માટે ટાઈપ કરો |
| 03.29 | 'gcc void function.c -o void અને enter દબાવો |
| 03.40 | એક્ઝેક્યુટ કરવાં માટે, ટાઈપ કરો
./void |
| 03.45 | આઉટપુટ Sum of a and b is 5 આ રીતે દેખાય છે' |
| 03.50 | હવે આપણા પ્રોગ્રામ પર પાછા આવો |
| 03.53 | વિશેષ identifiers ધરાવનાર ફંક્શનો પેરામીટરો અથવા આર્ગ્યુંમેંટો તરીકે સંબોધાય છે |
| 04.00 | હવે આપણે સમાન ઉદાહરણો આર્ગ્યુંમેંટોની સાથે જોઈશું |
| 04.03 | હું અહીં અમુક વસ્તુઓ બદલીશ. તમારા કીબોર્ડ પર shift Ctrl અને S કી એક સાથે દબાવો.. |
| 04.14 | હવે ફાઈલને Function.c તરીકે સંગ્રહીત કરો. Save પર ક્લિક કરો. |
| 04.24 | void' કી શબ્દને int અને (int a, int b) દરમ્યાન સાથે બદલી કરો; |
| 04.34 | save પર ક્લિક કરો
|
| 04.37 | અહીં int a અને int b ફંક્શન add નાં આર્ગ્યુંમેંટો છે |
| 04.44 | હવે આને રદ્દ કરો |
| 04.47 | અહીં a અને b ને પ્રારંભ કરવાની જરૂર નથી. હવે ફરીથી void કીશબ્દને int કીશબ્દ સાથે બદલી કરો અને save પર ક્લિક કરો
|
| 04.58 | ચાલો એક વેરીએબલ સમ ને અહીં જાહેર કરીએ |
| 05.01 | int sum ટાઈપ કરો; |
| 05.05 | enter' દબાવો |
| 05.06 | અને ટાઈપ કરો sum = add(5,4); |
| 05.19 | અહીં આપણે add ફંક્શનને કોલ કરીએ છે. |
| 05.22 | ત્યારબાદ આપણે આર્ગ્યુંમેંટોને 5 અને 4 તરીકે પસાર કરીએ છીએ |
| 05.26 | '5 a માં સંગ્રહીત થશે અને 4 b માં સંગ્રહીત થશે |
| 05.31 | સરવાળાની ક્રીયા પૂરી થશે |
| 05.34 | પાછી આવેલ વેલ્યુ c એ કુલ સરવાળામાં સંગ્રહીત થશે. |
| 05.38 | હવે આ સરવાળાને રદ્દ કરો કારણ કે આપણે ઉપરનાં ફંક્શનને પહેલાથી જ કોલ કર્યું છે |
| 05.44 | અને ટાઈપ કરો |
| 05.45 | return 0; હવે save પર ક્લિક કરો |
| 05.51 | non-void ફંક્શને' રીટર્ન સ્ટેટમેંટને વાપરવું જ જોઈએ જે એક વેલ્યુ પાછી આપે છે |
| 05.58 | ચાલો પ્રોગ્રામને એક્ઝેક્યુટ કરીએ |
| 06.00 | ટર્મીનલ પર પાછા આવીએ |
| 06.03 | gcc function.c -o fun ટાઈપ કરો અને enter દબાવો
|
| 06.13 | એક્ઝેક્યુટ કરવાં માટે
./fun એન્ટર દબાવો |
| 06.19 | આઉટપુટ આપેલ રીતે દેખાય છે |
| 06.21 | The Sum of a & b is 9 |
| 06.25 | NOW WE WILL EXECUTE THE SAME PROGRAM IN C++ |
| 06.29 | આપણા પ્રોગ્રામ પર પાછા આવીએ. હું એજ કોડને ફરીથી એડીટ કરીશ Shift'Ctrl અને S કીને એકસાથે તમારા કીબોર્ડ પર દબાવો
|
| 06.41 | હવે ફાઈલને .cpp એક્સટેંશન સાથે સંગ્રહીત કરો અને save પર ક્લિક કરો |
| 06.47 | ચાલો હેડર ફાઈલને iostream તરીકે બદલીએ |
| 06.52 | હવે using સ્ટેટમેંટનો સમાવેશ કરો. save પર ક્લિક કરો |
| 07.00 | ફંક્શન જાહેરાત C++ માં સમાન છે |
| 07.04 | તો અહીં કંઈપણ બદલવાની જરૂર નથી |
| 07.07 | હવે printf સ્ટેટમેંટને cout સ્ટેટમેંટથી બદલી કરો
|
| 07.13 | ફોર્મેટ સ્પેસીફાયર અને \n ને રદ્દ કરો |
| 07.16 | અલ્પ વિરામ રદ્દ કરો |
| 07.17 | બે ખુલ્લા ખૂણાવાળા કૌંસ ટાઈપ કરો. અહીં બંધ કૌંસને રદ્દ કરો |
| 07.23 | ફરીથી બે ખુલ્લા ખૂણાવાળા કૌંસ ટાઈપ કરો. |
| 07.25 | અને બે અવતરણ ચિન્હમાં backslash n ટાઈપ કરો |
| 07.29 | C++ માં લાઈનને પ્રીંટ કરવાં માટે આપણે cout ફંક્શનને વાપરીએ છીએ |
| 07.34 | હવે save પર ક્લિક કરો |
| 07.37 | ચાલો પ્રોગ્રામને એક્ઝેક્યુટ કરીએ |
| 07.39 | આપણા ટર્મીનલ પર પાછા આવીએ |
| 07.42 | કમ્પાઈલ કરવાં માટે, ટાઈપ કરો g++ function.cpp -o fun1 |
| 07.52 | અહીં આપણી પાસે છે fun1, કારણ કે આપણે ફાઈલ fun.c માટે આઉટપુટ પેરામીટર fun ને ઓવરરાઈટ કરવાં ઈચ્છતા નથી. |
| 08.02 | હવે Enter દબાવો |
| 08.05 | એક્ઝેક્યુટ કરવાં માટે |
| 08.06 | ./fun1 ટાઈપ કરો અને Enter દબાવો |
| 08.12 | આઉટપુટ આપેલ રીતે દેખાય છે: |
| 08.14 | The sum of a & b is 9. |
| 08.16 | આપણે જોઈ શકીએ છીએ કે આઉટપુટ આપણા c કોડની સમાન છે |
| 08.20 | ચાલો અમુક એવાં એરરોને જોઈએ જેનાં દ્વારા આપણે રૂબરૂ થઇ શકીએ. |
| 08.24 | આપણા પ્રોગ્રામ પર પાછા આવીએ. |
| 08.26 | ધારો કે અહીં લાઈન ક્રમાંક-11 પર. હું 4 ની જગ્યાએ x ટાઈપ કરીશ. |
| 08.32 | હું બાકી બચેલ કોડને એવું જ રાખીશ. |
| 08.36 | હવે Save પર ક્લિક કરો |
| 08.38 | ચાલો પ્રોગ્રામને એક્ઝેક્યુટ કરીએ |
| 08.40 | આપણા ટર્મીનલ પર પાછા આવીએ. |
| 08.44 | પહેલાની જેમ ચાલો કમ્પાઈલ કરીએ |
| 08.48 | આપણને એક એરર દેખાય છે |
| 08.50 | x was not declared in this scope'. આપણા પ્રોગ્રામ પર પાછા આવીએ |
| 08.54 | આનું કારણ એ છે કે x એ કેરેક્ટર વેરીએબલ છે |
| 08.58 | અને આપણું add ફંક્શન એક આર્ગ્યુંમેંટ તરીકે integer વેરીએબલ ધરાવે છે |
| 09.04 | તેથી રીટર્ન પ્રકાર અને રીટર્ન વેલ્યુમાં એક ગુંચવણ છે. |
| 09.08 | હવે ચાલો એરરને સુધાર કરીએ |
| 09.10 | અહીં 4 ટાઈપ કરો. Save પર ક્લિક કરો |
| 09.15 | ચાલો એક્ઝેક્યુટ કરીએ |
| 09.17 | આપણા ટર્મીનલ પર પાછા આવીએ. ચાલો હું પ્રોમ્પ્ટને સાફ કરું. |
| 09.21 | ચાલો હું પહેલાની જેમ કમ્પાઈલ કરું, એક્ઝેક્યુટ કરું |
| 09.27 | હા! આ કામ કરી રહ્યું છે |
| 09.29 | હવે આપણે બીજા એક સામાન્ય એરરને જોઈશું. આપણા પ્રોગ્રામ પર પાછા આવીએ |
| 09.34 | અહીં આપણે ફક્ત એક આર્ગ્યુંમેંટને પસાર કરીશું |
| 09.39 | 4 ને રદ્દ કરો |
| 09.40 | Now Click on Save . |
| 09.43 | હવે Save પર ક્લિક કરો. |
| 09.47 | ચાલો પહેલાની જેમ કમ્પાઈલ કરીએ
|
| 09.49 | આપણે એરર જોઈએ છીએ too few arguments to few functions int 'add'
|
| 09.54 | આપણા પ્રોગ્રામ પર પાછા આવીએ.
|
| 09.56 | તમે જોઈ શકો છો અહીં આપણી પાસે બે આર્ગ્યુંમેંટ છે int a અને int b |
| 10.03 | અને અહીંયા આપણે ફક્ત એક આર્ગ્યુંમેંટને પસાર કરી રહ્યા છે. |
| 10.06 | એટલા માટે આ એરર આપી રહ્યું છે |
| 10.09 | ચાલો એરરને સુધાર કરીએ |
| 10.10 | 4 ટાઈપ કરો, save પર ક્લિક કરો |
| 10.13 | ચાલો ફરીથી એક્ઝેક્યુટ કરીએ |
| 10.16 | પહેલાની જેમ કમ્પાઈલ કરીએ, એક્ઝેક્યુટ કરીએ. |
| 10.21 | હા આ કામ કરી રહ્યું છે! હવે આપણી સ્લાઈડ પર પાછા આવીએ |
| 10.26 | સારાંશમાં, આ ટ્યુટોરીયલમાં આપણે શીખ્યા |
| 10.29 | ફંક્શનો |
| 10.31 | ફંક્શનનું સિન્ટેક્ષ' |
| 10.33 | આર્ગ્યુંમેંટ વિનાનાં ફંક્શન: દા. ત. ;void add() |
| 10.37 | આર્ગ્યુંમેંટ સાથેનાં ફંક્શન: દા. ત. ;int add( int a,int b) |
| 10.43 | એસાઈનમેંટ તરીકે |
| 10.45 | એક પ્રોગ્રામ લખો જે ફંક્શનનાં ઉપયોગ વડે એક ક્રમાંકનાં વર્ગની ગણતરી કરે. |
| 10.50 | આ લીંક પર ઉપલબ્ધ વિડીયો જુઓ. http://spoken-tutorial.org /What\_is\_a\_Spoken\_Tutorial |
| 10.53 | તે સ્પોકન ટ્યુટોરીયલ પ્રોજેક્ટનો સારાંશ આપે છે |
| 10.56 | જો તમારી બેન્ડવિડ્થ સારી ન હોય, તો તમે ડાઉનલોડ કરી તે જોઈ શકો છો |
| 11.01 | સ્પોકન ટ્યુટોરીયલ પ્રોજેક્ટ ટીમ |
| 11.03 | સ્પોકન ટ્યુટોરીયલોનાં મદદથી વર્કશોપોનું આયોજન કરે છે |
| 11.07 | જેઓ ઓનલાઈન પરીક્ષા પાસ કરે છે તેમને પ્રમાણપત્રો આપે છે |
| 11.11 | વધુ વિગત માટે, કૃપા કરી contact@spoken-tutorial.org પર સંપર્ક કરો. |
| 11.19 | સ્પોકન ટ્યુટોરીયલ પ્રોજેક્ટ એ ટોક ટુ અ ટીચર પ્રોજેક્ટનો એક ભાગ છે |
| 11.23 | જે આઇસીટી, એમએચઆરડી, ભારત સરકાર દ્વારા શિક્ષણ પર નેશનલ મિશન દ્વારા આધારભૂત છે |
| 11.30 | આ મિશન પર વધુ માહીતી આ લીંક પર ઉપલબ્ધ છે "http://spoken-tutorial.org/NMEICT-Intro" |
| 11.35 | IIT-Bombay તરફથી સ્પોકન ટ્યુટોરીયલ પ્રોજેક્ટ માટે ભાષાંતર કરનાર હું, જ્યોતી સોલંકી વિદાય લઉં છું. |
| 11.39 | જોડાવાબદ્દલ આભાર. |
