4 CPA 2 Advanced flow control and data aggregates

modyfikatory zmiennych:
long - dłuższe 64 (long long)
short - krótsze 16
unisgnet - bez znaku

typ double różni się dokładnością. float32 = finite precision czyli 8 znaczących
double64=ma 16 znaczących (zdublowane ;-)

jeśli dodamy bardzo dużą liczbę do bardzo małej to dostaniemy zaokrągloną dużą = anomalia

typ bool  (true/false)



PĘTLE 
While(1)    ->zapetlone

int counter=5;
while(counter--)    -> az osiagnie zero

do
{
} while(warunek)   -> wykonuje a potem sprawdza;


pętla FOR:

for(initialization; checking; modifying)
for(i = 0;               i < 100;          i++)

for( ; ; )   -> zapętlone


break wychodzi z pętli
Continue wraca na początek pętli i wykonuje od początku


Logika: ( działa na poziomie true false)

&& - i      (dwa true dają true) koniunkcja
||    - lub, alternatywa
!    - negacja logiczna (zamienia true na false)

                równoznaczne
Variable > 0             !(Variable <= 0)

Variable != 0            !(Variable == 0)

Prawo morgana:
!(p && q) ==  !p  ||  !q
!  (p || q)   ==  !p && !q

Operator zmiennej boolowskiej   BOOL

co ważne jeśli porównany dwie liczby to jeśli będą różne od 0 to przy koniunkcji wynik 1 (true)
2&&3  true      0==0 da true

Operatory Bitowe:

& (ampersand) bitwise conjunction (koniunkcja)   i
| (bar) bitwise disjunction  (alternatywa)               lub
~ (tilde) bitwise negation(negacja)                        not
^ (caret) bitwise exclusive or             xor (alternatywa wykluczająca) 0 1 1 0  (daje 1 dla różnych)

Bitowe operują tylko na int, long i short. Nie mogą na Float.W przeciwieństwie do  Logiczny nie pracują na poziomie liczb ale na poziomie pojedynczych bitów.

skróty:
x=x&y  ->  x&=y

Przesuwanie bitów   >>liczba bitów do przesunięcia

<< mnoży razy 2
>> dzieli przez 2


SWITCH:

switch(i) {
case 1: KOD; break;
case 2: KOD; break;
case 3: KOD; break;
case 4: KOD;break
default: KOD;               -dla opcji innych niż 1-4
}

Tablice:
int nazwa[5];    ewentualnie={1,2,3,4}   ewentualnie int nazwa[]={dowolna ilosc};
  matematyczny vektor - kolekcja elementów scalarów, jęśli przypiszesz więcej błąd.

do pierwszego:
nazwa[0]=111;  (0 to indeks)

sumuje kolejne elementy:
for(int i = 0; i < 5; i++)
    sum += numbers[i]; 

mogą być:
float nazwa[5];
char nazwa[5];
bool nazwa[100];

Przykłady tworzenia i inicjalizacji oraz działania range for (nie działa na wskaznikach)

#include<iostream>

using namespace std;

int lenght=5;

int tabst[]{1,2,3,4,5};                //inicjalizowanie statycznej tablicy wartosciami
int *array = new int[lenght]();     //inicjalizowanie dynamicznej tablicy zerami c++98
int* tabwsk = new int [3]{1,2,3};   //inicjalizowanie dynamicznej tablicy wartosciami c++11

char *zdaniewsk = "programowanie";  //inicjalizowanie Literałem w stylu C (tablica zakonczone \n)
char zdanie [ ] = "programowanie";  //inicjalizowanie tablicy Literałem w stylu C (zakonczone \n)


int* tab1[3];               // statyczna tablica 3 wskaźników
int* tab2 = new int [3];    // "dynamiczna tablica" 3 int-ów

int** tab3 = new int* [3];  // "dynamiczna tablica" 3 wskaźników


int main ()
{

for (auto aa : zdanie)         //Range For tylko dla niewskaznikow, wskazniki nie maja metody begin
cout<<aa<<endl;

return 0;
}


Tablicatablic:

int nazwa[8][8];  ={{1,2,3,4,5,6,7,8},{1,2,3,4,5,6,7,8},...

String:

string nazwa="pizza";
string nazwa[100];


Struktury

struct STUDENT {
    string  name;
    float   time;
    int     recent_chapter;
};

i tworzymy:
STUDENT nazwa;     operator dostępu to   . 
np
nazwa.time=1.5;

teraz możemy wrzucić struktury do tablicy a raczej stworzyc tablice struktur;

STUDENT nazwa[100];

teraz dostęp do time ze struktury pod indexem 1

nazwa[1].time=1.5
nazwa[1].name="Bond;
nazwa[1].recent_chapter=4;

rozmiar struktury:
sizeof(struct nazwa);

Struktura może być w innej strukturze:

struct STUDENT {
    string  name;
    float time;
    int   recent_chapter;
    struct DATE last_visit;
} HarryPotter;

można od razu przy tworzeniu podać wartości

struct STUDENT nazwa={"BBond" , 3.2 , 5 }; a jeśli struct w strukturze to {"Bon" , 2, {212,4,5}};



Zad1
What is the output of the following snippet?

    double big = 1e15;
    double small = 1e-15;
 
    std::cout << std::fixed << big + small;
 


wynik bedzie: 100000000000000,0000   bo ma dokladnosc 15 znakow a wazniejsze powyzej przecinka



Zad2:
#include <iostream>
    using namespace std;
    int main() {
            for(int a = -10.0; a < 100.0; a = -a * 2)
                cout << a<<endl;

            return 0;
    }


Pętla wykona się 5 razy, wydrukuje -10,20,-40,80,-160
-160 jest mniejsze od 100 więc też wykona 5 obie (zmyłka z minusami )



Zad3:
#include <iostream>
    using namespace std;
    int main() {
            int a = 2;
            switch(a << a) {
            case 8 : a++;
            case 4 : a++;
            case 2 : break;
            case 1 : a--;
            }
            cout << a;
            return 0;
    }

Wynik 4, bo a w switch wychodzi 8 (2 i przesuniecie bitowe o 2 daje 8)
i uruchamia case 8 ale nie ma break więc zrobi też case 4.



Zad4:
#include <iostream>
    using namespace std;
    int main() {
            bool t[5];
            for(int i = 0; i < 5; i++)
                t[4 - i] = !(i % 2);
            cout << t[0] && t[2];
            return 0;
    }


Wynik 1  , bo reszta z dzielenia przez 2 jest zawsze 1 albo 0, tutaj zamieniana na odwrotną za pomoca !
wynik to 1 && 1  czyli  1