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