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

From Script | Spoken-Tutorial
Jump to: navigation, search
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++ માં, true0 કરતાં અન્ય કોઈ બીજી વેલ્યુ છે.
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 જો ab કરતા નાનો હોય, ત્યારે એક્સપ્રેશન આગળ ઉકેલાશે નહી.
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