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

Time	Narration
00:01	C અને C++ માં ટોકન્સ પરનાં સ્પોકન ટ્યુટોરીયલમાં સ્વાગત છે.
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,enum extern, વગેરે.
02:28	Constants, 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 and replace text પર ક્લિક કરો.
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 was not declared in the scope. પ્રોગ્રામ પર પાછા ફરીએ.
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