Difference between revisions of "C-and-C++/C2/Tokens/Gujarati"
From Script | Spoken-Tutorial
Jyotisolanki (Talk | contribs) |
Jyotisolanki (Talk | contribs) |
||
| Line 1: | Line 1: | ||
{| border=1 | {| border=1 | ||
| − | || ''Time''' | + | || '''Time''' |
|| '''Narration''' | || '''Narration''' | ||
| + | |- | ||
| 00.01 | | 00.01 | ||
| '''Tokens-in-C-and-C-Plus-Plus''' પરનાં સ્પોકન ટ્યુટોરીયલમાં સ્વાગત છે. | | '''Tokens-in-C-and-C-Plus-Plus''' પરનાં સ્પોકન ટ્યુટોરીયલમાં સ્વાગત છે. | ||
Revision as of 16:31, 10 July 2013
| Time | Narration |
| 00.01 | Tokens-in-C-and-C-Plus-Plus પરનાં સ્પોકન ટ્યુટોરીયલમાં સ્વાગત છે. |
| 00.06 | આ ટ્યુટોરીયલમાં આપણે શીખીશું, |
| 00.09 | કેવી રીતે tokens ને વ્યાખ્યાયિત કરવું અને વાપરવું. |
| 00.12 | આપણે એક ઉદાહરણની મદદથી આ કરીશું. |
| 00.15 | આપણે કેટલાક સામાન્ય એરરો અને તેમનાં ઉકેલોને પણ જોઈશું. |
| 00.20 | આ ટ્યુટોરીયલને રેકોર્ડ કરવાં માટે, |
| 00.21 | હું વાપરી રહ્યી છું ઉબુન્ટુ ઓપરેટીંગ સીસ્ટમ 11.10 gcc અને g++ કમ્પાઈલર આવૃત્તિ 4.6.1. |
| 00.33 | ચાલો એક પરીચય વડે શરૂઆત કરીએ |
| 00.37 | Data types, Variables, Constants અને Identifiers માટે ટોકન એક સામાન્ય શબ્દ છે |
| 00.46 | ચાલો આપણા પ્રોગ્રામ સાથે શરૂઆત કરીએ |
| 00.49 | મેં એડીટર પર પહેલાથી જ એક કોડ ટાઈપ કર્યો છે |
| 00.53 | ચાલો હું તે ખોલું. આપણા ફાઈલનું નામ Tokens .c છે એની નોંધ લો. |
| 01.04 | આ પ્રોગ્રામમાં આપણે વેરીએબલોને પ્રારંભિત કરીશું અને તેમની વેલ્યુઓને પ્રીંટ કરીશું. |
| 01.09 | ચાલો હમણાં હું કોડ સમજાવું. આ આપણી હેડર ફાઈલ છે. |
| 01.16 | આ આપણા મુખ્ય ફંક્શનો છે. |
| 01.20 | અહીં, int એક keyword છે |
| 01.22 | કમ્પાઈલર કીવર્ડો નાં અર્થ જાણે છે. |
| 01.26 | a એક ઇન્ટેગર વેરીએબલ છે |
| 01.29 | અમે તેને 2 ની વેલ્યું આપી છે. |
| 01.32 | આને ઇનીશલાઇઝેશન તરીકે સંબોધાય છે. |
| 01.35 | જો એક વેરીએબલને એક વેલ્યુ અપાતી નથી ત્યારે તેને વેરીએબલનું ડીકલેરેશન તરીકે સંબોધવામાં આવે છે. |
| 01.43 | અહીં, b એક અચલ છે. |
| 01.46 | અમે b ને પ્રારંભ કર્યું છે, તેને 4 ની એક વેલ્યુ આપીને. |
| 01.53 | const કીવર્ડને ફક્ત વાંચી શકાય એવાં વેરીએબલ બનાવવાં માટે વાપરવામાં આવે છે |
| 01.58 | કીવર્ડો અને અચલ પર વધુ જાણકારી માટે ચાલો આપણી સ્લાઈડો પર પાછા ફરીએ. |
| 02.06 | Keywords સ્થાયી અર્થો ધરાવે છે જેને બદલી શકાતા નથી |
| 02.11 | Keywords' variable નામો તરીકે વપરાઈ શકતા નથી |
| 02.15 | C માં 32 કી વર્ડો છે |
| 02.18 | કેટલાક નામ છે, auto, break, case, char, const, default, enum extern, વગેરે. |
| 02.28 | Constants સ્થાયી વેલ્યુઓ છે. |
| 02.34 | તે પ્રોગ્રામનાં એક્ઝેક્યુશન દરમ્યાન બદલાતા નથી. constants બે પ્રકારનાં છે,
Numeric constants અને Character constants. |
| 02.45 | હવે આપણા પ્રોગ્રામ પર પાછા આવીએ. |
| 02.47 | અહીં, ફ્લોટ' વેરીએબલ c નો ડેટા પ્રકાર છે. |
| 02.52 | અમે તેને 1.5 ની એક વેલ્યુ આપી છે |
| 02.57 | Data type નિયમસમૂહો સહીત વેલ્યુઓનું એક મર્યાદિત સમૂહ છે |
| 03.05 | અહીં, d એક variable છે |
| 03.07 | Char અને એકલ અવતરણ સૂચિત કરે છે કે આપણે એક character સાથે વ્યવહાર કરી રહ્યા છીએ |
| 03.13 | પરીણામ સ્વરૂપે, d મુલ્ય 'A' ને સંગ્રહીત કરનારી એક character variable છે |
| 03.20 | આ જોવું સરળ છે કે int, double float અને char એ ડેટાપ્રકારો છે |
| 03.30 | a, c અને d variables છે |
| 03.36 | હવે આપણી સ્લાઈડો પર પાછા આવીએ. |
| 03.38 | આપણે ડેટાપ્રકારો અને વેરીએબલ વિશે વધું જાણીશું |
| 03.48 | ચાલો ઇન્ટેગર ડેટાપ્રકાર સાથે શરૂઆત કરીએ |
| 03.51 | આને int તરીકે જાહેર કરાય છે |
| 03.53 | જો આપણને એક ઇન્ટેગર ડેટાપ્રકારને પ્રીંટ કરવું છે, તો આપણે %d ને એક ફોર્મેટ સ્પેસીફાયર તરીકે વાપરીશું. |
| 04.01 | એજ રીતે, આપણે ફ્લોટીંગ પોઈન્ટ ક્રમાંકો માટે ફ્લોટ અને %f ને વાપરીશું |
| 04.09 | કેરેક્ટર ડેટા પ્રકાર માટે, આપણે char અને %c ને વાપરીશું |
| 04.15 | અને બમણા ડેટા પ્રકાર માટે, આપણે double અને %lf ને ફોર્મેટ સ્પેસીફાયર તરીકે વાપરીશું. |
| 04.25 | હવે આપણે ડેટા પ્રકારોની શ્રેણી જોઈશું |
| 04.29 | Integer ડેટા પ્રકાર પાસે આ એક શ્રેણી છે -32,768 થી 32,767 |
| 04.34 | Floating point ડેટા પ્રકાર પાસે આ એક શ્રેણી છે 3.4E +/-38 |
| 04.39 | Character ડેટા પ્રકાર પાસે આ એક શ્રેણી છે -128 થી 127 |
| 04.42 | અને Double પાસે આ એક શ્રેણી છે 1.7E +/-308 |
| 04.48 | વેરીએબલમાં સંગ્રહીત થયેલ વેલ્યુઓ આ શ્રેણી કરતા વધારે અથવા ઓછી ન હોવી જોઈએ. |
| 04.56 | હવે આપણે વેરીએબલો પર જઈશું. |
| 05.00 | વેરીએબલ એક ડેટા નામ છે. |
| 05.03 | તેને ડેટા વેલ્યુ સંગ્રહીત કરવા માટે ઉપયોગમાં લઇ શકાય છે. |
| 05.06 | વેલ્યુઓ બદલી શકે છે જયારે એક પ્રોગ્રામ રન થાય છે. |
| 05.10 | variable ને વાપરતા પહેલા તેને જાહેર કરવું જોઈએ |
| 05.15 | આપણે variables ને અર્થપૂર્ણ નામો આપવાનો પ્રયાસ કરવું જોઈએ |
| 05.19 | ઉદાહરણ છે john, marks, sum વગેરે. |
| 05.24 | હવે આપણા પ્રોગ્રામ પર પાછા જઈએ. |
| 05.27 | અહીં, printf આ ફંક્શન માટે એક identifier નામ છે |
| 05.32 | આપણી સ્લાઈડો પર પાછા આવીએ. ચાલો identifiers વિશે જાણીએ. |
| 05.38 | Identifiers એ વપરાશકર્તાએ વ્યાખ્યાયિત કરેલ નામો છે |
| 05.41 | એક identifier અક્ષરો અને ક્રમાંકોને ધરાવે છે |
| 05.46 | મોટા અને નાના બંને અક્ષરોની પરવાનગી છે |
| 05.51 | પ્રથમ અક્ષર એક વર્ણમાળાનો શબ્દ અથવા અંડરસ્કોર હોવો જોઈએ. |
| 05.55 | હવે આપણા પ્રોગ્રામ પર પાછા આવીએ |
| 05.58 | અહીં અમે વેરીએબલો અને કોનસ્ટંટોને પ્રારંભિત કર્યા છે. અહીં અમે તેને પ્રીંટ કરીએ છીએ. |
| 06.05 | અને આ આપણું રીટર્ન સ્ટેટમેંટ છે. હવે save પર ક્લિક કરો. |
| 06.10 | ચાલો પ્રોગ્રામને એક્ઝેક્યુટ કરીએ |
| 06.12 | તમારા કીબોર્ડ પર Ctrl, Alt અને T કી એકસાથે દાબીને ટર્મીનલ ખોલો. |
| 06.21 | કમ્પાઈલ કરવાં માટે, ટાઈપ કરો gcc tokens.c -o tok, Enter દબાવો |
| 06.30 | એક્ઝેક્યુટ કરવાં માટે, ટાઈપ કરો ./tok |
| 06.35 | આઉટપુટ દ્રશ્યમાન થાય છે. |
| 06.39 | આપણે જોઈ શકીએ છીએ કે અહીં આપણી પાસે દશાંશ બીંદુ પછી છ વેલ્યુઓ છે. |
| 06.44 | અને અહીં આપણી પાસે બે વેલ્યુઓ છે. |
| 06.48 | હવે ચાલો આપણે શોધીએ કે આ કેવી રીતે થયું. આપણા પ્રોગ્રામ પર પાછા આવીએ. |
| 06.54 | આનું કારણ આ કે આપણી પાસે અહીં %.2f છે. |
| 06.59 | આ દર્શાવે છે કે આપણે દશાંશ બીંદુ પછીની ફક્ત બે વેલ્યુઓને જ પ્રીંટ કરી શકીએ છીએ. |
| 07.04 | અહીં મને ત્રણ દશાંશ સ્થાન સાથેનું એક આઉટપુટ જોઈએ છે. |
| 07.09 | ચાલો %.2f ને %.3f થી બદલીએ. |
| 07.16 | હવે Save પર ક્લિક કરો |
| 07.20 | ટર્મીનલ પર પાછા આવીએ. પહેલાની જેમ કમ્પાઈલ કરીએ, એક્ઝેક્યુટ કરીએ. |
| 07.29 | દશાંશ બીંદુ પછી ત્રણ વેલ્યુઓ અહીં આપણે જોઈ શકીએ છીએ. |
| 07.33 | હવે આપણે સમાન પ્રોગ્રામને C++ માં એક્ઝેક્યુટ કરીશું. |
| 07.37 | આપણા પ્રોગ્રામ પર પાછા આવીએ |
| 07.40 | હું અહીં અમુક વસ્તુઓને બદલીશ |
| 07.42 | પહેલા તમારા કીબોર્ડ પર shift+ctrl+s કી એકસાથે દાબો. |
| 07.50 | હવે ફાઈલને એક .cpp એક્સટેંશન સાથે સંગ્રહીત કરો અને save પર ક્લિક કરો |
| 07.58 | ચાલો હેડર ફાઈલને iostream તરીકે બદલીએ |
| 08.03 | હવે using સ્ટેટમેંટનો સમાવેશ કરો અને Save પર ક્લિક કરો. |
| 08.11 | હવે printf સ્ટેટમેંટને cout સ્ટેટમેંટથી બદલી કરો |
| 08.15 | કારણ કે C++ માં આપણે cout<< function નો ઉપયોગ એક લાઈનને પ્રીંટ કરવાં માટે કરીએ છીએ |
| 08.21 | Search for પર ક્લિક કરીને ટેક્સ્ટ વિકલ્પને બદલો |
| 08.28 | અહીં ટાઈપ કરો printf ખુલ્લું કૌંસ “(” |
| 08.33 | અને અહીં આ કોલમમાં ટાઈપ કરો, |
| 08.35 | cout અને બે ખુલ્લા ખૂણાનાં કૌંસ “<<”. હવે Replace All પર ક્લિક કરો અને Close પર ક્લિક કરો. |
| 08.45 | આપણને format specifier /n ની જરૂર નથી |
| 08.50 | ચાલો તેમને રદ્દ કરીએ. હવે અલ્પવિરામને રદ્દ કરો. |
| 08.54 | અને બે ખુલ્લા ખૂણાનાં કૌંસ ટાઈપ કરો. |
| 09.01 | Save પર ક્લિક કરો. હવે બંધ કૌંસને રદ્દ કરો |
| 09.06 | બે ખુલ્લા ખૂણાનાં કૌંસ ફરીથી ટાઈપ કરો. |
| 09.09 | અને બે અવતરણમાં \n ટાઈપ કરો. હવે Save પર ક્લિક કરો. |
| 09.20 | ચાલો પ્રોગ્રામને એક્ઝેક્યુટ કરીએ. ટર્મીનલ પર પાછા આવીએ. |
| 09.24 | કમ્પાઈલ કરવાં માટે, g++ tokens.cpp -o tok 1 ટાઈપ કરો |
| 09.35 | અહીં આપણી પાસે tok1 છે |
| 09.36 | કારણ કે આપણે ફાઈલ tokens.c માટે આઉટપુટ પેરામીટર tok ને ઓવરરાઈટ કરવાં ઈચ્છતા નથી. હવે Enter દબાવો |
| 09.48 | એક્ઝેક્યુટ કરવાં માટે, ./tok1 ટાઈપ કરો. Enter દબાવો |
| 09.55 | આઉટપુટ દ્રશ્યમાન થાય છે. |
| 09.59 | હવે ચાલો અમુક એવાં સામાન્ય એરરો પર જઈએ જેનાં દ્વારા આપણે રૂબરૂ થઇ શકીએ છીએ. |
| 10.03 | આપણા પ્રોગ્રામ પર પાછા આવીએ. ધારોકે અહીં હું b ને એક નવી વેલ્યુ 8 ફરીથી આપીશ. |
| 10.13 | હવે Save પર ક્લિક કરો. ચાલો જોઈએ શું થાય છે. |
| 10.15 | આપણાં ટર્મીનલ પર પાછા આવીએ. ચાલો હું પ્રોમ્પ્ટને સાફ કરું. |
| 10.22 | હવે પહેલાની જેમ કમ્પાઈલ કરો. |
| 10.26 | આપણને આપણી tokens. cpp ફાઈલમાં એક એરર લાઈન ક્રમાંક 7 પર દેખાય છે. |
| 10.32 | ફક્ત વાંચી શકાય એવાં વેરીએબલ b નું એસાઈનમેંટ. |
| 10.36 | આપણા પ્રોગ્રામ પર પાછા આવીએ |
| 10.40 | આનું કારણ આ છે કે b એક કોનસ્ટંટ છે. કોનસ્ટંટ સ્થાયી વેલ્યુઓ હોય છે. |
| 10.46 | તે પ્રોગ્રામનાં એક્ઝેક્યુંશન દરમ્યાન બદલાતા નથી. |
| 10.49 | એટલા માટે તે એક એરર આપી રહ્યું છે. ચાલો એરરને સુધાર કરીએ. |
| 10.54 | આને રદ્દ કરો. Save પર ક્લિક કરો. |
| 10.57 | ચાલો ફરીથી એક્ઝેક્યુટ કરીએ. આપણા ટર્મીનલ પર પાછા આવીએ. |
| 11.01 | પહેલાની જેમ કમ્પાઈલ કરીએ. એક્ઝેક્યુટ કરીએ. હા આ કામ કરી રહ્યું છે. |
| 11.09 | હવે આપણે બીજા એક સામાન્ય એરરને જોઈશું. |
| 11.12 | આપણા પ્રોગ્રામ પર પાછા જઈએ. |
| 11.15 | ધારોકે હું અહીં એક અવતરણ છોડી દઈશ. Save પર ક્લિક કરો. |
| 11.21 | ચાલો એક્ઝેક્યુટ કરીએ. આપણા ટર્મીનલ પર પાછા આવીએ. |
| 11.25 | પહેલાની જેમ કમ્પાઈલ કરીએ. |
| 11.28 | આપણને આપણી tokens. cpp ફાઈલમાં લાઈન ક્રમાંક 9 પર એક એરર દેખાય છે. |
| 11.34 | A ને સ્કોપમાં જાહેર કરાયો ન હતો. આપણા પ્રોગ્રામ પર પાછા ફરીએ. |
| 11.40 | આનું કારણ એ છે કે એક અવતરણમાં આવેલ કંઈપણને એક કેરેક્ટર વેલ્યુ તરીકે ગણવામાં આવે છે. |
| 11.47 | અને અહીં આપણે d ને એક કેરેક્ટર વેરીએબલ તરીકે જાહેર કર્યો છે. |
| 11.53 | ચાલો એરર સુધાર કરીએ. અહીં લાઈન ક્રમાંક 9 પર એક અવતરણ ટાઈપ કરો. |
| 11.59 | હવે Save પર ક્લિક કરો. ચાલો એક્ઝેક્યુટ કરીએ. |
| 12.02 | આપણા ટર્મીનલ પર પાછા આવીએ |
| 12.04 | હવે પહેલાની જેમ કમ્પાઈલ કરો |
| 12.06 | પહેલાની જેમ એક્ઝેક્યુટ કરો. હા આ કામ કરી રહ્યું છે. |
| 12.14 | હવે આપણી સ્લાઈડો પર પાછા આવીએ. |
| 12.15 | સારાંશમાં |
| 12.16 | આ ટ્યુટોરીયલમાં આપણે શીખ્યાં, |
| 12.18 | ડેટા પ્રકારો દા. ત. int, double, float વગેરે. |
| 12.24 | વેરીએબલો દા. ત. int a=2; |
| 12.29 | Identifiers દા. ત. printf() અને |
| 12.34 | Constant દા. ત. double const b=4; |
| 12.40 | એક એસાઈનમેંટ રૂપે |
| 12.41 | સાદુ વ્યાજ ગણતરી કરવાં માટે એક C પ્રોગ્રામ લખો. |
| 12.45 | સંકેત: Simple Interest = principal * rate * time / 100 |
| 12.51 | આ લીંક પર ઉપલબ્ધ વિડીયો જુઓ. http://spoken-tutorial.org /What\_is\_a\_Spoken\_Tutorial |
| 12.54 | તે સ્પોકન ટ્યુટોરીયલ પ્રોજેક્ટનો સારાંશ આપે છે |
| 12.57 | જો તમારી બેન્ડવિડ્થ સારી ન હોય, તો તમે ડાઉનલોડ કરી તે જોઈ શકો છો. |
| 13.01 | સ્પોકન ટ્યુટોરીયલ પ્રોજેક્ટ ટીમ |
| 13.03 | મૌખિક ટ્યુટોરીયલોનાં મદદથી વર્કશોપોનું આયોજન કરે છે |
| 13.07 | જેઓ ઓનલાઈન પરીક્ષા પાસ કરે છે તેમને પ્રમાણપત્રો આપે છે |
| 13.11 | વધુ વિગત માટે, કૃપા કરી contact@spoken-tutorial.org પર સંપર્ક કરો. |
| 13.20 | સ્પોકન ટ્યુટોરીયલ પ્રોજેક્ટ એ ટોક ટુ અ ટીચર પ્રોજેક્ટનો એક ભાગ છે |
| 13.24 | જે આઇસીટી, એમએચઆરડી, ભારત સરકાર દ્વારા શિક્ષણ પર નેશનલ મિશન દ્વારા આધારભૂત છે |
| 13.30 | આ મિશન પર વધુ માહીતી આ લીંક પર ઉપલબ્ધ છે "http://spoken-tutorial.org/NMEICT-Intro". |
| 13.35 | IIT-Bombay તરફથી સ્પોકન ટ્યુટોરીયલ પ્રોજેક્ટ માટે ભાષાંતર કરનાર હું, જ્યોતી સોલંકી વિદાય લઉં છું. જોડાવાબદ્દલ આભાર. |
