சி ++ லூப்பிற்கு


In போது மற்றும் செய்… போது சுழல்கள் சிறிது நேரம் கழித்து வளையத்தை உடைக்க அதிகரிப்பு அல்லது குறைப்பு செயல்பாட்டை எழுத வேண்டும். ஆனால் உள்ளே for லூப் லூப் உடலுக்கு வெளியே அதிகரிக்க அல்லது குறைக்க ஒரு விருப்பம் உள்ளது. மேலும் for சுழல்கள் மாறியைத் தொடங்க ஒரு விருப்பத்தைக் கொண்டுள்ளன. ஆகவே, லூப் உடலுக்குள் அதிகரிக்கும் / குறைக்கும் எந்த படியையும் எழுத வேண்டிய அவசியமில்லை. லூப் கீழே தெரிகிறது.

ஃபார் லூப்பின் தொடரியல்

for (initialization; termination; increment-decrement) 
    statement

OR
for (initialization; termination; increment-decrement) 
{
    statement(s)
}

துவக்கம்: லூப் தொடங்கும் போது துவக்க வெளிப்பாடு ஒரு முறை செயல்படுத்தப்படும். இந்த வெளிப்பாடு சுழற்சியைத் துவக்குகிறது.

முடித்தல்: முடித்தல் வெளிப்பாட்டின் மதிப்பு தவறானதாக இருந்தால் லூப் முடிவடைகிறது.

அதிகரிப்பு-குறைவு: ஒவ்வொரு மறு செய்கை மூலம் இந்த வெளிப்பாடு செயல்படுத்தப்படுகிறது. இந்த வெளிப்பாடு மதிப்பை அதிகரிக்கலாம் அல்லது குறைக்கலாம்.

லூப் எடுத்துக்காட்டுகளுக்கு

இதை முயற்சிக்கவும்

#include <iostream> 
using namespace std;
int main()
{
for (int i = 0; i < 5; i++)
	cout << "i is " << i << endl; 
return 0;
}

இங்கே int i = 0 துவக்கம்
i < 5 முடித்தல் நிலை
i++ 1 ஐ அதிகரிப்பதன் மூலம் மாறியின் மதிப்பை மாற்றுகிறது
cout << " i is " << i << endl; நான் 5 ஆகிவிடும் வரை செயல்படுத்தப்படும்

மேலே உள்ள குறியீட்டின் வெளியீடு இருக்கும்

நான் 0
நான் 1
நான் 2
நான் 3
நான் 4

துவக்கம், முடித்தல் மற்றும் அதிகரிப்பு-குறைவு இல்லாமல் சுழலுக்கு

துவக்கம், முடித்தல் மற்றும் அதிகரிப்பு-குறைப்பு வெளிப்பாடுகள் விருப்பத்தேர்வு. ஒரு இருக்க முடியும் for கீழே காட்டப்பட்டுள்ளபடி வளையம்.

for (;;) 
{
    statement(s)
}

மேலே வளையம் எப்போதும் இயங்கும் மற்றும் அதற்கு சமம்
while (true) 
{
    statement(s)
}

கீழே காட்டப்பட்டுள்ளபடி துவக்கம் மற்றும் அதிகரிப்பு-குறைப்பு வெளிப்பாடுகள் இல்லாமல் ஒரு ஃபார் லூப்பை எழுதலாம்
int i = 0;
for ( ; i < 10; )
{
    cout << i << " ";
    i++;
}

மேலே உள்ள குறியீட்டின் வெளியீடு இருக்கும்

0  1  2  3  4  5  6  7  8  9

கீழே காட்டப்பட்டுள்ளபடி அதிகரிப்பு-குறைப்பு வெளிப்பாட்டை மட்டுமே பயன்படுத்தி ஒரு ஃபார் லூப்பை எழுதலாம்

int i = 0;
for ( ; ; i++)
{
    cout << i << " ";  
    if(i==10)
        break;
}

மேலே உள்ள குறியீட்டின் வெளியீடு இருக்கும்

0  1  2  3  4  5  6  7  8  9  10

பூஜ்ய அறிக்கைகள்

கீழே காட்டப்பட்டுள்ளபடி அறிக்கை / கள் இல்லாமல் ஒரு ஃபார் லூப் வைத்திருப்பது சாத்தியமாகும். இதில் ஃபார் லூப் துவக்கம், முடித்தல் நிலை மற்றும் அதிகரிப்பு / குறைப்பு செயல்பாட்டைச் சரிபார்த்து பின்னர் சுழற்சியில் இருந்து வெளியேறும்.

