KURS C/C++
WYKA
AD 2
Instrukcje iteracyjne
Instrukcja while
Składnia tej instrukcji jest następująca:
while (wyrażenie) instrukcja
W pętli while wykonanie instrukcji powtarza się tak długo, jak długo wartość wyrażenia jest
różna od zera. Sprawdzenia tego dokonuje się przed każdym wykonaniem instrukcji.
char znak;
znak =żÿażÿ;
Program 1 Program 2
#include #include
void main() void main()
{ {
char znak; char znak;
znak = getchar(); // pobierz znak, while( (znak = getchar() ) != żÿtżÿ)
while(znak != żÿtżÿ) putchar(znak);
{ // blok instrukcji }
putchar(znak); //wypisz znak
znak = getchar();
}
}
Blok instrukcji (instrukcja złożona): { lista instrukcji }
{
putchar(ch);
ch = getchar();
}
Funkcja
int getchar(void)
zwraca czytany znak (kod). W przypadku gdy napotka koniec zbioru lub gdy wystąpi błąd w
operacji czytania zwraca EOF.
Funkcja
int putchar(int c)
zwraca wysyłany znak c lub EOF gdy powstał błąd.
Program 1 Program 2
#include #include
void main() void main()
{ {
int ch; int ch;
ch = getchar(); while( (ch = getchar() ) != EOF)
while(ch != EOF) putchar(ch);
{ // blok instrukcji }
putchar(ch);
ch = getchar();
}
}
Wprowadzono symboliczną nazwa EOF (end of file - koniec pliku). Stała EOF jest obiektem
całkowitym zdefiniowanym w standardowym pliku nagłówkowym . W Borland 3.1,
EOF przyjmuje wartość -1, w niektórych implementacjach jako 0.
Instrukcja do...while
Składnia instrukcji jest następująca:
do instrukcja while wyrażenie
W pętli do...while wykonanie instrukcji powtarza się tak długo, jak długo wartość wyrażenia jest
różna od zera. Sprawdzenia tego dokonuje się po każdym wykonaniu instrukcji, dlatego pętla
wykona się zawsze co najmniej raz; to różni ją od pętli while która może nie wykonć się wcale.
Program 1
#include
void main(){
int ch;
do{
ch = getch();
putch (ch);
} while (ch != żÿażÿ);
}
Program 2 Program 3
#include #include
#include #include
void main() void main()
{ {
int i; int i;
clrscr(); clrscr();
i=2; i=2;
while(i != 0) do
{ // blok instrukcji { // blok instrukcji
printf (żÿpÄ™tla while i=%d\nżÿ,i); printf(żÿpÄ™tla do_while i=%d\nżÿ,i);
i=i-1; i--;
getch(); getch();
} } while (i != 0);
printf (żÿpo pÄ™tli\nżÿ); printf (żÿpo pÄ™tli\nżÿ);
} }
EKRAN:
pętla while i=2 pętla do_while i=2
pętla while i=1 pętla do_while i=1
po pętli po pętli;
Program 3 Program 4
#include #include
#include #include
void main() void main()
{ {
int i=0; float licznik=0; int i=0; float licznik=0;
clrscr(); clrscr();
while(i) do
{ // blok instrukcji { // blok instrukcji
printf (?i=%d\n?,i); printf (?i=%d\n?,i);
i--; i = i-1;
licznik++; licznik++;
} } while (i);
printf (żÿpo pÄ™tli licznik=%fżÿ,licznik); printf(żÿpo pÄ™tli licznik=%fżÿ,licznik);
} }
EKRAN:
licznik=0 i=0
Jestem po pętli while i=i-1=0-1=-1
i=-1
i=i-1=-1-1=-2
i=-2
i=i-1=-2-1=-3
......
po pętli licznik=65536
Przykłady pętli:
Przykład 1,
float kwota;
do
 {
printf (? Podaj wpÅ‚acanÄ… kwotÄ™ żÿ);
scanf (?%f?, &kwota);
} while (kwota<=0);
Przykład 2.
int liczba;
do
{
cout<<żÿPodaj liczbÄ™ caÅ‚kowitÄ… z przedziaÅ‚u <10, 100>żÿ ;
cin>>liczba;
} while ( (liczba<10) | | (liczba>10)); // | | operator logiczny lub (suma logiczna)
Przykład 3.
int liczba;
do
{
cout<<żÿPodaj liczbÄ™ caÅ‚kowitÄ… z przedziaÅ‚u (-?,10) lub (100, +?) ;
cin>>liczba;
} while ( (liczba>=10) && (liczba<=100)); //&& - operator logiczny i (iloczyn logiczny)
Program 5
#include
#include
void main() {
char ch;
// zakończenie pętli po wprowadzeniu znaku ENTER
while ( (ch=getchar()) !=0xA){
putchar(ch);
}
while ( (ch=getche()) !=0xD){
putch(ch);
}
}
Instrukcja for
Składnia pętli for ma postać:
for (inst_ini; wyr_war; wyr_krok) instrukcja;
inst _ini wykorzystywana jest zwykle do deklarowania i inicjalizowania zmiennych na potrzeby
pętli
wyr_war wyrażenie warunkowe wykorzystywane jest do testowania warunków wykonywania pętli,
wyr_krok określa zmianę stanu pętli i używane jest zwykle do zwiększania lub zmniejszania
 zmiennej indeksującej pętlę.
