Pętle nieskończone są niezwykle przydatne w rzeczywistych aplikacjach, zwłaszcza tam, gdzie program musi działać przez dłuższy czas lub nieprzerwanie monitorować określone warunki. Oto kilka praktycznych przykładów:
1. Aplikacja monitorująca stan serwera
W systemach sieciowych pętla nieskończona może działać jako mechanizm ciągłego sprawdzania stanu serwera.
Przykład: Monitorowanie połączenia z serwerem
#include <iostream>
#include <thread> // Dla funkcji sleep_for
#include <chrono> // Dla opóźnienia
using namespace std;
int main() {
while (true) {
// Symulacja sprawdzania połączenia z serwerem
cout << "[INFO] Sprawdzanie połączenia z serwerem..." << endl;
// Symulacja problemu z połączeniem
int status = rand() % 5; // Losowy status połączenia (0 = problem)
if (status == 0) {
cout << "[ALERT] Utracono połączenie z serwerem!" << endl;
break;
}
this_thread::sleep_for(chrono::seconds(3)); // Opóźnienie 3 sekundy
}
cout << "Zakończono monitorowanie." << endl;
return 0;
}
2. System logowania danych (np. z czujników)
W wielu urządzeniach IoT lub systemach automatyki przemysłowej konieczne jest ciągłe monitorowanie wartości z czujników.
Przykład: Odczyt temperatury z symulowanego czujnika
#include <iostream>
#include <cstdlib>
#include <thread> // Dla opóźnień
#include <chrono> // Dla funkcji sleep_for
using namespace std;
int main() {
while (true) {
int temperatura = rand() % 40; // Losowa temperatura 0-39
cout << "Aktualna temperatura: " << temperatura << "°C" << endl;
if (temperatura > 35) {
cout << "[OSTRZEŻENIE] Temperatura krytyczna!" << endl;
}
this_thread::sleep_for(chrono::seconds(2)); // Przerwa 2 sekundy
}
return 0;
}
3. Proste menu w aplikacji konsolowej
Pętle nieskończone świetnie sprawdzają się w systemach obsługujących interaktywne menu.
Przykład: Menu konsolowe
#include <iostream>
using namespace std;
int main() {
while (true) {
cout << "\n=== MENU ===" << endl;
cout << "1. Witaj" << endl;
cout << "2. Kalkulator" << endl;
cout << "3. Zakończ" << endl;
cout << "Wybierz opcję: ";
int opcja;
cin >> opcja;
switch (opcja) {
case 1:
cout << "Witaj w naszej aplikacji!" << endl;
break;
case 2:
int a, b;
cout << "Podaj dwie liczby: ";
cin >> a >> b;
cout << "Suma: " << a + b << endl;
break;
case 3:
cout << "Do widzenia!" << endl;
return 0; // Zakończenie programu
default:
cout << "Niepoprawna opcja. Spróbuj ponownie." << endl;
}
}
}
4. Aplikacja zegara cyfrowego
Pętla nieskończona jest doskonałym rozwiązaniem do symulowania działania zegara cyfrowego.
Przykład: Zegar cyfrowy
#include <iostream>
#include <thread> // Dla funkcji sleep_for
#include <chrono> // Dla odmierzania czasu
using namespace std;
using namespace chrono;
int main() {
int godzina = 0, minuta = 0, sekunda = 0;
while (true) {
// Formatowanie czasu
cout << (godzina < 10 ? "0" : "") << godzina << ":"
<< (minuta < 10 ? "0" : "") << minuta << ":"
<< (sekunda < 10 ? "0" : "") << sekunda << endl;
this_thread::sleep_for(seconds(1)); // Czekaj 1 sekundę
sekunda++;
if (sekunda == 60) {
sekunda = 0;
minuta++;
}
if (minuta == 60) {
minuta = 0;
godzina++;
}
if (godzina == 24) {
godzina = 0;
}
}
return 0;
}
5. Symulacja prostego chatu (czat bot)
Pętle nieskończone mogą obsługiwać interakcję z użytkownikiem w stylu czatu.
Przykład: Prosty chatbot
#include <iostream>
#include <string>
using namespace std;
int main() {
string wiadomosc;
while (true) {
cout << "Ty: ";
getline(cin, wiadomosc);
if (wiadomosc == "exit") {
cout << "Bot: Do widzenia!" << endl;
break;
} else if (wiadomosc == "jak się masz") {
cout << "Bot: Dobrze, dziękuję! A Ty?" << endl;
} else {
cout << "Bot: Ciekawa wiadomość, powiedz mi więcej!" << endl;
}
}
return 0;
}
6. Automatyczne próby połączenia z bazą danych
Pętle nieskończone są używane w aplikacjach bazodanowych do automatycznego ponawiania połączeń.
Przykład: Próba połączenia
#include <iostream>
#include <thread>
#include <chrono>
using namespace std;
int main() {
int proby = 0;
while (true) {
proby++;
cout << "Próba #" << proby << ": Łączenie z bazą danych..." << endl;
if (proby == 3) {
cout << "Połączenie nawiązane!" << endl;
break;
}
this_thread::sleep_for(chrono::seconds(2)); // Czekaj 2 sekundy
}
return 0;
}
7. Symulacja automatycznego powiadomienia
Pętla nieskończona może działać jako mechanizm wysyłający powiadomienia w określonych odstępach czasu.
Przykład: System przypomnień
#include <iostream>
#include <thread>
#include <chrono>
using namespace std;
int main() {
while (true) {
cout << "[Powiadomienie] Czas na przerwę! Wstań, rozciągnij się!" << endl;
this_thread::sleep_for(chrono::minutes(30)); // Powiadomienie co 30 minut
}
return 0;
}
Podsumowanie
✅ Pętle nieskończone są kluczowym elementem w programach działających w czasie rzeczywistym.
✅ Znajdują zastosowanie w serwerach, grach, systemach monitorujących, interaktywnych menu i wielu innych dziedzinach.
✅ Należy zawsze zadbać o odpowiedni mechanizm przerwania (break), aby uniknąć blokowania programu.