4. Operatory matematyczne, porównania i logiczne - majsylw/Introduction-to-programming-in-C GitHub Wiki

Gdy wiemy już, jakie typy danych możemy przechowywać, czas dokonać pierwszych operacji na nich!

Język C udostępnia typowe operacje powszechnie znane z lekcji matematyki:

• dodawanie (+)
• odejmowanie (-)
• mnożenie (*)
• dzielenie (/)
• reszta z dzielenia, czyli dzielenie modulo (%)

Teraz prosty program ilustrujący wykorzystanie tych operatorów:

#include <stdio.h>

int main(){
    int x = 7;
    int y = 3;
    
    int suma = x + y;
    printf("Dodawanie: %d", suma);
    
    int roznica = x - y;
    printf("Różnica: %d", roznica);
    
    int iloczyn = x * y;
    printf("Iloczyn: %d", iloczyn);
    
    int iloraz = x / y;
    printf("Iloraz: %d", iloraz);
    float ilorazf = x / (float)y; // aby otrzymać wynik w postaci liczby zmiennoprzecinkowej
    // musimy zmienną przechowującą wynik zadeklarować jako float, ale także zrzutować jedną ze zmiennych x lub y na typ float
    // w przeciwnym razie otrzymalibyśmy wynik równy 2.00
    printf("! Iloraz: %.2f", ilorazf);
    
    int reszta = x % y;
    printf("Reszta z dzielenia: ", reszta);

    return 0;    
}
/*
Dodawanie: 10
Różnica: 4
Iloczyn: 21
Iloraz: 2
! Iloraz: 2.33
Reszta z dzielenia: 1
*/

Jak już pewnie, Czytelniku, zdążyłeś zauważyć szczególne miejsce w programowaniu zajmuje operator przypisania =, który znaczy tyle, co: to jest, tyle wynosi. Jest to operacja inicjalizowania zmiennej, czyli posługując się terminologią z poprzednich lekcji - wkładania pewnej wartości do pudełeczka nazwanego przez nas w pewien specyficzny sposób. Czasami zajdzie potrzeba, aby zmodyfikować wartość stworzonej już zmiennej na podstawie dotychczasowej wartości już w niej przechowywanej. Wyobraźmy sobie, że mamy 3 kulki w koszyczku. Teraz chcemy dodać jeszcze 2 nowe kuleczki do koszyka. Na podstawie dotychczasowej wiedzy moglibyśmy napisać:

int liczba_kulek_w_koszyku = 3;
liczba_kulek_w_koszyku = liczba_kulek_w_koszyku + 2;
printf("%d",liczba_kulek_w_koszyku);
// 5

Jednak taki zapis zajmuje sporo miejsca i można go w pewien sposób skrócić:

int liczba_kulek_w_koszyku = 3;
liczba_kulek_w_koszyku += 2;
printf("%d",liczba_kulek_w_koszyku);
// 5

Operator += jest operatorem, który modyfikuje zmienną stojącą po lewej stronie, dodając do jej dotychczasowej wartości wartość stojącą po prawej stronie. Analogicznie mamy operatory -=, *=, /=, %=.

Warto przy okazji zaznaczyć, że w języku C, mamy jeszcze operatory:

• ++, zwiększający wartość zmiennej o 1, działający podobnie do operatora +=,
• --, zmniejszający wartość zmiennej o 1, działający podobnie do operatora -=.

Operatory inkrementacji (++) oraz dekrementacji -- mogą stać przed (pre), jak i po (post) zmiennej, na którą oddziałują. Wiąże się to z kolejnościa wykonywania działań, np.

int x = 4;
printf("%d\n",++x); // najpierw do x zostanie dodana wartość 1, a potem wyświetlona, więc zobaczymy na ekranie 5
printf("%d\n",x++); // najpierw zmienna x zostanie wyświetlona, więc zobaczymy na ekranie 5, potem nastąpi inkrementacja
printf("%d\n",x); // przy tym wyświetleniu zobaczymy już wartość 6

W przypadku operatorów matematycznych warto wspomnieć o bibliotece math. Pisząc programy często okazuje się, że podstawowe działania matematyczne, jakie udostępnia nam język są niewystarczające. Z pomocą przychodzi tu ta biblioteka. Umożliwia ona zaokraglanie liczb (według zasad matematycznych, czy też w górę lub w dół), zastosowanie powszechnie znanych funkcji (exp, cos czy sin, a nawet pow) oraz posiada podstawowe stałe matematyczne (takie jak e czy pi). Jeśli będziesz wykorzystywał stałe matematyczne z biblioteki math.h z pewnością nie musisz się martwić o dokładność wyników, ponieważ stałe te zawierają conajmniej 18 cyfr po przecinku. Zachęcam do dokładniejszego zapoznania się z tą biblioteką.

