C++ நிரலாக்கத்தில், பல்வேறு சூழ்நிலைகளில் நாம் நிபந்தனைகளை சரிபார்க்க வேண்டும். சில நேரங்களில், நாம் ஒரே நேரத்தில் பல நிபந்தனைகளை பூர்த்தி செய்ய வேண்டும். இதற்கு C++ நிரலாக்கத்தில் உள்ள “nested if” நிபந்தனையைப் பயன்படுத்துகிறோம். 'if' நிபந்தனையை மற்ற 'if' க்குள் வைத்தால், அது 'nested if' என்று கூறப்படுகிறது. முதல் 'if' நிபந்தனை திருப்தி அடையும் போது, அந்த 'if' இன் உள்ளே நாம் மற்றொரு 'if' ஐ வைக்கிறோம். பின்னர், இது முதல் 'if' நிபந்தனையின் உள்ளே வைக்கப்பட்டுள்ள 'if' நிலையை சரிபார்க்கிறது, மற்றும் பல. எல்லா நிபந்தனைகளும் பூர்த்தி செய்யப்பட்டால், 'if' க்குள் நாம் வைக்கும் முடிவை இது வழங்குகிறது.
எடுத்துக்காட்டு 1:
'nest if' ஐப் பயன்படுத்தும் சில குறியீடுகளைச் செய்வோம். C++ குறியீட்டைத் தொடங்க, இங்கே “iostream” தலைப்புக் கோப்பையும், பின்னர் “std” பெயர்வெளியையும் சேர்க்கிறோம். இதற்குப் பிறகு, 'முக்கிய()'டிரைவர் குறியீட்டை வைத்து, 'n1', 'n2' மற்றும் 'n3' ஆகிய மூன்று மாறிகளை முறையே '20', '10' மற்றும் '2' மதிப்புகளுடன் துவக்குவோம். பின்னர், 'n2' ஐ விட 'n1' அதிகமாக உள்ளதா என்பதை இங்கே 'if' நிபந்தனையைப் பயன்படுத்துகிறோம். இந்த நிபந்தனை திருப்தியடைந்தால், இந்த 'if' க்குள் நாம் முன்னேறுவோம், அங்கு மற்றொரு 'if' நிபந்தனையைச் சேர்க்கிறோம்.
இப்போது, இரண்டாவது 'if' ஆனது 'n3' ஐ விட அதிகமாக இருக்கும் 'n1' மதிப்புகளை சரிபார்க்கிறது. இந்த 'உள்ளமை என்றால்' நிபந்தனையும் திருப்தி அடைந்தால், இதற்குக் கீழே உள்ள அறிக்கை செயல்படுத்தப்படும், அதில் நாம் 'கவுட்' அறிக்கையை வைக்கிறோம். எனவே, இந்த குறியீட்டில் 'nested if' இன் இரண்டு நிபந்தனைகளும் பூர்த்தி செய்யப்பட்டால், அது அந்த அறிக்கையை அச்சிடுகிறது. நிபந்தனைகளில் ஏதேனும் தவறு இருந்தால், அது கன்சோலில் எந்த செய்தியையும் காட்டாது.
குறியீடு 1:
#
பெயர்வெளி std ஐப் பயன்படுத்துதல்;
முழு எண்ணாக ( )
{
நீங்கள் n1 = இருபது , n2 = 10 , n3 = 2 ;
என்றால் ( n1 > n2 ) {
என்றால் ( n1 > n3 ) {
கூட் << 'n1 என்பது மிகப்பெரிய மதிப்புகள்' << n1 << endl;
}
}
திரும்ப 0 ;
}
வெளியீடு:
இங்கே, இது கன்சோலில் உள்ள ஸ்டேட்மென்ட்டைக் காட்டுகிறது, அதாவது 'நெஸ்ட் இஃப்' இன் 'இஃப்' நிபந்தனைகள் இரண்டும் உண்மை. 'nest if' என்பதன் உள்ளே நாம் சேர்த்த அறிக்கையும் இங்கே கொடுக்கப்பட்டுள்ளது.
எடுத்துக்காட்டு 2:
C++ குறியீட்டைத் தொடங்க “std” பெயர்வெளி மற்றும் “iostream” தலைப்புக் கோப்பு இங்கே சேர்க்கப்பட்டுள்ளது. 'main()'இயக்கி குறியீடு பின்னர் செருகப்பட்டு, 'var1', 'var2' மற்றும் 'var3' ஆகிய மூன்று மாறிகள், '8', '91' மற்றும் '32' மதிப்புகளுடன் துவக்கப்படும்.
அடுத்து, 'val1' 'val2' ஐ விட சிறியதா என்பதை தீர்மானிக்க 'if' நிபந்தனையைப் பயன்படுத்துகிறோம். இந்த நிபந்தனை பூர்த்தி செய்யப்பட்டால், நாம் 'if' நிபந்தனைக்குள் தொடர்ந்து மற்றொரு 'if' நிபந்தனையைச் சேர்க்கிறோம். இரண்டாவது “if” இப்போது “val1” மதிப்பு “val3” ஐ விடச் சிறியதா என்பதைச் சரிபார்க்கிறது. இந்த 'உள்ளமை என்றால்' நிபந்தனையும் பூர்த்தி செய்யப்பட்டால், 'கவுட்' க்குள் வைக்கப்படும் அறிக்கை பின்வருவனவற்றில் இயங்கும். எனவே, இந்த குறியீட்டில் 'உள்ளமை என்றால்' நிபந்தனைகள் இரண்டும் பூர்த்தி செய்யப்பட்டால், அது அந்த அறிக்கையை அச்சிடுகிறது. நிபந்தனைகள் பொய்யாக இருந்தால் கன்சோல் எந்த செய்தியையும் காட்டாது.
குறியீடு 2:
#பெயர்வெளி std ஐப் பயன்படுத்துதல்;
முழு எண்ணாக ( )
{
int var1 = 8 , var2 = 91 , var3 = 32 ;
என்றால் ( var1 < var2 ) {
என்றால் ( var1 < var3 ) {
கூட் << 'var1 என்பது மிகச்சிறிய மதிப்புகள்' << var1 << endl;
}
}
திரும்ப 0 ;
}
வெளியீடு:
'nest if' க்குள் நாங்கள் சேர்த்த அறிக்கை இப்போது இங்கே கொடுக்கப்பட்டுள்ளது. கன்சோலில் உள்ள செய்தியானது, 'உள்ளது என்றால்' இன் 'if' நிபந்தனைகள் இரண்டும் உண்மை என்பதைக் குறிக்கிறது.
எடுத்துக்காட்டு 3:
இங்கே “main()” இல், “x”, “y” மற்றும் “z” என்ற மாறிகளை முறையே “11”, “22” மற்றும் “33” மதிப்புகளுடன் துவக்குகிறோம். பின்னர், 'if' ஐப் பயன்படுத்துகிறோம், அதில் 'x == 11' என்ற நிபந்தனையை வைத்து, 'y == 22' ஐச் சேர்க்கும் இடத்தில் 'nest if' என்ற இந்த 'if' க்குள் மற்றொரு 'if' ஐ வைக்கிறோம். நிலை. இந்த 'நெஸ்ட் இஃப்' முதல் 'இஃப்' நிபந்தனையை பூர்த்தி செய்யும் போது மட்டுமே செயல்படுத்தப்படுகிறது.
இதற்குப் பிறகு, இரண்டாவது 'if' க்குள் மேலும் ஒரு 'if' ஐப் பயன்படுத்துகிறோம், இது நாம் முன்பு சேர்த்த 'if' இரண்டும் திருப்தி அடையும் போது செயல்படுத்தப்படும். மூன்றாவது 'if' இல் 'z == 33' நிபந்தனை உள்ளது மற்றும் கடைசி 'if' நிபந்தனைக்குள் 'cout' ஐ சேர்க்கிறோம். இந்த மூன்று நிபந்தனைகளும் உண்மையாக இருக்கும்போது மட்டுமே இது செயல்படுத்தப்படும்.
குறியீடு 3:
#பெயர்வெளி std ஐப் பயன்படுத்துதல்;
முழு எண்ணாக ( )
{
int x = பதினொரு , y = 22 , z = 33 ;
என்றால் ( x == பதினொரு ) {
என்றால் ( மற்றும் == 22 ) {
என்றால் ( == உடன் 33 ) {
கூட் << 'ஏய்! இங்கே இருந்தால் C++ கூடு!!' << endl;
}
}
}
திரும்ப 0 ;
}
வெளியீடு:
இந்த முடிவு அனைத்து 'உள்ளமை என்றால்' நிபந்தனைகளும் திருப்திகரமாக இருப்பதைக் காட்டுகிறது. கடைசி 'if' க்குள் உள்ள அறிக்கை இங்கே காட்டப்படும். பட்டியலிடப்பட்ட நிபந்தனைகளில் ஏதேனும் தவறு இருந்தால் இந்த அறிக்கை இங்கு தோன்றாது.
எடுத்துக்காட்டு 4:
“ch1”, “ch2” மற்றும் “ch3” மாறிகள் “main()” செயல்பாட்டிற்கு பிறகு “a”, “b” மற்றும் “z” எழுத்துகளுடன் “char” தரவு வகையாக துவக்கப்படும். அடுத்து, கூடுதல் 'ch2 == b' நிபந்தனையுடன் 'ch1 == a' நிபந்தனையுடன் 'if' அறிக்கையையும் அதன் உள்ளே மற்றொரு 'if' ('nested if' எனக் குறிப்பிடப்படுகிறது) பயன்படுத்துகிறோம். அதாவது முதல் 'if' நிபந்தனையை பூர்த்தி செய்யும் போது மட்டுமே இந்த 'nested if' இயக்கப்படும்.
அதற்குப் பிறகு, இரண்டாவது 'if' க்குள் கூடுதல் 'if' ஐப் பயன்படுத்துகிறோம், இது முன்னர் செருகப்பட்ட 'if' நிபந்தனைகள் இரண்டின் திருப்தியின் பேரில் மேற்கொள்ளப்படுகிறது. 'ch3 == z' நிபந்தனை மூன்றாவது 'if' இல் காணப்படுகிறது மற்றும் 'cout' என்ற வார்த்தை கடைசி 'if' நிலையில் உள்ளது. எல்லா நிபந்தனைகளும் பூர்த்தி செய்யப்பட்டால் மட்டுமே இது கடந்து செல்லும்.
குறியீடு 4:
#பெயர்வெளி std ஐப் பயன்படுத்துதல்;
முழு எண்ணாக ( )
{
char ch1 = 'a' , ch2 = 'b' , ch3 = 'உடன்' ;
என்றால் ( ch1 == 'a' ) {
என்றால் ( ch2 == 'b' ) {
என்றால் ( ch3 == 'உடன்' ) {
கூட் << 'The C++ programming nested if..!!' << endl;
}
}
}
திரும்ப 0 ;
}
வெளியீடு:
கடைசி 'if' க்குள் உள்ள வாக்கியம் இங்கே காட்டப்பட்டுள்ளது, இது 'உள்ளமை என்றால்' நிபந்தனைகள் அனைத்தும் திருப்திகரமாக இருப்பதைக் குறிக்கிறது. நிபந்தனைகளில் ஏதேனும் தவறு இருந்தால் இந்த அறிக்கை இங்கு தோன்றாது.
எடுத்துக்காட்டு 5:
'main()' முறையை அழைத்த பிறகு, 'f1', 'f2' மற்றும் 'f3' மாறிகள் '2.40', '19.7' மற்றும் '43.1' மதிப்புகளுடன் 'float' தரவு வகையாக துவக்கப்படும். அடுத்து, “f1 == 2.40” நிபந்தனையுடன் “if” அறிக்கையையும் அதன் உள்ளே “f2 == 19.7” நிபந்தனையுடன் மற்றொரு “if” (“nested if” என்றும் அழைக்கப்படுகிறது) ஆகியவற்றைப் பயன்படுத்துகிறோம். முதல் 'இஃப்' நிபந்தனை பூர்த்தி செய்யப்பட்டால் மட்டுமே இந்த 'உள்ளமைக்கப்பட்ட இஃப்' செயல்படுத்தப்படும் என்பதை இது குறிக்கிறது.
பின்னர், இரண்டாவது 'if' க்குள் மூன்றாவது 'if' ஐப் பயன்படுத்துகிறோம், இது முன்னர் சேர்க்கப்பட்ட 'if' நிபந்தனைகள் இரண்டும் பூர்த்தி செய்யப்பட்டால் செயல்படுத்தப்படும். மூன்றாவது 'if' நிலையில் 'f3 == 9' நிபந்தனை உள்ளது, மேலும் கடைசி 'if' நிலையில் 'cout' உள்ளது. மூன்று தேவைகளும் பூர்த்தி செய்யப்பட்ட சூழ்நிலையில் மட்டுமே இந்த 'கவுட்' அறிக்கை வழங்கப்படும். பின்னர், இந்த 'if' நிபந்தனைகள் அனைத்திற்கும் வெளியே, 'if' நிபந்தனை உண்மையில்லாதபோது வழங்கப்படும் 'cout' ஐயும் சேர்க்கிறோம்.
குறியீடு 5:
#பெயர்வெளி std ஐப் பயன்படுத்துதல்;
முழு எண்ணாக ( )
{
மிதவை f1 = 2.40 , f2 = 19.7 , f3 = 43.1 ;
என்றால் ( f1 == 2.40 ) {
என்றால் ( f2 == 19.7 ) {
என்றால் ( f3 == 9 ) {
கூட் << 'நிபந்தனைகள் இங்கே உண்மையாக இருந்தால் அனைத்து உள்ளமையும்!!' << endl;
}
}
}
கூட் << 'திருப்தி அடையவில்லை என்றால் உள்ளமையின் நிலை..!!' << endl;
திரும்ப 0 ;
}
வெளியீடு:
இங்கே, 'nested if' நிபந்தனைக்கு வெளியே நாம் சேர்த்த அறிக்கையைக் காட்டுகிறது மற்றும் 'nested if' நிபந்தனை திருப்தியடையவில்லை என்பதைக் காட்டுகிறது.
முடிவுரை
C++ இல் உள்ள 'nested if' கருத்து இங்கே முழுமையாகக் கற்றுக் கொள்ளப்படுகிறது. 'nest if' என்பது 'if' நிபந்தனையை மற்ற 'if' நிபந்தனைக்குள் வைத்துள்ளோம் என்பதை நாங்கள் ஆராய்ந்தோம். ஒரே நேரத்தில் பல நிபந்தனைகளை பூர்த்தி செய்ய வேண்டிய இந்த 'உள்ளே இருந்தால்' நிபந்தனையைப் பயன்படுத்தினோம். எங்கள் C++ குறியீடுகளில் உள்ள 'nested if' நிபந்தனையைப் பயன்படுத்திய சில உதாரணங்களை ஆராய்ந்தோம், அது எவ்வாறு செயல்படுகிறது என்பதை விளக்கினோம்.