પ્રોગ્રામિંગ કરતી વખતે તમે લૂપનો ઉપયોગ કેવી રીતે કરો છો?

આ પોસ્ટમાં, અમે વિશે વાત કરવામાં આવશે જ્યારે પ્રોગ્રામિંગમાંઆ નિયંત્રણ માળખામાં સૂચનાઓ છે જે ઘણા પ્રસંગોએ પુનરાવર્તિત થાય છે, તેમના મુખ્ય કાર્યોમાં સાચા કે ખોટા સંબંધિત સંખ્યાબંધ સૂચનાઓને અવરોધવું છે, વધુમાં, લૂપનો ઉપયોગ કેવી રીતે થાય છે તે જાહેર કરવામાં આવે છે.

જ્યારે પ્રોગ્રામિંગમાં

પ્રોગ્રામિંગમાં કેટલો સમય છે, નિયંત્રણ માળખામાં સૂચનોની શ્રેણી આપવા માટે વપરાય છે જે ઘણી વખત પુનરાવર્તિત થાય છે, તે સૂચનોની શ્રેણીમાં અવરોધ લાવવાનું કાર્ય પણ કરે છે, જો સંકળાયેલ અભિવ્યક્તિનું મૂલ્યાંકન અને / અથવા તાર્કિક અથવા ખોટું હોય.

આનો અર્થ એ છે કે સૂચનાનું મૂલ્યાંકન સાચું હોય ત્યારે જ તે પુનરાવર્તિત થાય છે.

પ્રોગ્રામિંગમાં if અથવા switch સ્ટેટમેન્ટ જેવા નિયંત્રણ માળખા ઉપરાંત, પુનરાવર્તિત માળખા પણ છે.

પુનરાવર્તિત પ્રોગ્રામિંગ સ્ટ્રક્ચર્સમાં, થોડો સમય લૂપ સંબંધિત, તે કોડના બ્લોકને પુનરાવર્તિત કરે છે જ્યાં સુધી તેમાં સાચું મૂલ્ય હોય, જે નીચે મુજબ વ્યક્ત કરી શકાય:

• જ્યારે (શરત).
• {.
• સૂચનાઓ;.
• }.

જેમ તમે જોઈ શકો છો કે પુનરાવર્તનો અને આંટીઓ છે, જો કે, તે સામાન્ય રીતે સમાન છે, એ નોંધવું અગત્યનું છે કે આંટીઓ સમાવે છે:

• મૂલ્યાંકન કરવાની શરત સાચી કે ખોટી છે, અને તે લૂપના દરેક પુનરાવર્તન પર કરવામાં આવે છે.
• જો સ્થિતિ સાચી હોય તો કોડની રેખાઓ દર્શાવતું નિવેદન કરવામાં આવે છે.

આ પ્રકારની લૂપની લાક્ષણિકતાઓ પૈકીની એક એ છે કે કોડ ચલાવતા પહેલા શરતની પ્રક્રિયા કરવામાં આવે છે, પછી, પરિણામ ખોટું હોય તો, સૂચનાઓ ચલાવવામાં આવશે નહીં, જ્યારે અન્ય પ્રકારની લૂપ છે જે ફક્ત એક જ વખત ચલાવે છે. .

અહીં અમે સંબંધિત એક રસપ્રદ લેખની ભલામણ કરીએ છીએ સી ભાષા.

પછી, જ્યારે આંટીઓ વ્યાખ્યાયિત કરવામાં આવે છે, તે એક ચક્રીય માળખાનો ઉલ્લેખ કરે છે જે પ્રારંભિક મૂલ્ય વગર અને કેટલીકવાર તે અપેક્ષિત અંતિમ મૂલ્ય ક્યારે પરત કરશે તે જાણ્યા વિના, કોડની એક અથવા વિવિધ રેખાઓને વારંવાર પુનરાવર્તિત કરવાની મંજૂરી આપે છે.

જ્યારે આંટીઓ તે છે જે આંકડાકીય મૂલ્યોને આધિન નથી, તેનાથી વિપરીત તેઓ બુલિયન મૂલ્યો પર આધાર રાખે છે, જેનો અર્થ સાચી કે ખોટી સ્થિતિનું સત્ય મૂલ્ય છે.

જ્યારે લૂપ કેવી રીતે કામ કરે છે?

જ્યારે લૂપ કેવી રીતે કાર્ય કરે છે તે સમજવા માટે, આ ભાગમાં આપણે એવા ઉદાહરણોનો ઉલ્લેખ કરીશું જે આપણને તેના પ્રદર્શનને વધુ સારી રીતે જોવા માટે દોરી જાય છે.

ઉદાહરણ તરીકે, અમે માનીએ છીએ કે કેટલાક કારણોસર, વપરાશકર્તાને તેમની પાસે થતી સંખ્યાઓની સંખ્યા માટે પૂછવામાં આવે છે, અને તેઓ 100 થી મોટી સંખ્યા દાખલ કરે છે.

