C-and-C++/C2/Logical-Operators/Gujarati

Time	Narration
00.02	C અને C++ માં લોજીકલ ઓપરેટર પરનાં સ્પોકન ટ્યુટોરીયલમાં સ્વાગત છે.
00.08	આ ટ્યુટોરીયલમાં આપણે આપેલ વિશે શીખીશું: લોજીકલ ઓપરેટરો જેમ કે && લોજીકલ એન્ડ ઉ.દા. expression1 && expression2
00.17	લોજીકલ ઓર ઉ.દા. expression1 || expression2
00.21	! લોજીકલ નોટ ઉ.દા. !(Expression1)
00.25	આપણે આ ઉદાહરણોની મદદથી કરીશું.
00.28	આ ટ્યુટોરીયલ રેકોર્ડ કરવા માટે, હું ઓપરેટિંગ સિસ્ટમ તરીકે ઉબુન્ટુ 11.10,
00.34	ઉબુન્ટુમાં gcc અને g++ કમ્પાઇલર આવૃત્તિ 4 .6.1 નો ઉપયોગ કરી રહ્યી છું.
00.40	ચાલો લોજીકલ ઓપરેટરોનાં પરિચય સાથે શરૂઆત કરીએ.
00.44	C and C++ માં, true એ 0 કરતાં અન્ય કોઈ બીજી વેલ્યુ છે.
00.49	શૂન્ય ન હોવાનો અર્થ true છે
00.51	Non zero = True, શૂન્ય એટલે false, Zero = False
00.53	એક્સપ્રેશન જે લોજીકલ ઓપરેટરોનો ઉપયોગ કરે છે તે true માટે 1 અને false માટે 0 રીટર્ન કરે છે.
00.59	હવે હું ઉદાહરણની મદદથી લોજીકલ ઓપરેટરો સમજાવીશ.
01.04	અહીં C માં લોજીકલ ઓપરેટરો માટેનો પ્રોગ્રામ છે.
01.09	main બ્લોકની અંદર
01.11	આ સ્ટેટમેંટ a,b અને c વેરીએબલોને ઇન્ટીજર તરીકે જાહેર કરે છે.
01.16	printf સ્ટેટમેંટ યુઝરને a,b અને c ની વેલ્યુઓ દાખલ કરવા માટે પ્રોમ્પ્ટ કરે છે.
01.22	scanf સ્ટેટમેંટ યુઝર પાસેથી a,b અને c વેરીએબલો માટે ઈનપુટ લે છે.
01.28	અહીં, આપણે મહત્તમ વેલ્યુ શોધવા માટે વેલ્યુ a ની તુલના વેલ્યુ b અને c સાથે કરી રહ્યા છીએ.
01.33	એકસાથે તુલના કરવા માટે, આપણે લોજીકલ એન્ડ ઓપરેટરનો ઉપયોગ કરીએ છીએ.
01.38	અહીં, લોજીકલ એન્ડ true વેલ્યુ return કરે એ માટે તમામ કંડીશનોનું true હોવું જરૂરી છે.
01.44	false કંડીશન મળવા પર એક્સપ્રેશન આગળ ઉકેલાશે નહી.
01.49	આમ, (a>c) એક્સપ્રેશન ફક્ત ત્યારે જ ઉકેલાશે જયારે (a>b) true હોય છે.
01.57	જો a એ b કરતા નાનો હોય, ત્યારે એક્સપ્રેશન આગળ ઉકેલાશે નહી.
02.03	જો પહેલાની કંડીશન true હોય તો આ સ્ટેટમેંટ ઉકેલાય છે.
02.07	આગળ (b>c) ઉકેલાય છે.
02.10	જો કંડીશન true હોય, તો સ્ક્રીન પર b is greatest એવું દર્શાવાશે.
02.17	નહી તો સ્ક્રીન પર c is greatest એવું દર્શાવાશે.
02.21	આપણે હવે લોજીકલ ઓર ઓપરેટર પર આવીશું.
02.24	અહીં, લોજીકલ ઓર true વેલ્યુ return કરે એ માટે કોઈપણ એક કંડીશનનું true હોવું જરૂરી છે.
02.31	true મળ્યા પછી એક્સપ્રેશન ઉકેલવા માટે આગળ વધતું નથી.
02.36	તેથી, જો a == zero, ત્યારે બચેલા બે એક્સપ્રેશન ઉકેલાશે નહી.
02.43	જો a, b કે c માંનું કોઈપણ 0 હોય તો printf સ્ટેટમેંટ એક્ઝીક્યુટ થાય છે.
02.49	પ્રોગ્રામનાં અંતમાં આવીએ. return 0 અને બંધ કર્લી કૌંસ.
02.54	હવે પ્રોગ્રામને સંગ્રહીત કરો.
02.58	તેને .c એક્સ્ટેંશન સાથે સંગ્રહીત કરો.
03.00	મેં મારી ફાઈલને logical.c તરીકે સંગ્રહી છે.
03.04	Ctrl, Alt અને T કી એકસાથે દબાવી ટર્મીનલ ખોલો.
03.09	કોડને કમ્પાઈલ કરવા માટે ટાઈપ કરો gcc logical.c -o log એન્ટર દબાવો
03.23	એક્ઝીક્યુટ કરવા માટે ./log ટાઈપ કરો
03.27	એન્ટર દબાવો.
03.30	હું આપેલ રીતે વેલ્યુઓ દાખલ કરીશ, 0 34 567
03.40	આઉટપુટ આ રીતે દેખાશે,
03.43	c is greatest.
03.46	The product of a, b and c is zero.
03.50	તમારે આ પ્રોગ્રામ ઇનપુટ્સના જુદા જુદા સમૂહ સાથે એક્ઝીક્યુટ કરવાનો પ્રયાસ કરવો જોઈએ.
03.55	હવે ચાલો સમાન પ્રોગ્રામ C++ માં લખીએ.
03.59	મેં પહેલેથી જ પ્રોગ્રામ લખ્યો છે અને આપણે તે મારફતે જશું.
04.03	અહીં C++ નો કોડ છે.
04.07	હવે C++ માં સમાન પ્રોગ્રામ બનાવવા માટે, આપણે અમુક ફેરફારો કરીશું.
04.12	અહીં હેડર ફાઈલમાં ફેરફાર છે.
04.15	Using સ્ટેટમેંટ વપરાયું છે.
04.18	એ સાથે જ આઉટપુટ અને ઈનપુટ સ્ટેટમેંટોમાં પણ તફાવત છે.
04.22	ઓપરેટરો સમાન રીતે વર્તન કરશે જેમ તેમણે C માં કર્યું હતું.
04.26	Save પર ક્લિક કરો.
04.27	ખાતરી કરો કે ફાઈલ .cpp એક્સ્ટેંશન સાથે સંગ્રહીત થયેલ છે.
04.31	Ctrl, Alt અને T કી એકસાથે દબાવી ટર્મીનલ ખોલો.
04.37	પ્રોગ્રામને કમ્પાઈલ કરવા માટે ટાઈપ કરો g++ logical.cpp -o log1
04.49	એક્ઝીક્યુટ કરવા માટે ટાઈપ કરો ./log1
04.54	Enter દબાવો.
04.56	હું આપેલ રીતે વેલ્યુઓ દાખલ કરીશ. 0 34 567
05.02	તો આપણે જોઈએ છીએ કે આઉટપુટ C પ્રોગ્રામ સમાન છે.
05.05	તમારે આ પ્રોગ્રામ, ઇનપુટ્સનાં જુદા જુદા સમૂહ સાથે પણ એક્ઝીક્યુટ કરવાનો પ્રયાસ કરવું જોઈએ.
05.10	હવે ચાલો એરર જોઈએ જેનાંથી આપણે રૂબરૂ થઇ શકીએ.
05.13	એડીટર પર જાવ.
05.16	માની લો કે અહીં આપણે કૌંસ ભૂલી ગયા છીએ.
05.20	આ અને આ રદ્દ કરો.
05.26	ચાલો જોઈએ કે શું થશે, પ્રોગ્રામને સંગ્રહો.
05.31	ટર્મીનલ પર પાછા આવીએ
05.33	પહેલાની જેમ કમ્પાઈલ અને એક્ઝીક્યુટ કરીએ
05.38	આપણને એરર દેખાય છે:
05.41	Expected identifier before '(' token.
05.46	આ એટલા માટે કારણ કે અહીં આપણી પાસે બે જુદા જુદા એક્સપ્રેશન છે
05.49	આપણે તેને એન્ડ ઓપરેટરની મદદથી એક એક્સપ્રેશન તરીકે ઉકેલવું પડશે.
05.53	ચાલો હવે આપણા પ્રોગ્રામ પર જઈએ અને એરરને સુધારીએ
05.58	કૌંસને અહીં અને અહીં દાખલ કરો.
06.04	Save પર ક્લિક કરો
06.07	ટર્મીનલ પર પાછા આવીએ.
06.09	ચાલો પહેલાની જેમ કમ્પાઈલ કરીએ અને એક્ઝીક્યુટ કરીએ
06.14	તો આ કામ કરી રહ્યું છે.
06.22	ચાલો હવે ટ્યુટોરીયલનો સારાંશ લઈએ.
06.24	આ ટ્યુટોરીયલમાં આપણે શીખ્યા && લોજીકલ એન્ડ વિશે ઉ.દા. ((a > b) && (a > c))
06.32	લોજીકલ ઓર વિશે ઉ.દા. (a == 0 || b == 0 || c == 0)
06.40	એસાઇનમેંટ
06.41	યુઝર પાસેથી બે ક્રમાંકો ઇનપુટ તરીકે લેતો પ્રોગ્રામ લખો.
06.45	નોટ ઓપરેટરની મદદથી તપાસ કરો કે બે ક્રમાંકો સરખા છે કે નથી. સંકેત: (a != b)
06.54	નીચે આપેલ લીંક ઉપર ઉપલબ્ધ વિડીઓ જુઓ.
06.57	તે સ્પોકન ટ્યુટોરીયલ પ્રોજેક્ટ માટે સારાંશ આપે છે.
06.59	જો તમારી પાસે સારી બેન્ડવિડ્થ ન હોય તો, તમે ડાઉનલોડ કરી તે જોઈ શકો છો
07.03	સ્પોકન ટ્યુટોરીયલ પ્રોજેક્ટ ટીમ * સ્પોકન ટ્યુટોરીયલોની મદદથી વર્કશોપ આયોજિત કરે છે.
07.08	જેઓ ઓનલાઇન પરીક્ષા પાસ કરે છે તેમને પ્રમાણપત્ર આપે છે.
07.11	વધુ વિગતો માટે, contact at spoken hyphen tutorial dot org પર સંપર્ક કરો.
07.18	સ્પોકન ટ્યુટોરીયલ પ્રોજેક્ટ એ ટોક ટુ અ ટીચર પ્રોજેક્ટનો એક ભાગ છે
07.21	જે આઇસીટી, એમએચઆરડી, ભારત સરકાર દ્વારા શિક્ષણ પર નેશનલ મિશન દ્વારા આધારભૂત છે.
07.27	આ મિશન વિશે વધુ માહીતી આ લીંક ઉપર ઉપલબ્ધ છે:
07.30	spoken hyphen tutorial dot org slash NMEICT hyphen Intro
07.37	આઈઆઈટી બોમ્બે તરફથી ભાષાંતર કરનાર હું, જ્યોતી સોલંકી વિદાય લઉં છું. જોડાવા બદ્દલ આભાર.

Contributors and Content Editors

Jyotisolanki, Krupali, Pratik kamble