உள்ளடக்கம்
- படிகள்
- முறை 2 இல் 1: லூப் நுட்பம்
- முறை 2 இல் 2: "தூக்கம் ()" நுட்பம்
- மாதிரி குறியீடு
- குறிப்புகள்
- எச்சரிக்கைகள்
ஒரு குறிப்பிட்ட நேரத்திற்கு காத்திருக்கும் சி நிரலை உருவாக்க நீங்கள் எப்போதாவது விரும்பினீர்களா? உதாரணமாக "பறக்க" நேரம் கொடுக்கும் வழியை நீங்கள் தனிப்பயனாக்கலாம், எடுத்துக்காட்டாக: விளையாட்டிற்கான பாப்-அப் பக்கத்தை (அறிவிப்பு அல்லது குறிப்பு) காட்டும் போது. ... சரி, "இன்னும் நிற்க" நிரலை உருவாக்க சில வழிகள் இங்கே, படிக்கவும் ...
படிகள்
1 கவனிக்கத்தக்க நிகழ்வை ஏற்படுத்தாமல் உங்கள் செயலி சிறிது நேரம் இயங்கட்டும்.
2 ஒரு எளிய நேர தாமதத்தை உருவாக்க இந்த தாமதத்தின் போது வேறு எந்த செயல்பாடுகளையும் செய்ய வேண்டாம்.
முறை 2 இல் 1: லூப் நுட்பம்
1 தாமதத்தை செயல்படுத்த ஒரு வழக்கமான "ஃபார்" லூப்பைப் பயன்படுத்தி வெற்று அறிக்கையைப் பயன்படுத்தவும்.
2 பின்வருமாறு எழுதுங்கள், எடுத்துக்காட்டாக:- (i = 1; i100; i ++);
- ";" ஐப் பின்பற்றும் ஆபரேட்டர் குறிப்பிடத்தக்க நிகழ்வு இல்லாமல் கணினியை 100 முறை சுழற்றும்படி கட்டாயப்படுத்துகிறது. இது கால தாமதத்தை மட்டுமே உருவாக்குகிறது.
முறை 2 இல் 2: "தூக்கம் ()" நுட்பம்
1 தூக்கத்தைப் பயன்படுத்தவும் (). இந்த செயல்பாடு தூக்கம் (int ms) என அழைக்கப்படுகிறது, TIME.H> இல் அறிவிக்கப்பட்டது, இது நிரலை மில்லி விநாடிகளில் குறிப்பிட்ட நேரத்திற்கு காத்திருக்க வைக்கிறது. 
2 Int main () க்கு முன் உங்கள் நிரலில் பின்வரும் வரியைச் சேர்க்கவும்:- #TIME.H> ஐ சேர்க்கவும்
3 உங்கள் திட்டத்தை தாமதப்படுத்த தேவையான இடங்களில் ஒட்டவும்:- தூக்கம் (1000);
- நீங்கள் காத்திருக்க விரும்பும் மில்லி விநாடிகளின் எண்ணிக்கைக்கு "1000" ஐ மாற்றவும் (எடுத்துக்காட்டாக, நீங்கள் 2 வினாடி தாமதம் செய்ய விரும்பினால், அதை "2000" உடன் மாற்றவும்.
- உதவிக்குறிப்பு: சில அமைப்புகளில், மில்லி விநாடிகளுக்குப் பதிலாக மதிப்பை வினாடிகளில் குறிப்பிடலாம். எனவே, சில நேரங்களில் 1000 என்பது 1 வினாடி அல்ல, உண்மையில் 1000 வினாடிகள்.
மாதிரி குறியீடு
ஒரு குறிப்பிட்ட எண்ணிக்கையிலான வினாடிகள் காத்திருக்கும் ஒரு நிரல்:
#stdio.h> ஐ சேர்க்கவும். dos.h> int main () {int del; // தாமத காலம் printf ("தாமத நேரத்தை உள்ளிடவும் (நொடிகளில்):"); ஸ்கேன்ஃப் ("% i",? டெல்); டெல் * = 1000; // அதை மில்லி விநாடிகள் தாமதமாக மாற்ற 1000 ஆல் பெருக்கவும்; // தாமதம். printf ("முடிந்தது"); திரும்ப 0; }
10 இலிருந்து 0 ஆகக் கணக்கிடப்படும் ஒரு நிரல்:
#STDIO.H> #TIME.H> int main () {int i; (i = 10; i> = 0; i--) {printf ("% i n", i); // தற்போதைய 'கவுண்டவுன்' எண் தாமதத்தை எழுதுங்கள் (1000); // ஒரு நிமிடம் காத்திருங்கள்} திரும்ப 0; }
குறிப்புகள்
- ஒரு மில்லி வினாடி என்பது ஒரு வினாடிக்கு 1/1000 ஆகும்.
- மேற்கூறிய வழிமுறையை பூஜ்ய ஆபரேட்டர் - ";
எச்சரிக்கைகள்
- இந்த முறை பொதுவாக ஒரு அற்பமான திட்டத்தைத் தவிர வேறு எதற்கும் பயனற்றது. பொதுவாக, இதைச் செய்ய டைமர்கள் அல்லது நிகழ்வு சார்ந்த அணுகுமுறையைப் பயன்படுத்தவும். இல்லையெனில், தாமத நேரத்தில் நிரல் பதிலளிக்காது, இது எப்போதும் நல்லதல்ல. மேலும், ஒரு வளையத்தில் N ஐத் தேர்ந்தெடுப்பது, கட்டளைகளைச் செயல்படுத்துவதைப் பொறுத்தது என்றால், எதிர்பாராத முடிவுகளைப் பெறலாம். வெளிப்படையாக அசல் ஆசிரியர் ஒரு சிறந்த கம்பைலரைப் பற்றி கேள்விப்பட்டதே இல்லை ... அது உண்மையில் எதையும் செய்யவில்லை என்றால் அது ஒரு முழு வளையத்தையும் மேம்படுத்தும்!
- "ஃபார்-லூப்" முறையைப் பயன்படுத்தும் போது, வெற்று அறிக்கை மிக வேகமாக இருப்பதால், i க்கு மிகப் பெரிய இடைவெளி எடுக்கலாம். இவ்வளவு பெரிய எண்கள் ஒரு முழு எண் வகைக்கு பொருந்தாது.
- நீங்கள் ஃபார் லூப்பைப் பயன்படுத்தினால், கம்பைலர் குறியீட்டை மேம்படுத்த முடியும், மேலும் லூப் எதுவும் செய்யாததால், அதை அகற்றவும். தாமதம் () பயன்படுத்தும் போது இது நடக்காது.