જેમ તમે જોઈ શકો છો, તમે લૂપ માટે ઉપયોગ કરી શકતા નથી, કારણ કે તમને કોઈ ખ્યાલ નથી કે વપરાશકર્તા 100 થી વધારે નંબર દાખલ કરશે, તે એવી વસ્તુ છે જે નક્કી કરી શકાતી નથી, પરંતુ જ્યારે લૂપ કોઈ ચોક્કસ સ્થિતિ સુધી અનંત ક્રિયા કરવા માટે સંમત થાય છે ચલાવવામાં આવે છે, આ કિસ્સામાં તે દાખલ કરેલ સંખ્યા છે જે 100 કરતા વધારે છે.

તેથી, જો વપરાશકર્તા સતત નીચે આપેલા નંબરો દાખલ કરે છે: 1, 50, 99, 49, 21, 30, 100, પ્રોગ્રામ સમાપ્ત થશે નહીં, કારણ કે સંખ્યાઓ 100 કરતા વધારે નથી, પરંતુ, જો નંબર દાખલ કરો તો 300, પ્રોગ્રામની શરત છે કે તે તરત જ સમાપ્ત થશે.

જ્યારે C ++ માં લૂપ સિન્ટેક્સ

થોડો સમય લૂપનો વાક્યરચના સી ++ માં ફોર લૂપ કરતા સરળ અને વધુ વાંચી શકાય છે, કારણ કે તેને માત્ર ચોક્કસ સ્ટોપ સ્થિતિની જરૂર છે.

જ્યારે લૂપ લખવાની મોટાભાગની ઉચ્ચ-સ્તરની ભાષાઓ ખૂબ સમાન છે, તેથી તમારે શું કરવું જોઈએ તે લૂપ માટે સમાપ્તિની સ્થિતિ ધ્યાનમાં રાખો જે તૈયાર કરવામાં આવશે.

ચાલો નીચેના ઉદાહરણમાં જોઈએ કે અંતિમ સ્થિતિ કેવી રીતે મૂકવામાં આવશે:

• જ્યારે (અંતિમ સ્થિતિ) // ઉદાહરણ તરીકે નંબર == 100.
• {.
• ....
• ....
• ....
• ....
• }.

અમે ઉપરોક્ત કોડની લાઇન દ્વારા રેખાની કલ્પના કરીશું, આ રીતે કે તે આપણને શું અર્થ છે તે સમજવામાં મદદ કરે છે.

લાઈન 1: તેની સામગ્રીમાં થોડા સમય માટે સૌથી મહત્વનું છે.

વાક્યરચના ખૂબ જ સરળ છે, તમે જોઈ શકો છો કે કૌંસ અંદર એક સ્થિતિ જોવા મળે છે, ઉદાહરણ તરીકે: «==. >, <,> =, <=,! = »અથવા કદાચ અન્ય, ખાસ રીતે જણાવેલ શરત એ છે કે જે તે ચક્ર પરિપૂર્ણ થવાનું ચાલુ રાખે છે જ્યાં સુધી તે તે સ્થિતિ સુધી ન પહોંચે જ્યાં સુધી તે જ સ્થિતિ અમલમાં ન આવે.

ઉદાહરણ તરીકે, તમે ખાતરી કરો છો કે ચોક્કસ સંખ્યા == 50, ચક્ર ત્યારે જ કરવામાં આવે છે જ્યારે કોઈપણ સંખ્યા 50 ની બરાબર હોય; જ્યારે તેનું મૂલ્ય અન્ય કોઈપણ જથ્થામાં સુધારેલ છે, જ્યારે લૂપ તેની પ્રક્રિયા સમાપ્ત કરે છે, પરંતુ તે પ્રોગ્રામ એક્ઝેક્યુશનના અન્ય ભાગ સાથે ચાલુ રહેશે.

તે ધ્યાનમાં લેવું જોઈએ કે તે સ્પષ્ટ છે કે નોંધાયેલ શરત હંમેશા બુલિયન મૂલ્ય લેશે, એટલે કે સાચું કે ખોટું.

લાઇન 2: આ લાઇનમાં એક "{" ઓપનિંગ દેખાય છે, જેનો અર્થ છે કે આ ભાગમાં સૂચનાઓનો બ્લોક શરૂ કરવામાં આવી રહ્યો છે જે ચક્ર વળાંક શરૂ થયા પછી પૂર્ણ થશે.

જો કે, આ કી મૂકવી ફરજિયાત નથી, પરંતુ, જો તે મૂકવામાં ન આવે, તો તે ફક્ત તાત્કાલિક લાઇનમાં બતાવેલ જ્યારે લૂપમાં ચલાવવામાં આવશે, પછી લૂપ ઘોષણા, જેનો અર્થ છે કે જો તમે ન ઇચ્છતા હોવ તો જો ચક્રમાં જુદી જુદી રેખાઓ હાથ ધરવામાં આવે છે, તો ચાવીઓ મૂકવી આવશ્યક છે.

