C-and-C++/C2/Relational-Operators/Gujarati
From Script | Spoken-Tutorial
| Time' | Narration |
| 00:02 | C અને C++ માં રીલેશનલ ઓપરેટર્સ પરના સ્પોકન ટ્યુટોરીયલમાં તમારું સ્વાગત છે. |
| 00:07 | આ ટ્યુટોરીયલમાં આપણે શીખીશું: |
| 00;09 | રીલેશનલ ઓપરેટર્સ જેવા કે, |
| 00:12 | લેસ ધેન : ઉ.દા. a < b |
| 00:15 | ગ્રેટર ધેન : ઉ.દા. a > b |
| 00:18 | લેસ ધેન ઓર ઇકવલ ટુ : ઉ.દા. a <= b |
| 00:23 | ગ્રેટર ધેન ઓર ઇકવલ ટુ : ઉ.દા. a >= b |
| 00:28 | ઇકવલ ટુ : ઉ.દા. a == b |
| 00:31 | નોટ ઇકવલ ટુ : ઉ.દા. a != b |
| 00:38 | આ ટ્યુટોરીયલ રેકોર્ડ કરવા માટે, ઓપરેટિંગ સિસ્ટમ તરીકે હું ઉબુન્ટુ 11.10, |
| 00:43 | ઉબુન્ટુમાં gcc અને g++ કમ્પાઇલર આવૃત્તિ 4 .6.1 નો ઉપયોગ કરી રહ્યી છું. |
| 00:50 | ચાલો પરિચય સાથે શરૂ કરીએ. |
| 00:53 | રીલેશનલ ઓપરેટરો ઈન્ટીજર અને ફ્લોટિંગ પોઇન્ટ નંબરોની તુલના કરવા માટે વપરાય છે. |
| 00:58 | એક્સપ્રેશન જે રીલેશનલ ઓપરેટરોનો ઉપયોગ કરે છે તે false માટે 0 અને true માટે 1 return કરે છે.
Return વેલ્યુઝ: 0 જયારે False હોય, 1 જયારે True હોય. |
| 01:04 | હવે હું એક C પ્રોગ્રામની મદદ સાથે રીલેશનલ ઓપરેટરોનું નિદર્શન કરીશ. |
| 01:10 | મેં પહેલેથી જ પ્રોગ્રામ બનાવ્યો છે. |
| 01:11 | તો, હું એડિટર ખોલીશ અને કોડ સમજાવીશ. |
| 01:16 | પ્રથમ આપણે બે વેરિયેબલો જાહેર કરીશું, a અને b. |
| 01:21 | આ printf સ્ટેટમેન્ટ યુઝરને a અને b ની વેલ્યુ દાખલ કરવા માટે પૂછે છે. |
| 01:27 | આ scanf સ્ટેટમેન્ટ વેરિયેબલો a અને b માટે ઇનપુટ લે છે. |
| 01:33 | હવે આપણી પાસે ગ્રેટર ધેન ઓપરેટર છે. |
| 01:35 | આ ઓપરેટર ઓપરેટરની બીજી બાજુ પરના બે ઓપેરેન્ડને સરખાવે છે. |
| 01:39 | તે ફોલ્સ રીટર્ન કરશે જો a એ b કરતાં મોટું છે. |
| 01:44 | ઉપરોક્ત કન્ડીશન સાચી હોય તો આ printf સ્ટેટમેન્ટ એક્ઝીક્યુટ થશે. |
| 01:48 | જો ઉપરોક્ત કન્ડીશન ખોટી છે તો તે છોડવામાં આવશે. |
| 01:51 | પછી કન્ટ્રોલ આગામી સ્ટેટમેન્ટ ઉપર જશે. |
| 01:54 | હવે આપણી પાસે લેસ ધેન ઓપરેટર છે. |
| 01:56 | આ પણ ઓપેરેન્દ્સ સરખાવે છે. |
| 01:58 | તે true રીટર્ન કરશે જયારે a એ b કરતા નાનું હોય. |
| 02:03 | ઉપરોક્ત કન્ડીશન સાચી હોય તો આ printf સ્ટેટમેન્ટ એક્ઝીક્યુટ થશે. |
| 02:07 | નહી તો છોડવામાં આવશે. |
| 02:09 | ચાલો અહીં સુધી કોડ એક્ઝીક્યુટ કરીએ. |
| 02:13 | પ્રથમ નીચેનાને કમેન્ટ કરો. ટાઇપ કરો, /* */ |
| 02:24 | Save ઉપર ક્લિક કરો. |
| 02:26 | મેં ફાઈલને relational.c તરીકે સંગ્રહી છે. |
| 02:30 | Ctrl, Alt અને T કી એકસાથે દબાવી ટર્મિનલ વિન્ડો ખોલો. |
| 02:36 | કમ્પાઈલ કરવા માટે, ટર્મિનલ ઉપર આ કમાંડ ટાઇપ કરો gcc relational.c -o rel |
| 02:50 | Enter ડબાઓ. |
| 02:52 | એક્ઝીક્યુટ કરવા માટે ટાઇપ કરો, ./rel, Enter ડબાઓ.
|
| 02:58 | મેં a માટે 8 અને b માટે 3 દાખલ કર્યું છે. |
| 03:02 | આઉટપુટ પ્રદર્શિત થયું છે: |
| 03:04 | 8 is greater than 3. |
| 03:07 | તમે અલગ અલગ વેલ્યુઝ સાથે આ કોડ એક્ઝીક્યુટ કરી પ્રયાસ કરી શકો છો. |
| 03:12 | કોડ ઉપર પાછા આવો. |
| 03:14 | અહીંથી કમેન્ટ રદ કરો અને અહીં મૂકો. |
| 03:24 | હવે આપણી પાસે લેસ ધેન ઇકવલ ટુ ઓપરેટર છે. |
| 03:29 | આ ઓપરેટર ઓપરેટરની બીજી બાજુ પરના બે ઓપેરેન્દ્સ સરખાવે છે. |
| 03:33 | તે true રીટર્ન કરશે જો a એ b કરતા નાનું અથવા બરાબર હોય. |
| 03:39 | ઉપરોક્ત કન્ડીશન સાચી હોય તો આ printf સ્ટેટમેન્ટ એક્ઝીક્યુટ થશે. |
| 03:43 | જો ઉપરોક્ત કન્ડીશન ખોટી હશે તો તે છોડવામાં આવશે. |
| 03:46 | કંટ્રોલ પછી આગળના સ્ટેટમેંટ પર થશે. |
| 03:50 | આગળ ગ્રેટર ધેન ઓર ઇકવલ ટુ ઓપરેટર છે. |
| 03:53 | તે a અને b સરખાવે છે અને true રીટર્ન કરે છે જો a એ b કરતાં મોટું અથવા બરાબર હોય. |
| 04:01 | જો કન્ડીશન true હોય તો આ printf સ્ટેટમેન્ટ એક્ઝીક્યુટ થશે. |
| 04:05 | હવે ચાલો કોડ અહીં સુધી એક્ઝીક્યુટ કરીએ. |
| 04:08 | Save ઉપર ક્લિક કરો. |
| 04:10 | ટર્મિનલ ઉપર ફરી જાઓ. |
| 04:12 | પહેલા મુજબ કમ્પાઈલ અને એક્ઝીક્યુટ કરો. |
| 04:17 | હું a માટે 8 અને b માટે 3 દાખલ કરીશ. |
| 04:23 | આઉટપુટ પ્રદર્શિત થાય છે: |
| 04:25 | 8 is greater than or equal to 3 |
| 04:30 | હવે બાકીના કોડ ઉપર પાછા આવો. |
| 04:33 | અહીં અને અહીંથી મલ્ટી લાઈન કમેન્ટ રદ કરો. |
| 04:43 | આપણી પાસે હવે ઇકવલ ટુ ઓપરેટર છે. |
| 04:47 | તે ડબલ ઇકવલ ટુ (==) ચિહ્નો દ્વારા સૂચિત થયેલ છે. |
| 04:50 | આ ઓપરેટર true રીટર્ન કરે છે જયારે બંને ઓપેરેન્દ્સ એક બીજા સાથે સમાન હોય. |
| 04:57 | આ printf સ્ટેટમેન્ટ એક્ઝીક્યુટ થશે જયારે a એ b સમાન હશે. |
| 05:01 | જો નહિં, તો કંટ્રોલ આગળના સ્ટેટમેન્ટ પર જશે. |
| 05:06 | તેવી જ રીતે, આપણી પાસે નોટ ઇકવલ ટુ ઓપરેટર છે. |
| 05:09 | આ ઓપરેટર true રીટર્ન કરશે જયારે ઓપેરેન્દ્સ એક બીજા સાથે સમાન નથી. |
| 05:15 | આ printf સ્ટેટમેન્ટ એક્ઝીક્યુટ થશે જયારે a એ b સમાન નથી. |
| 05:21 | પ્રોગ્રામના અંતે આવીએ.
Return 0; |
| 05:24 | Save ઉપર ક્લિક કરો. |
| 05:26 | ટર્મિનલ ઉપર ફરી જાઓ. |
| 05:28 | પેહલા મુજબ કમ્પાઈલ અને એક્ઝીક્યુટ કરો. |
| 05:33 | a માટે 8 અને b માટે 3 દાખલ કરો. |
| 05:39 | આઉટપુટ સ્ક્રીન પર દર્શાવવામાં આવે છે: |
| 05:41 | 8 is not equal to 3 |
| 05:45 | તો, આપણે જોયું કે રીલેશનલ ઓપરેટરો કેવી રીતે કાર્ય કરે છે. |
| 05:48 | ઇનપુટ્સના અલગ સમૂહ સાથે આ કોડ એક્ઝીક્યુટ કરવાનો પ્રયાસ કરો. |
| 05:52 | હવે, C++ માં આ સમાન પ્રોગ્રામ લખવો સરળ છે. |
| 05:56 | સિન્ટેક્ષમાં થોડો તફાવત છે. |
| 06:00 | મેં પહેલેથી જ C++ માં પ્રોગ્રામ લખ્યો છે. |
| 06:04 | રીલેશનલ ઓપરેટરો માટે C++ માં કોડ છે. |
| 06:09 | નોંધ લો કે હેડર અલગ છે. |
| 06:12 | આપણી પાસે અહીં using સ્ટેટમેન્ટ પણ છે. |
| 06:16 | C++ માં આઉટપુટ સ્ટેટમેન્ટ cout છે. |
| 06:19 | અને C++ માં ઇનપુટ સ્ટેટમેન્ટ cin છે. |
| 06:22 | તેથી, આ તફાવતો સિવાય, બે કોડ ખૂબ જ સમાન છે. |
| 06:27 | save. |
| 06:29 | Please make sure the file is saved with the extension .cpp |
| 06:33 | I have saved my file as relational.cpp |
| 06:38 | Let's compile the code. |
| 06:40 | Open the terminal and type g++ relational.cpp -o rel1 |
| 06:51 | To execute Type './ rel1, Press Enter.
|
| 06:57 | I enter a as 8 and b as 3. |
| 07:01 | The output is displayed: |
| 07:03 | We see that the output is same as the one in C code. |
| 07:08 | Now let us see an error which we can come across. |
| 07:11 | Come back to the program |
| 07:13 | Suppose here we replace the double equal to sign with the single equal to. |
| 07:20 | Click on Save. |
| 07:21 | Come back to the terminal. |
| 07:24 | Compile and execute as before. |
| 07:34 | Here we see it is showing 3 is equal to 3. |
| 07.38 | Come back to our program |
| 07:40 | This is because here we have an assignment operator. |
| 07:44 | So value of b is assigned to a. |
| 07:47 | Now Let us fix this error. |
| 07:49 | Type an equal to sign. |
| 07:52 | Click on Save |
| 07:55 | Switch back to the terminal |
| 07:56 | compile and execute as before. |
| 08:04 | The output is now correct. |
| 08:06 | Let's summarize the tutorial. |
| 08:09 | In this tutorial, we learnt |
| 08:10 | Relational operators like |
| 08:12 | Less than: eg. a b |
| 08:18 | Less than or equal to: eg. a<=b |
| 08:23 | Greater than or equal to: eg. a>=b |
| 08:27 | Equal to: eg. a==b |
| 08:30 | Not equal to: eg. a!=b |
| 08:34 | As an assignment |
| 08:35 | Write a program that takes the marks of three students as input. |
| 08:40 | Compare the marks to see which student has scored the highest. |
| 08:44 | Check also if two or more students have scored equal marks. |
| 08:49 | Watch the video available at the following link |
| 08:51 | It summarises the Spoken Tutorial project |
| 08:54 | If you do not have good bandwidth, you can download and watch it
|
| 08:58 | The Spoken Tutorial Project Team |
| 09:00 | Conducts workshops using spoken tutorials |
| 09:03 | Gives certificates for those who pass an online test |
| 09:06 | For more details, please write to contact at spoken hyphen tutorial dot org
|
| 09:14 | Spoken Tutorial Project is a part of the Talk to a Teacher project |
| 09:18 | It is supported by the National Mission on Education through ICT, MHRD, Government of India |
| 09:24 | More information on this Mission is available at |
| 09:27 | spoken hyphen tutorial dot org slash NMEICT hyphen Intro
|
| 09:35 | This is Ritwik Joshi from IIT Bombay.
Thank you for joining. |