Wszystkie składniki w nawiasie są opcjonalne, jednak muszą być zachowane średniki oddzielające
je.
for (i =1; i < 4; i=i+1)
printf (żÿJestem w pÄ™tliżÿ); // PÄ™tla wypisze 3 razy ten sam tekst: Jestem w pÄ™tli
1) i = 1 wartość i jest mniejsza od 4 wypisuje tekst: Jestem w pętli
2) i = i+1=1+1=2 wartość i jest mniejsza od 4 wypisuje tekst: Jestem w pętli
3) i = i+1=2+1=3 wartość i jest mniejsza od 4 wypisuje tekst: Jestem w pętli
4) i = i+1=3+1=4 wartość i nie jest mniejsza od 4 pętla zostaje zakończona
for (i =1; i<4; i++)
printf (żÿJestem %d raz w pÄ™tliżÿ, i); // 3 razy kolejno tekst: Jestem 1 raz w pÄ™tli
Jestem 2 raz w pętli
ostatni raz: Jestem 3 raz w pętli
Praca pętli for wykonywana jest według nastepującego algorytmu:
1. wykonują się instrukcje inicjujące pętlę inst_inic.
2. Obliczana jest wartość wyrażenia wyr_war. Jeśli wartość tego wyrażenia jest równa zero,
praca pętli jest przerywana.
3. Jeśli powyżej okazało się, że wyr_war jest != 0, wtedy wykonywana są instrukcja
4. Po wykonaniu instrukcji, obilczana jest wartość wyrażenia wyr_krok. Po czym powtarzany
jest punkt 2.
Wyrażeń: inst_ini, wyr_war, wyr_krok - może być kilka,wtedy rozdzielane są przecinkami.
Pętlą równoważną pętli for jest while w postaci:
instr_inic;
while (instr1_warunkowa)
{ // instrukcje
instr2;
}
for (i =1; i < 4; i=i+1) i=1;
printf (żÿJestem w pÄ™tliżÿ); while (i<4){
printf (żÿJestem w pÄ™tliżÿ);
 i = i + 1;
}
Pętlami tzw. nieskończonymi są pętle:
for( ; ; ) while( 1) do
{ { {
// instrukcje //instrukcje //instrukcje
} } } while (1);
Program 1
#include
#include
void main()
{
clrscr();
for ( int i = 1; i<24; i++){ // int i - deklaracja zmiennej tylko w C++
cout< gotoxy (2*i, i);
}
getch();
}
Program 2
#include
#include
void main(){
for(int i = 1; i<24; cout<<++i <<"INFORMATYKA\n");
}
Instrukcje:
while (wyrażenie) instrukcja
do instrukcja while wyrażenie
for (inst_ini; wyr_war; wyr_krok) instrukcja;
nazywamy instrukcjami iteracyjnymi.


Wyszukiwarka