3 થી 7 રેખાઓ: આ રેખાઓ છે જ્યાં તમે ચક્ર પ્રક્રિયામાં વારંવાર ચલાવવા માંગો છો તે તમામ કામગીરી મૂકવામાં આવશે. આ બ્લોકમાં જરૂરી લાઇનોની સંખ્યા શામેલ હોઈ શકે છે.

લાઇન 8: તે છેલ્લી લાઇન છે અને "}" બંધ કરીને કીનો ઉપયોગ કરવો જોઇએ, જ્યારે લૂપના બ્લોક દ્વારા સ્થાપિત કરવામાં આવે છે અને એક્ઝેક્યુશન સમાપ્ત કરવામાં આવશે, જો કે, બાકીનું અલ્ગોરિધમ ચાલુ રહેશે.

હવે અમે કેટલાક ઉદાહરણો બતાવીશું જે વપરાશકર્તાઓને સ્પષ્ટ અને સરળ રીતે C ++ માં લૂપ્સનો ઉપયોગ સમજવા તરફ દોરી જશે, અમે આની સાથે પ્રારંભ કરીએ છીએ:

ઉદાહરણ 1: સ્ક્રીન પર સંખ્યા 100 માટે મોટી ન થાય ત્યાં સુધી પૂછો

અમે ઉપર દર્શાવેલ ઉદાહરણ સાથે ચાલુ રાખીશું, જ્યાં અમે પ્રોગ્રામ પર આગળ વધીએ છીએ જેમાં વપરાશકર્તાને સંખ્યાઓ દાખલ કરવા માટે કહેવામાં આવે છે, પછી ભલે તે ગમે તે હોય, અને જ્યારે વપરાશકર્તા 100 થી વધુ સંખ્યામાં પ્રવેશ કરે ત્યારે તે કરવાનું બંધ થઈ જશે, તે છે એક ઉદાહરણ પ્રાયોગિક અને સરળ, ચકાસવા માટે કે ઉપરોક્ત સમજાયું છે.

ઉકેલ ઉદાહરણ 1:

અમે સોલ્યુશન આપવા જઈ રહ્યા છીએ, તે ધ્યાનમાં રાખવું જોઈએ કે શરત ચલાવવી જોઈએ જેથી ચક્ર નંબરની વિનંતી કરે, ચક્ર ત્યારે જ બંધ થશે જ્યારે દાખલ કરેલો નંબર 100 કરતા વધારે હશે, પછી મારા માટે ચાલુ રાખવાની શરત પ્રક્રિયા એ છે કે સંખ્યા 100 થી ઓછી છે, રોકવા માટે સંખ્યા 100 થી વધારે હોવી જોઈએ, અને પ્રક્રિયા ચાલુ રાખવા માટે સંખ્યા 100 કરતા ઓછી અથવા બરાબર હોવી જોઈએ.

તે જોઈ શકાય છે કે તે નીચેની રીતે પ્રતિબિંબિત થાય છે:

• પૂર્ણાંક સંખ્યા;.
• cin >> સંખ્યા;.
• જ્યારે (સંખ્યા <= 100).
• {.
• cout << «કૃપા કરીને એક નંબર દાખલ કરો«;.
• cin >> સંખ્યા;.
• }.

સંપૂર્ણ કાર્યકારી કોડ વપરાશકર્તા દ્વારા હેન્ડલ કરવા માટે ખૂબ જ સરળ છે, નીચે તેનો ઉપયોગ કેવી રીતે કરવો તેની પ્રથા છે:

• #"iostream" શામેલ કરો.
• નેમસ્પેસ std; નો ઉપયોગ કરીને.
• પૂર્ણાંક મુખ્ય ().
• {.
•  પૂર્ણાંક સંખ્યા;.
•  cout << «કૃપા કરીને એક નંબર દાખલ કરો«;.
•  cin >> સંખ્યા;.
•  જ્યારે (સંખ્યા <= 100).
•  {.
•  cout << «કૃપા કરીને એક નંબર દાખલ કરો«;.
•  cin >> સંખ્યા;.
•  }.
•  સિસ્ટમ ("PAUSE");.
•  વળતર 0;.
• }.

જ્યારે પ્રોગ્રામિંગમાં લૂપ્સ ખૂબ ઉપયોગી હોય છે, પરંતુ તે ધ્યાનમાં રાખવું જોઈએ કે લૂપ્સ માટે અન્યની જેમ કાર્યક્ષમતા અને માન્યતાના પાસામાંથી, એવું સૂચવવામાં આવે છે કે તેનો ઉપયોગ ન કરવો, જ્યારે પણ લૂપ અથવા અન્ય કોઈ પણ પ્રકારની લૂપ ચાલુ હોય ત્યારે. વાપરવા માટે.