Przejdźmy teraz do operatorów porównań. Można je postrzegać dokładnie tak samo, jak operatory arytmetyczne, takie jak dodawanie, jednak ich wynikiem są wartości logiczne, tj. prawda (1) albo fałsz (0). Zacznijmy od przykładu:

int logiczna = 4 < 5;
printf("%d",logiczna);
// 1

oraz:

int logiczna = 6 >= 10;
printf("%d",logiczna);
// 0

Operatory porównania sprawdzają relację pomiędzy dwiema zmiennymi i zwracają wartość logiczną, czy sprawdzana relacja zachodzi (prawda) czy nie (fałsz). Oto lista operatorów logicznych w języku C:

• < - mniejsze
• <= - mniejsze równe, zwróćmy uwagę, że zapisujemy tak jak czytamy, nie ma operatora =< (równe mniejsze)
• > - większe
• >= - większe równe
• != - różne
• == - równa się.

Tutaj bardzo ważne jest, aby odróżniać operator przypisania (=) od operatora porównania (==). To bardzo częsty błąd. Operator = nie jest symetryczny, ma na celu przekopiowanie wartości z prawej do lewej, podczas gdy operator == jest operatorem zwracającym wartość logiczną, jest on operatorem symetryczym, a pisząc to mam na myśli tyle, że tutaj nie ma znaczenia zamienienie kolejnością argumentów. Poniżej prosty kod, który ilustruje działanie poszczególnych operatorów:

# include <stdio.h>

int main(){
    int x = 7;
    int y = 3;
    
    printf("%d < %d == %d\n", x, y, x < y);
    printf("%d <= %d == %d\n", x, y, x <= y);
    printf("%d > %d == %d\n", x, y, x > y);
    printf("%d >= %d == %d\n", x, y, x >= y);
    printf("%d == %d == %d\n", x, y, x == y);
    printf("%d != %d == %d\n", x, y, x != y);

    return 0;

}
/*
7<3 == 0
7<=3 == 0
7>3 == 1
7>=3 == 1
7!=3 == 1
7==3 == 0
*/

Zauważ, że w powyższym kodzie przekazałam kilka argumentów do funkcji print, stosując odpowiednią liczbę i typ znaczników konwersji w zastosowanym łańcuchu znaków.

W temacie operatorów pozostały nam jeszcze operatory logiczne, czyli takie, których argumentami są wartości logiczne oraz ich wynik także jest taką wartością. Są to znane nam z lekcji logiki operatory koniunkcji (and), alternatywy (or), a także zaprzeczenia (not).

Operator koniunkcji, &&, utożsamiany z polskim i. Zwraca wartość True wtedy i tylko wtedy, gdy oba argumenty są równe True. Operator alternatywy, ||, utożsamiany z polskim lub. Zwraca wartość True wtedy i tylko wtedy, gdy przynajmniej jeden argument jest równy True (uwaga: prawdę otrzymamy również gdy oba warunki będą prawdziwe). Operator zaprzeczenia, !, utożsamiany z polskim nie. Zwraca wartość przeciwną, niż sprawdzany argument.

printf("1 i 1: %d\n", 1 && 1);
// 1 i 1: 1 
printf("0 i 1: %d\n", 0 && 1);
// 0 i 1: 0
printf("1 i 0: %d\n", 1 && 0);
// 1 i 0: 0
printf("0 i 0: %d\n", 0 && 0);
// 0 i 0: 0

printf("1 lub 1: %d\n", 1 || 1);
// 1 lub 1: 1
printf("0 lub 1: %d\n", 0 || 1);
// 0 lub 1: 1
printf("1 lub 0: %d\n", 1 || 0);
// 1 lub 0: 1
printf("0 lub 0: %d\n", 0 || 0);
// 0 lub 0: 0

printf("nie 1: %d\n", !1);
// nie 1: 0
printf("nie 0: %d\n", !0);
// nie 0: 1

// Przykład zastosowania
int wiek = 35;
int czy_wiek_produkcyjny = (18 <= wiek and wiek <= 65);
printf("%d", czy_wiek_produkcyjny);
// 1

W temacie operatorów na tę lekcję to już wszystko, w następnej poznamy jakie możliwości daje nam tworzenie własnych funkcji.