Wykłady 2. Podstawy programowania C/C++
mgr Teresa Podhorska semestr III - studia dzienne magisterskie
semestr II - studia dzienne zawodowe
Zawartoœć tematyczna:
1. Arytmetyczne wyrażenie warunkowe, operator warunkowy
2. Instrukcje iteracyjne
2.2. Instrukcja while
2.3. Instrukcja do...while
2.4. Instrukcja for
Arytmetyczne wyrażenie warunkowe , operator warunkowy
Instrukcja :
if( a > b)
z = a;
else
z = b;
może być zastąpiona trzyargumentowym operatorem warunkowym: ? :
z = (a>b) ? a : b;
Ogólnie można wyrażenie warunkowe zapisać:
wyr1 ? wyr2 : wyr3;
Wyr2 i wyr3 powinny mieć taki sam typ, jeœli nie to musi być możliwe przekształcenia typów.
Wyrażenia warunkowe często wpływają na zwięzłoœć programu np.:
printf(”Masz %d częœ%s.\n”,n , n = = 1 ? ”ć” : ”ci” );
lub:
for (i = 0; i < n; i++)
printf(”%d%3c”,a[i],(i%10 == 9 || i == n-1) ? '\n' : ' '); //9,19
Znak nowego wiersza w powyższym przykładzie wypisywany jest po każdym dziesiątym elemencie tablicy, natomiast po innych wstawiane są 3 znaki spacji.
Przykład:
int signum(int x){
return
x > 0 ? 1 : x < 0 ? -1 : 0;
}
Błędne jest natomiast:
a ? b = c : c = b; //niezbędne są nawiasy
poprawnie:
a ? (b = c) : (c = b);
tzn: (a != 0) ? (b = c) : (c = b);
znak= = toupper (znak) ? (znak=tolower(znak)) : (znak=tolower(znak));
islower (znak) ? (znak=tolower(znak)) : (znak=tolower(znak));
2. Instrukcje iteracyjne
2.1. 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.
Program 1
#include<stdio.h>
main(){
float kwota;
printf (“podaj kwotę ”);
scanf (“%f”, &kwota);
while (kwota < 0)
{ // blok instrukcji
printf (“błędna kwota, podaj ponownie ”);
scanf (“%f”, &kwota);
}
Blok instrukcji (instrukcja złożona): { lista instrukcji }
{
printf (“błędna kwota, podaj ponownie ”);
scanf (“%f”, &kwota);
}
Program 2
#include<stdio.h>
main(){
int c;
c = getch();
while(c != `*') { // blok instrukcji
putch(c);
c =getch();
}
Blok instrukcji (instrukcja złożona): { lista instrukcji }
{
putch(ch);
ch = getch();
}
Program 3
#include<stdio.h>
void main(){
int c;
while( (c = getch() ) != `*') { // blok instrukcji
putch(c);
c =getch();
}
Program 4, zamiana liter - małych na duże lub dużych na małe
#include<stdio.h>
void main(){
int c;
while( (c = getche()) != `*')
{
if ((c >=`a') && (c <= `z' ) ) // islower(c)
c=c -'a'+'A'; // c=toupper(c);
else if ((c >=`A') && (c <= `Z' ) ) // isupper(c)
c=c -'A'+'a'; // c=tolower(c);
putch (c);
}
}
&& - operator iloczynu logicznego
| | - operator sumy logicznej
Program 5
#include<stdio.h>
#include<conio.h>
#include<ctype.h>
void main(){
int c;
while ( (c = getch()) != `*') { // blok instrukcji
if (islower(c)) c=toupper(c);
else c=tolower(c);
printf (”\nznak: %c kod znaku: %d”, x, x);
}
}
Program 6
#include<stdio.h>
#include<conio.h>
void main(){
int c;
while((c = getch()) != `*')
putch (c>=`A' && c<=`Z' ? c -'A' + 'a' : c -'a' + 'A');
//arytmetyczne wyrażenie warunkowe
}
Program 7
#include<stdio.h>
#include<conio.h>
#include<ctype.h>
void main(){
int c;
while((c = getch()) != `*')
putch (c= = tolower(c) ? toupper(c) : tolower(c);)
//zmienna c nie zostanie zmieniona
}
Program 7 a
#include<stdio.h>
#include<conio.h>
#include<ctype.h>
void main(){
int c;
while((c = getch()) != `*')
islower (c) ? (c = toupper(c)) : (c = tolower(c));
// arytmetyczne wyrażenie warunkowe, zmienna c zostaje zmieniona
putch(c);
}
Program 8
#include<stdio.h>
void main() {
int ch;
while ( (ch=getchar()) !=EOF ) {
putchar(ch);
}
}
Program 9
#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);
}
}
int i; while (i) while (!i) while (i-5) while (!(i-5))
2.2. 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>
main(){
int ch;
do{
ch = getchar();
putchar(ch);
} while(ch != EOF);
}
Program 2
#include<stdio.h>
main(){
int kwota;
do{
puts (”podaj wpłatę ”);
scanf (”%f”, &kwota);
} while ( kwota<=0); //kontrolujemy wprowadzaną wartoœć, jeżeli podana
//kwota jest ujemna żądamy ponownego wprowadzenia.
}
Program 3
#include<iostream.h>
#include<conio.h>
#include<math.h>
#include<iomanip.h> //setw, precision
void main(){
float suma=1, p, i=1;
clrscr();
cout.precision(10);
cout<<setw(14)<<”p”<<setw(14)<<”sqrt(1/i)”<<setw(14)<<"suma"<<setw(18)
<<"fabs(p-suma)”<<”\n”;
do
{
p=suma;
suma=suma+1/(pow (2,i)); //potgowanie
cout<<setw(14)<<p<<setw(14)<<sqrt(1/i)<<setw(14)<<suma<<setw(18)
<<fabs(p-suma)<<"\n";
i++;
} while ((fabs(suma-p)) > 0.0001);
getch();
}
Program 4
#include<conio.h>
#include<stdio.h>
void main() {
int i, w1;
float w2;
i=2;
w2= 1/i; // w2=0.0
w2= 1./i; // w2=0.5
w2= float (1)/i; // w2=0.5
w2= float (1/i); // w2=0.0
w1=1./i; // w1=0
getch();
}
Program 5
#include<conio.h>
#include<stdio.h>
void main() {
char nazwa [30];
int rok;
do {
printf ("podaj rok powstania firmy: ”);
scanf(”%d”, &rok);
fflush (stdin); //opróżnianie bufora
printf ("podaj nazwę instytucji”);
gets (nazwa);
} while (nazwa[0] != `*'); //badamy czy nazwa rozpoczyna się od gwiazdki
getch();
}
#include<stdio.h> main() { int i; i=2; while(i != 0) {printf (”Jestem w pętli while i=%d\n”,i); i--; //i=i-1; getch(); } } |
#include<stdio.h> main() { int i; i=2; do {printf (” Jestem w pętli do_while i=%d\n”,i); i--; getch(); } while (i != 0); } |
EKRAN:
Jestem w pętli while i=2 Jestem w pętli while i=1 |
Jestem w pętli do_while i=2 Jestem w pętli do_while i=1 |
int i=0; long licznik=0; while(i) { printf (” Jestem w pętli while i=%d\n”,i”); i--; //i=i-1; licznik++; //licznik=licznik+1; } printf (”Jestem po pętli while); |
int i=0; long licznik=0; do { printf (” Jestem w pętli do_while i=%d\n”,i”); i--; licznik++; } while (i); printf (”licznik = %ld”,licznik); |
EKRAN: Jestem po pętli while |
Jestem w pętli do_while i=0 i=i-1=0-1=-1 Jestem w pętli do_while i=-1 i=i-1=-1-1=-2 ...... licznik=65536 |
2.3. Instrukcja for
Składnia pętli for ma postać:
for (instr_ini; wyr_war; wyr_krok) instrukcja
instr_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 zmiennych indeksujących pętlę.
Wszystkie składniki w nawiasie są opcjonalne, jednak muszą być zachowane oddzielające je œredniki.
Wyrażenie wyr_war musi być typu arytmetycznego (całkowite+rzeczywiste) lub wskaŸnikowego.
Praca pętli for wykonywana jest według nastepującego algorytmu:
wykonują się instrukcje inicjujące pętlę instr_inic.
Obliczana jest wartoœć wyrażenia wyr_war. Jeœli wartoœć tego wyrażenia jest równa zero, praca pętli jest przerywana.
Jeœli powyżej okazało się, że wyr_war jest != 0, wtedy wykonywana jest instrukcja
Po wykonaniu instrukcji, obliczana jest wartoœć wyrażenia wyr_krok. Po czym powtarzany jest punkt 2.
Pętlą równoważną pętli for jest while w potaci:
instr_inic;
while (instr_warunkowa) {
instrukcje
}
for (i =1; i < 4; i=i+1) printf (”%d”,i);
|
i=1; while (i<4){ printf (”%d”,i); i++; } |
instr_inic może zawierać także deklaracje zmiennych, ale tylko w C++.
Program 1
#include <stdio.h>
#include <conio.h>
void main(){
const il_linii=25;
clrscr();
for ( int i = 1; i<=il_linii; i++){ // int i - deklaracja zmiennej tylko w C++
gotoxy (2*i, i);
printf ("INFORMATYKA");
}
getch();
clrscr();
for ( int i = il_linii; i>=1; i--) // BŁĄD zmienna i nie może być redeklarowana.
printf (* INFORMATYKA \n");
}
Przykład
const roz=12;
int tab[roz];
long int suma;
randomize();
suma=0;
for (i=0; i<roz; i++){
tab[i]=random(100);
suma=suma + tab[i];
}
printf (”%ld”, suma);
Wyrażeń:
instr_ini, wyr_war, wyr_krok
może być kilka,wtedy rozdzielane są przecinkami.
for (i =1, j=1; i < 4, j<2; i++, j++)
i < 4, j<2 - oba warunki musza być fałszywe,
lub
for (i =1, j=1; i < 4 | | j<2; i++, j++) | | - operator sumy logicznej
for (i =1, j=1; i < 4 && j<2; i++, j++) && - operator iloczynu logicznego
Pętlami tzw. nieskończonymi są pętle:
for ( ; ; ) while( 1) do
{ { {
// instrukcje //instrukcje //instrukcje
} } } while (1);