విషయము

• దశలు
• 2 వ పద్ధతి 1: లూప్ టెక్నిక్ కోసం
• 2 వ పద్ధతి 2: "నిద్ర ()" టెక్నిక్
• నమూనా కోడ్
• చిట్కాలు
• హెచ్చరికలు

నిర్దిష్ట సమయం కోసం వేచి ఉండే C ప్రోగ్రామ్‌ను మీరు ఎప్పుడైనా సృష్టించాలనుకుంటున్నారా? మీరు "ఫ్లై బై" సమయం ఇవ్వడానికి మార్గాన్ని అనుకూలీకరించవచ్చు, ఉదాహరణకు: గేమ్ కోసం పాప్-అప్ పేజీ (నోటిఫికేషన్ లేదా సూచన) చూపించినప్పుడు. ... సరే, "ఇంకా నిలబడండి" ప్రోగ్రామ్‌ను రూపొందించడానికి ఇక్కడ కొన్ని మార్గాలు ఉన్నాయి, చదవండి ...

దశలు

1. 1 గమనించదగ్గ ఈవెంట్‌ని కలిగించకుండా మీ ప్రాసెసర్‌ని కాసేపు అమలు చేయనివ్వండి.
2. 2 సాధారణ సమయ ఆలస్యాన్ని సృష్టించడానికి ఈ ఆలస్యం సమయంలో ఏ ఇతర కార్యకలాపాలను నిర్వహించవద్దు.

2 వ పద్ధతి 1: లూప్ టెక్నిక్ కోసం

1. 1 విలక్షణమైన "ఫర్" లూప్‌ని ఉపయోగించండి, దాని తర్వాత ఖాళీ స్టేట్‌మెంట్‌ను ఆలస్యం చేయడానికి అమలు చేయండి.
2. 2 కింది విధంగా వ్రాయండి, ఉదాహరణకు:
   • (i = 1; i100; i ++) కోసం;
   • ";" ని అనుసరించే ఆపరేటర్ గుర్తించదగిన ఈవెంట్ లేకుండా కంప్యూటర్‌ను 100 సార్లు లూప్ చేయమని బలవంతం చేస్తుంది. ఇది సమయ ఆలస్యాన్ని మాత్రమే సృష్టిస్తుంది.

2 వ పద్ధతి 2: "నిద్ర ()" టెక్నిక్

1. 1 నిద్ర () ఉపయోగించండి. ఫంక్షన్‌ను నిద్ర (int ms) అని పిలుస్తారు, TIME.H> లో ప్రకటించబడింది, ఇది ప్రోగ్రామ్‌ను మిల్లీసెకన్లలో నిర్దిష్ట సమయం కోసం వేచి ఉండేలా చేస్తుంది.
2. 2 Int ప్రధాన () ముందు మీ ప్రోగ్రామ్‌లో కింది లైన్‌ను చేర్చండి:
   • #TIME.H> ని చేర్చండి
3. 3 మీ ప్రోగ్రామ్ ఆలస్యం చేయడానికి అవసరమైన చోట అతికించండి:
   • నిద్ర (1000);
   • "1000" ని మీరు వేచి ఉండాలనుకుంటున్న మిల్లీసెకన్ల సంఖ్యకు మార్చండి (ఉదాహరణకు, మీరు 2 సెకన్ల ఆలస్యం చేయాలనుకుంటే, దాన్ని "2000" తో భర్తీ చేయండి.
   • చిట్కా: కొన్ని సిస్టమ్‌లలో, విలువ మిల్లీసెకన్లకు బదులుగా సెకన్లలో పేర్కొనబడవచ్చు. అందువల్ల, కొన్నిసార్లు 1000 అనేది 1 సెకను కాదు, వాస్తవానికి 1000 సెకన్లు.

నమూనా కోడ్

నిర్దిష్ట సంఖ్యలో సెకన్ల పాటు వేచి ఉండే ప్రోగ్రామ్:

#stdio.h> #చేర్చండి dos.h> int ప్రధాన () {int del; // ఆలస్యం వ్యవధి printf ("ఆలస్యం సమయాన్ని నమోదు చేయండి (సెకన్లలో):"); scanf ("% i" ,? డెల్); డెల్ * = 1000; // మిల్లీసెకన్ల ఆలస్యం (డెల్) గా మార్చడానికి దానిని 1000 ద్వారా గుణించండి; // ఆలస్యం. printf ("పూర్తయింది"); రిటర్న్ 0; }

10 నుండి 0 కి లెక్కించబడే ప్రోగ్రామ్:

#STDIO.H> #TIME.H> int ప్రధాన () {int i; (i = 10; i> = 0; i--) {printf ("% i n", i); // ప్రస్తుత 'కౌంట్‌డౌన్' సంఖ్య ఆలస్యం (1000) వ్రాయండి; // ఒక్క క్షణం ఆగు} తిరిగి 0; }

చిట్కాలు

• మిల్లిసెకండ్ అనేది సెకనులో 1/1000.
• పై అల్గోరిథం శూన్య ఆపరేటర్ అనుసరించే ఏదైనా లూపింగ్ స్ట్రక్చర్‌ని ఉపయోగించి అమలు చేయవచ్చు - "; అయితే లేదా చేస్తున్నప్పుడు లూప్‌లను ఉపయోగిస్తున్నట్లుగా.

హెచ్చరికలు

• ఈ పద్ధతి సాధారణంగా పనికిమాలిన ప్రోగ్రామ్ కాకుండా దేనికీ పనికిరాదు. సాధారణంగా, దీనిని సాధించడానికి టైమర్‌లు లేదా ఈవెంట్-ఆధారిత విధానాన్ని ఉపయోగించండి. లేకపోతే, ఆలస్యం సమయంలో ప్రోగ్రామ్ ప్రతిస్పందించదు మరియు ఇది ఎల్లప్పుడూ మంచిది కాదు. అలాగే, లూప్‌లో N ని ఎంచుకోవడం, అది ఆదేశాల అమలుపై ఆధారపడి ఉంటే, ఊహించని ఫలితాలను పొందవచ్చు. ఆప్టిమైజింగ్ కంపైలర్ గురించి అసలు రచయిత ఎన్నడూ వినలేదు ... అది నిజంగా ఏమీ చేయకపోతే అది మొత్తం లూప్‌ను ఆప్టిమైజ్ చేయగలదు!
• "ఫర్-లూప్" పద్ధతిని ఉపయోగించినప్పుడు, ఖాళీ స్టేట్‌మెంట్ చాలా వేగంగా ఉన్నందున, i కోసం ఇది చాలా పెద్ద విరామం తీసుకోవచ్చు. అంత పెద్ద సంఖ్యలు ఒక పూర్ణాంక రకానికి సరిపోకపోవచ్చు.
• మీరు లూప్ కోసం ఉపయోగిస్తే, కంపైలర్ కోడ్‌ను ఆప్టిమైజ్ చేయగలదు మరియు లూప్ ఏమీ చేయనందున, దాన్ని తీసివేయండి. ఆలస్యం () ఉపయోగిస్తున్నప్పుడు ఇది జరగదు.