for(int i=0; i < 10; i++);

மேலே வளையம் 10 முறை இயங்கும், அதன் பிறகு நிறுத்தப்படும். நிறுத்தப்படுவதற்கு முன் i இன் மதிப்பு 10 ஆக இருக்கும்

For loop பற்றிய மேம்பட்ட விவரங்கள்

துவக்கம்: இது ஒரு ஒற்றை வெளிப்பாடு ஆகும், இதில் ஒரே வகையின் பல மாறி அறிவிப்பு இருக்கலாம். நீங்கள் 2 மாறிகள் அறிவிக்க விரும்பினால், நீங்கள் கமாவால் பிரிக்கப்பட்டதைப் போல எழுத வேண்டும் int i=0, j=0 ஆனால் அரைக்காற்புள்ளியைப் போல பிரிக்கப்படவில்லை int i=0; int j=0. நீங்கள் எழுத முடியாது int i=0, float j=0.

முடித்தல்: இங்கே நீங்கள் பல நிறுத்த நிபந்தனைகளை எழுதலாம், ஆனால் கடைசி ஒன்று மட்டுமே செல்லுபடியாகும் மற்றும் முந்தையவை புறக்கணிக்கப்படும். உதாரணத்திற்கு b > 5, a < 10 இங்கே b > 5 புறக்கணிக்கப்படும் மற்றும் மட்டுமே a < 10 சரியான முடித்தல் நிபந்தனையாக இருக்கும்.

அதிகரிப்பு-குறைவு: இங்கேயும் பிரிக்கப்பட்ட பல அதிகரிப்பு-குறைப்பு செயல்பாடுகளை எழுதலாம் ,.

மேலே உள்ள அம்சங்களை செயல்படுத்தும் குறியீடு கீழே உள்ளது

int main ()
{   
   for( int a = 1, b = 10, c = 1 ; a < 10; a = a + 1, b = b - 1, c = c * 2 )
   {
       cout << "value of a: " << a << endl;
       cout << "value of b: " << b << endl;
       cout << "value of c: " << c << endl;
   } 
   return 0;
}

மேலே உள்ள குறியீட்டின் வெளியீடு கீழே காட்டப்பட்டுள்ளது

ஒரு மதிப்பு: 1
b இன் மதிப்பு: 10
c இன் மதிப்பு: 1
ஒரு மதிப்பு: 2
b இன் மதிப்பு: 9
c இன் மதிப்பு: 2
ஒரு மதிப்பு: 3
b இன் மதிப்பு: 8
c இன் மதிப்பு: 4
ஒரு மதிப்பு: 4
b இன் மதிப்பு: 7
c இன் மதிப்பு: 8
ஒரு மதிப்பு: 5
b இன் மதிப்பு: 6
c இன் மதிப்பு: 16
ஒரு மதிப்பு: 6
b இன் மதிப்பு: 5
c இன் மதிப்பு: 32
ஒரு மதிப்பு: 7
b இன் மதிப்பு: 4
c இன் மதிப்பு: 64
ஒரு மதிப்பு: 8
b இன் மதிப்பு: 3
c இன் மதிப்பு: 128
ஒரு மதிப்பு: 9
b இன் மதிப்பு: 2
c இன் மதிப்பு: 256

துவக்க வெளிப்பாட்டில் ஒரே மாதிரியான பல மாறிகள் மட்டுமே வரையறுக்க முடியும் என்று மேலே குறிப்பிட்டோம். வெவ்வேறு வகை மாறிகள் துவக்க ஒரு வழியை கீழே குறிப்பிடுவோம்.

for(struct { int a; float b; } s = { 0, 0.5 } ; s.a < 5 ; ++s.a, ++s.b) 
{
	cout <<"a="<< s.a << " b=" << s.b << endl;
}

மேலே உள்ள குறியீட்டின் வெளியீடு கீழே இருக்கும்

a = 0 b = 0.5
a = 1 b = 1.5
a = 2 b = 2.5
a = 3 b = 3.5
a = 4 b = 4.5

லூப்பிற்கான மரணதண்டனை வரிசை பின்வரும் படிகளில் காட்டப்பட்டுள்ளது

Step1: துவக்கத்தைச் செய்யுங்கள்
Step2: முடித்தல் நிலையை சரிபார்க்கவும். அது தவறானது என்றால் படி 6 க்குச் செல்லவும்
Step3: அறிக்கைகளை இயக்கவும்
Step4: அதிகரிப்பு-குறைப்பு மாறி
Step6: படி 2 க்குச் செல்லவும்
Step7: நிறுத்து

