KURS C/C++ WYKŁAD 2

KURS C/C++
WYKŁ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
#include<stdio.h>
void main()
{
char znak;
znak = getchar();
// pobierz znak, <enter>
while(znak != �t�)
{
// blok instrukcji
putchar(znak);
//wypisz znak
znak = getchar();
}
}
Program 2
#include<stdio.h>
void main()
{
char znak;
while( (znak = getchar() ) != �t�)
putchar(znak);
}
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
#include<stdio.h>
void main()
{
int ch;
ch = getchar();
while(ch != EOF)
{
putchar(ch);
ch = getchar();
}
}
// blok instrukcji
Program 2
#include<stdio.h>
void main()
{
int ch;
while( (ch = getchar() ) != EOF)
putchar(ch);
}
Wprowadzono symboliczną nazwa EOF (end of file - koniec pliku). Stała EOF jest obiektem
całkowitym zdefiniowanym w standardowym pliku nagłówkowym <stdio.h>. 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<stdio.h>
void main(){
int ch;
do{
ch = getch();
putch (ch);
} while (ch != �a�);
}
Program 2
#include<stdio.h>
#include<conio.h>
void main()
{
int i;
clrscr();
i=2;
while(i != 0)
{ // blok instrukcji
printf (�pętla while i=%d\n�,i);
i=i-1;
getch();
}
printf (�po pętli\n�);
Program 3
#include<stdio.h>
#include<conio.h>
void main()
{
int i;
clrscr();
i=2;
do
{ // blok instrukcji
printf(�pętla do_while i=%d\n�,i);
i--;
getch();
} while (i != 0);
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
#include<stdio.h>
#include<conio.h>
void main()
{
int i=0; float licznik=0;
clrscr();
while(i)
{ // blok instrukcji
printf (?i=%d\n?,i);
i--;
licznik++;
}
printf (�po pętli licznik=%f�,licznik);
}
Program 4
#include<stdio.h>
#include<conio.h>
void main()
{
int i=0; float licznik=0;
clrscr();
do
{ // blok instrukcji
printf (?i=%d\n?,i);
i = i-1;
licznik++;
} while (i);
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<conio.h>
#include<stdio.h>
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�);
1) i = 1
// Pętla wypisze 3 razy ten sam tekst: Jestem w pętli
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)
printf (�Jestem w pętli�);
i=1;
while (i<4){
printf (�Jestem w pętli�);
i = i + 1;
}
Pętlami tzw. nieskończonymi są pętle:
for( ; ; )
{
while( 1)
{
// instrukcje
}
do
{
//instrukcje
}
//instrukcje
} while (1);
Program 1
#include <conio.h>
#include <iostream.h>
void main()
{
clrscr();
for ( int i = 1; i<24; i++){
// int i - deklaracja zmiennej tylko w C++
cout<<i<<" INFORMATYKA \n";
gotoxy (2*i, i);
}
getch();
}
Program 2
#include <iostream.h>
#include <conio.h>
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.