C-and-C++/C2/Tokens/Gujarati

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

Contributors and Content Editors

Jyotisolanki, Krupali, PoojaMoolya, Pratik kamble