WYKŁAD 2. OPERATORY I INSTRUKCJE 2_1. Operatory

WYKŁAD 2. OPERATORY I INSTRUKCJE
2_1. Operatory przypisania
Instrukcje z operatorami przypisania
Instrukcje
z operatorem
złożonym
Równoważne
instrukcje
z operatorem
prostym
j+=delta;
j=j+delta;
j-=delta;
j=j-delta;
j*=delta:
j=j*delta:
j/=delta;
j=j/delta;
j%=delta;
j=j%delta;
Przykład:
int x=2; //x==2
x+=3;
//x==5
x-=2;
//x==3
x*=5;
//x==15
2_2. Operatory inkrementacji i dekrementacji
Operatory inkrementacji/dekrementacji
Operator
inkrementacji
Operator
dekrementacji
Postać
przedrostkowa
++Op
--Op
Postać
przyrostkowa
Op++
Op--
Różnica działania pomiędzy operatorem w postaci ++ Op a operatorem w
postaci Op++ ujawnia się w złożonych wyrażeniach:
Operator przedrostkowy ++ Op działa przed obliczeniem wartości wyrażenia.
Operator przyrostkowy Op++ działa po obliczeniu wartości wyrażenia.
Przykłady
int a=8,b=1,x;
x=(++a)+(++b);
//x==9+2==11, a==9, b==2
int a=8; b=1, x;
x=(a++)+(b++);
//x==8+1==9, a==9, b==2
int s=0, j=1;
s+=j++; //s==1,
s+=j++; //s==3,
s+=j++; //s==6,
s+=j++; //s==10,
j==2
j==3
j==4
j==5
2_3. Hierarchia operatorów
Operatory C++ w porządku malejącego priorytetu
Operatory
()
[]
->
::
Wiązanie
.
L → P
! ~ + -- ++ sizeof new delete
P → L
.*
L → P
->*
*
/
+
-
<<
%
L → P
L → P
L → P
>>
<
<=
==
!=
>
>=
L → P
L → P
&
L → P
^
L → P
|
L → P
&&
L → P
||
L → P
?:
P → L
=
,
*=
/=
%=
+=
-=
&=
^= |=
<<=
>>=
P → L
L → P
2_4. Funkcje i stałe matematyczne określone w <math.h>
Wywołanie
double x,y,a;
y=sin(x);
y=cos(x);
y=tan(x);
y=asin(x);
y=acos(x);
y=atan(x);
y=exp(x);
y=log(x);
y=log10(x);
y=pow(x,a);
y=sqrt(x);
y=ceil(x);
y=floor(x);
y=fabs(x);
y=fmod(x,a);
y=hypot(a,x);
y=modf(x,&a);
Obliczona wartość
Sinus kąta x (kąt w radianach)
Kosinus kąta x (kąt w radianach)
Tangens kata x (kąt w radianach)
Arkus sinus argumentu x (x w przedziale <-1,1>)
Arkus kosinus argumentu x (x w przedziale <-1,1>)
Arkus tangens argumentu x
ex
Logarytm naturalny liczby x
Logarytm dziesiętny liczby x
Liczba x do potęgi a
Pierwiastek kwadratowy nieujemnej liczby x
Zaokrąglenie x w górę
Zaokrąglenie x w dół
Wartość bezwzględna liczby x
Reszta z dzielenia x/a
Przeciwprostokątna trójkąta o bokach a, x
Część ułamkowa liczby x zostaje przypisana do y, część
całkowita x przekazana do argumentu a.
Stałe określone w zbiorze nagłówkowym <math.h>
Nazwa stałej
M_PI
M_PI_2
M_1_PI
M_SQRT2
M_SQRT_2
M_E
M_LOG2E
M_LOG10E
M_LN2
M_LN10
Wartość
3.1415926535897931200
1.57079632679489661923
0.3183098861837906738
1.41421356237309504880
0.70710678118654752440
2.71828182845904523536
1.44269504088896340736
0.434294481903251827651
0.69314718055945309417
2.30258509299404568402
Znaczenie
π
π/22
1/π
π
sqrt(2)
1/sqrt(2)
e
log2(e)
log10(e)
ln(2)
ln(10)
Przykład
Program obliczający pierwiastek kwadratowy metodą Newtona
#include<conio.h> //dla clrscr
#include<stdio.h> //dla printf,scanf
#include<math.h> //dla sqrt
int main() {
clrscr();
double x,p;
printf("Podaj x: ");
scanf("%lf",&x);
printf("\nKolejne aproksymacje:");
p=x/2.0;
// 0. przybliżenie
printf("\n\n%.9lf",p);
p=(x+p*p)/(2*p);
printf("\n%.9lf",p);
// 1. przybliżenie
p=(x+p*p)/(2*p);
printf("\n%.9lf",p);
// 2. przybliżenie
p=(x+p*p)/(2*p);
printf("\n%.9lf",p);
// 3. przybliżenie
p=(x+p*p)/(2*p);
printf("\n%.9lf",p);
// 4. przybliżenie
printf("\n\nFunkcja sqrt(%.1lf) zwraca:
%.9lf",x,sqrt(x));
getch();
return 0;
}
Po wprowadzeniu za x wartości 2, na ekranie pojawi się tekst:
Podaj x: 2
Kolejne aproksymacje:
1.000000000
1.500000000
1.416666667
1.414215686
1.414213562
Funkcja sqrt(2.0) zwraca: 1.414213562
2_5. Instrukcje warunkowe
Instrukcja if
if (wyr_relacyjne)
{
instrukcja_1;
instrukcja_2;
//--------instrukcja_n;
}
Graf działania instrukcji warunkowej if
0
wyrażenie
relacyjne
1
{
instrukcja 1
instrukcja 2
//-------instrukcja n
}
Instrukcja if-else
if (wyr_relacyjne)
{
instrukcja_1_1;
instrukcja_1_2;
//--------instrukcja_1_n;
}
else
{
instrukcja_2_1;
instrukcja_2_2;
//--------instrukcja_2_m;
}
Graf działania instrukcji warunkowej if–else
0
{
}
instrukcja 2–1
instrukcja 2–2
//------------instrukcja 2–m
wyrażenie
relacyjne
1
{
}
instrukcja 1–1
instrukcja 1–2
//------------instrukcja 1–n
2.6. Zagnieżdżone instrukcje warunkowe
Przykład
Obliczenie wieku osoby
#include <conio.h>
#include <stdio.h>
int main()
{
int r0,m0,d0,r1,m1,d1,wiek;
printf("Podaj rok, miesiac, dzien urodzenia: ");
scanf("%d%d%d",&r0,&m0,&d0);
printf
("Podaj dzisiejsza date: rok, miesiac, dzien: ");
scanf("%d%d%d",&r1,&m1,&d1);
wiek=r1-r0;
if(m0>m1) wiek--; //zagnieżdżone if-else
else if(m0==m1)
if(d0>d1) wiek--;
//else if (m0==m1 && d0>d1) wiek--;
printf("\nMasz %d lat.",wiek);
getch();
return 0;
}
2_7. Operatory logiczne w instrukcjach warunkowych
W języku C++ istnieją trzy operatory logiczne:
Koniunkcja
Alternatywa
Negacja
&&
||
!
Działanie operatorów logicznych
Operandy i ich
wartości
Wyrażenia logiczne i ich wartości
Op1
Op1 &&
Op2
Op2
Op1 ||
Op2
! Op1
fałsz
fałsz
fałsz
fałsz
prawda
fałsz
prawda
fałsz
prawda
prawda
prawda
fałsz
fałsz
prawda
fałsz
prawda
prawda
prawda
prawda
fałsz
Uwaga: W C++ wartość fałsz jest reprezentowana przez liczbę 0,
a wartość prawda jest reprezentowana przez liczbę 1.
Przykład
Sprawdzenie, czy wartość x jest w przedziale <P, K>
#include<conio.h>
#include<stdio.h>
int main()
{
const double P=-1.0, K=1.0;
double x;
printf("Podaj x: ");
scanf("%lf",&x);
if(x>=P && x<=K) //użycie operatora koniunkcji &&
printf
("Poziom x==%.3lf jest dopuszczalny.",x);
else printf("x==%.3lf jest poza zakresem!",x);
getch();
return 0;
}
2_8. Instrukcja wyboru switch
służy do wyboru jednej spośród kilku instrukcji (lub sekwencji instrukcji),
zależnie od wartości pewnego wyrażenia typu całkowitego, zwanego
wyrażeniem sterującym.
switch (wyrażenie_sterujące)
{
case stała_1:instrukcja;
- - - instrukcja;
break;
case stała_2:instrukcja;
- - - instrukcja;
break;
// - - - - - - - - - - - - case stała_n:instrukcja;
- - - instrukcja;
break;
default: instrukcja;
- - - instrukcja;
}
wyrażenie_sterujące ==
1
2
3
inna wartość
case 1: instrukcja;
--instrukcja;
break;
case 2: instrukcja;
--instrukcja;
break;
case 3: instrukcja;
--instrukcja;
break;
default: instrukcja;
--instrukcja;
Graf działania instrukcji wyboru
Przykład
//kalkul.cpp
//4-działaniowy kalkulator
#include <stdio.h>
#include <conio.h>
#include <stdlib.h> //dla system()
int main()
{
double a,b,wynik;
char op;
int k=0;
printf("\nWybierz operacje (+, -, *, /): ");
scanf("%c",&op);
printf("\nPodaj pierwszy argument: ");
scanf("%lf",&a);
printf("\n\nPodaj drugi argument: ");
scanf("%lf",&b);
switch
{
case
case
case
case
(op)
'+':
'-':
'*':
'/':
wynik=a+b; break;
wynik=a-b; break;
wynik=a*b; break;
if (b!=0) wynik=a/b;
else k=1; break;
default: k=2;
}
system("CLS"); //czyszczenie ekranu
if (k==0)
printf("\n%.3lf%c%.3lf=%.3lf",a,op,b,wynik);
else if (k==1) printf("\nDzielenie przez zero!");
else printf("\nNie ma takiej operacji!");
getch();
return 0;
}