ஃபார் லூப்பின் ஓட்ட விளக்கப்படம் கீழே உள்ளது

லூப்பிற்கு


லூப்பிற்கான வரம்பு அடிப்படையிலானது

புதிய தரநிலை லூப்பை அடிப்படையாகக் கொண்ட ஒரு வரம்பை அறிமுகப்படுத்தியது, இது எளிமையானது மற்றும் உறுப்புகளின் சேகரிப்பின் மூலம் ஐடியேட் செய்ய பயன்படுத்தப்படலாம். இதை பின்வரும் வழியில் குறிப்பிடலாம்

for ( range_declaration : range_expression ) statement;

range_expression பொருள்களைக் கொண்ட வரிசையைக் குறிக்க வேண்டும் begin மற்றும் end உறுப்பினர்கள் விரும்புகிறார்கள் list , array , vector , string , முதலியன

அதாவது நாம் விரும்பும் அனைத்து ஈரேட்டர்களையும் பயன்படுத்தலாம் list , array , vector , string , போன்றவை range_expression இல்.

range_declaration ஒரு மாறியை வரையறுக்கிறது மற்றும் range_expression இலிருந்து வரும் ஒவ்வொரு உறுப்புகளும் இந்த மாறி வகைக்கு மாற்றப்படும். எடுத்துக்காட்டாக range_declaration என்றால் char வகை மற்றும் வரம்பு_ வெளிப்பாடு string தட்டச்சு செய்தால் ஒவ்வொரு உறுப்புக்கும் மாற்றப்படும் char தட்டச்சு செய்து கீழே காட்டப்பட்டுள்ளபடி மாறிக்கு ஒதுக்கப்படும்.

“SzName” இலிருந்து வரும் ஒவ்வொரு உறுப்புக்கும் மாற்றப்படும் char தட்டச்சு செய்து பின்னர் "ch" என்ற மாறிக்கு ஒதுக்கப்படும்.

int main ()
{
    string szName = "TutorialCup";
    for(char ch : szName)
    {
        cout << ch << endl;
    }

    return 0;
}

மேலே உள்ள குறியீட்டின் வெளியீடு கீழே காட்டப்பட்டுள்ளது

T
u
t
o
r
i
a
l
C
u
p

லூப்பை அடிப்படையாகக் கொண்ட வரம்பின் கூடுதல் எடுத்துக்காட்டு

int main() 
{
    string szName = "TutorialCup";
    for (const char &ch : szName) // access by const reference
        cout << ch << ' ';
    cout << '\n';
    
    for (auto ch : szName) // access by value, the type of ch is ch
        cout << ch << ' ';
    cout << '\n';
 
    for (auto&& ch : szName) // access by reference, the type of ch is char&
        cout << ch << ' ';
    cout << '\n';
 
    for(char ch : {'T','u','t','o','r','i','a','l','C','u','p'}) // the initializer may be a braced-init-list
        cout << ch << ' ';
    cout << '\n';
}

மேலே உள்ள குறியீட்டின் வெளியீடு கீழே உள்ளது

T u t o r i a l C u p
T u t o r i a l C u p
T u t o r i a l C u p
T u t o r i a l C u p

சுழலுக்கான வரம்பை அடிப்படையாகக் கொண்டது

லூப்பிற்கான வரம்பை அடிப்படையாகக் கொண்டு செயல்படுத்துவதன் மூலம் முடிவடைகிறது break , return மற்றும் goto வரம்பு அடிப்படையிலான சுழற்சியின் உடலுக்குள் அறிக்கை. தொடர்ச்சியான அறிக்கை ஒரு வளையத்தின் தற்போதைய மறு செய்கையை மட்டுமே நிறுத்துகிறது.

வரம்பை அடிப்படையாகக் கொண்ட முக்கிய புள்ளிகள் லூப்

  1. வரிசைகள் லூப்பிற்கான வரம்பை அடிப்படையாகக் கொண்டு தானாகவே அங்கீகரிக்கப்படும்.
  2. லூப்பிற்கான வரம்பை அடிப்படையாகக் கொண்டது .begin () மற்றும் .end () ஆகியவற்றைக் கொண்ட கொள்கலன்களை அடையாளம் காண முடியும்.
  3. வேறு எதற்கும், லூப்பிற்கான வரம்பு அடிப்படையானது வாதம் சார்ந்த தேடல் தொடக்கம் () மற்றும் முடிவு () ஐப் பயன்படுத்துகிறது.