owned this note
owned this note
Published
Linked with GitHub
# Zajęcia zerowe
### Plan Zajęć
#### Część pierwsza:
- omówienie szablonu programu w C++ (w Code::Blocks) - co znaczy #include <iostream>, a co using namespace std?
- jakie są typy zmiennych (int, float, string)?
* czym różni się cout << "a"; od cout << a;?
* jak działają operatory arytmetyczne na różnych typach? (dlaczego 5/2=2 a 5.0/2.0=2.5?)
- przydatne skróty w zapisie stringów "\n" "\b"
- warunki - if i else oraz operatory logiczne &&(i), ||(lub), !(nie)
- pętle: for, while, do while i czym różni się i++ od ++i?
- zakresy zmiennych - czym są zmienne lokalne, a czym globalne?
#### Część druga:
- jak działają tablice i jak je tworzymy?
- dlaczego trzeba uważać na zakresy (od 0 do n-1)?
- jak odczytywać i zapisywać dane do tablicy?
- dlaczego czasami tablica ma w sobie same zera, a czasami przypadkowe wartości?
- funkcje wbudowane (max, min, abs) - jak napisać je samemu?
---
### Omówienie szablonu
- **#include <nazwa_biblioteki>** - import odpowiednich bibliotek, dzięki którym możemy korzystać z gotowych funkcji i struktur
#include <iostream> - najbardziej podstawowe funkcje takie jak cout, cin
#include <string> - obsługa zmiennych tekstowych
#include <cmath> - funkcje takie jak min, max, sqrt (pierwiastek)
**#include <bits/stdc++.h>** - importuje wszystkie podstawowe biblioteki
- **using namespace std** określa przestrzeń nazw, w której się znajdujemy oraz pozwala na pisanie **cout**, **cin**, **endl** zamiast **std::cout**, **std::cin**, **std::endl**
- **int main()** funkcja główna, w której wywołujemy pozostałe funkcje i piszemy główną część kodu. **main** zwraca **int**, dlatego na koniec main'a piszemy **return 0;**" (zero oznacza, że program wykonał się poprawnie. Jest to pewna konwencja).
:::warning
Uwaga - niektórzy mogli spotkać się z zapisem void main(), wówczas funcja kończy się bez zwrócenia wartości. (Nie ma "return 0;"). Jest to jednak sposób archaiczny, obecnie zaleca się używanie int main().
:::
### Typy zmiennych
###### Zmienne i ich typy
Zmienna - to jest taki obiekt, który przechowuje dane w programie.
Zmienną tworzymy w następujący sposób:
```cpp=
typ nazwa;
```
###### Typy liczbowe
```cpp=
int liczba; \\ liczba całkowita
float liczba2; \\ liczba zmienno-przecinkowa 6-7 cyfr po przecinku
double liczba3; \\ tzw. podwojna precyzja 15-16 cyfr po przecinku
unsigned int liczba; \\ liczba calkowita bez znaku, tylko dodatnie, podwojony prawy zakres
long int liczba;
```
###### Typ logiczny
```cpp=
bool a = true;
bool b = false;
// LUB
bool a = 1;
bool b = 0;
```
###### Typy znakowe
```cpp=
char znak = 'A';
char znak = 65;
```
###### Napisy - stringi
```cpp =
string napis = "abcd";
//'a' 'b' 'c' 'd' '\0'
// 0 1 2 3 4
// gdzie '\0' to znak specjalny, który oznacza koniec napisu
cout << napis.size();
cout << napis.length();
cout << napis[0];
cout << napis[1];
napis[2] = 'x';
for(int i = 0; i < napis.size(); i++)
{
napis[i] = 'x';
}
string napis2 = "efg";
string napis3 = napis + napis2;
string napis3 += "hij";
// do uzupelnia
string a = "abcdef";
cout << a.length(); // 6
a = "abcdef\0";
cout << a.length() << endl; // 6
a = "abc\0def";
cout << a.length() << endl; // 3
```
NIEPOPRAWNE NAZWY ZMIENNYCH:
```cpp=
int moja-zmienna;
int moja zmienna;
int 12zmienna; // ale zmiennna123 JEST POPRAWNE
int ąę;
int max;
int return;
```
Nie używamy w nazwach zmiennych spacji, myślników(jest odbierany przez kompilator jako odejmowanie), nie zaczynamy od cyfry (w środku i na końcu już mogą być), nie używamy również polskich znaków, ani np. słów kluczowych (takich jak return, auto, max, int - jeśli nam podkresla to znaczy ze cos jest nie tak).
###### Operatory + - * / %
``` cpp =
int l1= 2;
int l2= 5;
cout << l1 + l2 << endl
cout << 1.2 + 3.4 << endl;
cout << l1 - 3 << endl;
// analogicznie mnozenie, dzielenie, reszta z dzielenia
// -1 mod 3 = 2
cout << -1 % 3 << endl;
```
DZIAŁANIA MAJĄ PRIORYTETY: np. mnożenie potem dodawanie
```cpp=
cout << 2 * 3 + 1 << endl;
cout << 1 + 2 * 3 << endl;
```
```cpp =
int l1 = 2;
int l2 = 5;
l1 = l1 + l2;
l1 += l2;
// do tego co mamy po lewej stronie dodajemy to co jest po prawej
// Analogicznie jest zdefiniowane -=, *=, /=
l1++; // l1 += 1; l1 = l1 + 1;
l1--; // l1 -= 1;
// DLATEGO NIE:
l1+2; // nie dziala
// TYLKO
l1 += 2;
```
###### Dzielenie liczb całkowitych vs liczb zmiennoprzecinkowe
```cpp=
int a = 5;
int b = 2;
cout << a/b;
//tutaj wynik byłby 2, bo dzielimy przez siebie dwie liczby całkowite, więc wynik mamy tutaj dzieleni całkowite
```
```cpp=
float a = 5;
float b = 2;
cout << a/b;
//tutaj wynik byłby 2.5, bo dzielimy przez siebie dwie liczby zmiennoprzecinkowe, więc mamy tutaj zwykłe dzielenie
```
```cpp=
int a = 5;
float b = 2;
cout << a/b;
//tutaj wynik byłby 2.5, bo program automatycznie dostosuje się do typu o większym zakresie
```
###### Preinkrementacja i postinkrementacja
``` cpp =
int i1 = 2;
int i2 = 2;
cout << ++i1 << " " << i1 << endl;
cout << i2++ << " " << i2 << endl;
```
###### KOD ASCII:
Jest to system kodowania znaków, działa w ten sposób, że każdemu znakowi przyporządkowana jest liczba od 0-127.
Warto zapamiętać:
65 - 90 (26 wielkich liter)
97 - 122 (26 malych liter)
48 - 57 (10 cyfr)
### Skróty w zapisie stringów
\n - new line - skrót na wstawienie entera
\b - backspace - usuwa znak poprzedząjacy
\t - tab - wstawia przerwę horyzontalną
###### Przykład użycia - wypisywanie tablicy
```cpp=
cout<<"[";
for(int i=0; i<10; i++)
{
cout<<i<<", ";
}
cout<<"\b\b]";
```
### Instrukcje warunkowe
#### Operatory porownania
``` cpp =
<, >, <=, >=, ==, !=
```
// POROWNYWAC MOZEMY TEZ ZNAKI
```cpp =
'a' < 'b' // prawda
'A' < 'a' // prawda bo A jest wczesniej w kodzie ASCII
```
if (warunek) {kod1}
else {kod2}
jeżeli warunek jest prawdziwy to wykona się fragment kod1, a w przeciwnym wypadku kod2
:::warning
0 - false - fałsz
1 - true - prawda
:::
**&&** logiczne "i"
| p | q | p&&q |
| - | - | -----|
| 0 | 0 | 0 |
| 0 | 1 | 0 |
| 1 | 0 | 0 |
| 1 | 1 | 1 |
**||** logiczne "lub"
| p | q | p\|\|q |
| - | - | -----|
| 0 | 0 | 0 |
| 0 | 1 | 1 |
| 1 | 0 | 1 |
| 1 | 1 | 1 |
**!** logiczne "nie"
| p | !p |
| - | - |
| 0 | 1 |
| 1 | 0 |
###### Przykład
```cpp=
int liczba = 5;
if(liczba > 1 && liczba < 6)
{
...
}
if(!(liczba>1 && liczba < 6))
{
}
// TO OZNACZA ZE
if(!(liczba >1) || !(liczba < 6))
// czyli
if(liczba <= 1 || liczba >= 6)
if(!(liczba > 1)) // oznacza liczba <= 1
{
}
if(liczba < 7 || liczba > 10)
```
###### Uwaga! Nawiasy mają znaczenie:
```cpp=
int liczba = 1;
if(liczba > 3)
liczba++;
cout << liczba << endl; // ta linijka wykonuje sie poza if'em
```
### Pętle
```cpp=
for(int i = 0; i < 5; i++)
{
cout << i << " ";
}
cout << endl;
for(int i = 4; i >=0; i--)
{
cout << i << " ";
}
cout << endl;
for(int i = 2; i <= 10; i+=2)
{
cout << i << " ";
}
cout << endl;
//można wykorzystać pętle for rownież w następujący posób (ale nie jest to wskazane, bo do tego służy pętla while)
int i = 0;
for(;i<10;)
{
cout << i << endl;
i++;
}
```
```cpp=
int i = 0;
while(i < 10)
{
if(i == 5)
{
continue;
}
cout << i << " ";
i++;
}
cout << endl;
int i = 0;
while(i < 10)
{
if(i == 5)
{
i++;
continue;
}
cout << i << " ";
i++;
}
cout << endl;
```
```
int i = 0;
while(i > 5)
{
cout << "jestem w while" << endl;
}
do
{
cout << "jestem w do...while" << endl;
}while(i > 5);
```
#### Zakres ważności zycia obiektu i zaslanianie nazw
```cpp=
int x = 1;
if(x == 1)
{
int y = 4;
cout << y << endl;
}
cout << y << endl; // blad, bo zmienna y poza if'em nie istnieje
```
```cpp=
int x = 1;
if(x == 1)
{
int x = 4; // tutaj zmienna x zostaje zasłoniona
cout << x << endl;
}
cout << x << endl;
```
#### Tablice
Zmienna przechowuje jedną wartość, tablice przechowują wiele wartości. Czyli jest to po prostu pojemnik na dane.
W tablicy przechowujemy tylko wartości jednego typu.
Poczatek tablicy to tak naprawdę wskaźnik na pierwszy element tablicy;
Tablice muszą mieć z góry określony rozmiar.
Tablice w C++ numerowane są od 0 do n-1.
Jeśli nie przypiszemy wartości do tablicy, to będzie ona w sobie zawierać śmieci (chyba, że zadeklarujemy ją globalnie tzn. nad funkcją main - wtedy jest wypełniona zerami).
:::warning
Deklarowanie zmiennych globalnie nie jest dobrą praktyką.
:::
```
int tab[5];
```
```
int tab[5] = {1,2,3,4,5};
```
```
int x = 4;
int tab[x];
```
```
tab[ilosc_wierszy][ilosc_kolumn];
tab[3][2] = {{1,1}, {2, 2}, {3, 3}};
tab[][2] = {{1,1}, {2, 2}, {3, 3}};
for(int i = 0; i < 3; i++)
{
for(int j = 0; j < 2; j++)
{
cout << tab[i][j] << " ";
}
cout << endl;
}
```
Przy tworzeniu tablicy dwuwymiarowej możemy pominąć wartość w pierwszym nawiasie kwadratowym, ale nie w drugim!
(Jeśli ktoś jest ciekawy dlaczego, to można wygooglować lub nas dopytać ;)
### Funkcje
:::success
O funkcjach będzie jeszcze wykład. Teraz przekazujemy Wam w skrócie kilka informacji, żebyście lepiej zrozumieli, jak używać funkcji wbudowanych, o których chcemy dziś powiedzieć.
:::
``` cpp =
typ_wartosci_zwracanej nazwa_funkcji(typ argumentu)
{
}
int zwieksz_o_1(int liczba)
{
return liczba + 1;
}
```
```cpp=
int abs(int x)
{
if(x < 0)
{
return -x; // TO RETURN KONCZY DZIALANIE FUNKCI
}
return x;
}
```
```cpp=
void funkcja1()
{
cout << "hello" << endl;
}
void funkcja2()
{
funkcja1();
}
```
Przy takim wywołaniu funkcji ważna jest kolejność definicji funkcji, jeśli umieścimy funkcja2() przed funkcja1(), to wywali nam to błąd.
Widzimy więc, że funkcja moze wywolac inna funkcje, ale nie mozna napisac funkcji w funkcji. Nie tworzymy też funkcji w mainie - jedynie wywolujemy.
```cpp=
void funkcja(int tab[])
{
for(int i = 0; i < 5; i++)
{
tab[i] = 1;
}
}
int main()
{
int tab[5] = {0, 0, 0, 0, 0};
funkcja(tab);
for(int i = 0; i < 5; i++)
{
cout << tab[i] << " ";
}
return 0;
}
```
### Przydatne funkcje wbudowane
- min() - minimum
- max() - maksimum
- abs() - wartość bezwzględna - moduł liczby
- sort() - sortowanie tablicy
- swap() - zamiana wartości dwóch zmiennych
- __gcd() - największy wspólny dzielnik
``` cpp=
bool porownaj(int i, int j)
{
return i > j;
}
int main()
{
int ar[5] = {2,5,1,2,4};
sort(ar, ar + 5, porownaj);
for(int i = 0; i < 5; i++)
{
cout << ar[i] << " ";
}
return 0;
}
-----------------------------------------------
cout << max(1, 2) << endl;
cout << min(1, 2) << endl;
int a[5] = {1, 2, 3, 4, 5};
swap(a[0], a[1]);
for(int i = 0; i < 5; i++)
{
cout << a[i] << " ";
}
cout << endl;
cout << abs(-5) << endl;
cout << __gcd(4, 10) << endl;
```
