PN

// Skrypcik do PN z Kniatem by Marcin Jaskuslki, weryfikacja: Kamil Stróżyk, pan z batem: Danik Martich, śmieszki: Szymon Michalak, Paweł Pytel

// Deklaracja to wtedy gdy deklarujesz xD (Deklarujesz np. istanienie jakiejś struktury, zmiennej) int a;
// Inicjali jest wtedy, gdy nadajesz zmiennej, strukturze jakąś wartość. (np. a = 4; int b = 5; <b ma deklaracje i nicjalizację w jednym>)
// I Z tą wiedzę lecież do pliku "N" u Kniata. Ważne, bo za jak coś zrobicie z tej listy, to Kniat daje laczki od tak.

//Gdy dzielimy liczby zmiennoprzecinkowe, to musimy wyraźnie zaznaczyć, że są takie (np. 2.0/3.0 = 0.6666667 )

// Lab 1 -> wstęp
// Lab 2 -> zmiana na bin, dec + przesunięcia bitowe + konwersja string na int -> generalnie najlepszy wzorzec przesunięć bitowych
// Lab 3 -> stringi + tablice dynamiczne + struktury + tablice funkcji
// Lab 4 -> operacje na plikach + struktury + tablice funkcji
// Lab 5 -> operacje na plikach + tablice dynamiczne + struktury + tablice funkcji + rzutowanie <jeśli ktoś zrobił 7/10 tak dziwnie jak ja> (rzutowanie można raczej olać)
// Lab 6 -> operacje na plikach + tablice dynamiczne + struktury + tablice funkcji + przesunięcia bitowe

// Biblioteki
#include "stdafx.h"
#include "cmath" // biblioteka do wszystkich matematycznych rzeczy
#include <conio.h> // _getch(); -> zatrzymanie na końcu. Raczej nie stosujemy, bo mamy program w pętli z opcją zatrzymania
#include <string.h> // wykorzystywane przy operacjach na stringach



char vchar() // Kniatowska wersja pobrania znaku, dzieki której nie mamy problemu z jakimiś "\n, \0" i kij wie czym jeszcze
{
    char cc;
    while ((cc = getchar()) <= ' ');
    return cc;
};

//* Pomiń. Gdy zobaczysz odpowiednią liczbę gwiazdek wróć
void f(int tab[]) {};
void f(int tab[50]) {};
void f(int* tab) {};

//**
void g(int &x) {};

//***
void f1(int tab[], int & index, int cos) {};
void f2(int tab[], int & index, int cos) {};


//**** --- deklaracja struktury ---
struct pracownik {
    char *imie; // tablica dynamiczna
    char nazwisko[16]; // string
    int placa;
};



int main()
{
    // --- TYPY ZMIENNYCH ---
    unsigned int a;             // -> %u   -> unsigned daje same dodatnie. W sensie z zakresu -0x800000000 do +0x 8000 0000  robi się 0x 1 0000 0000 (czyli wszystko na dodatnie) // specjalnie podniosłem o jeden bit, żeby było widać maski
    char c;                     // -> %c
    char slowo[16];             // -> %s   -> Tablica znaków
    int liczba;                 // -> %d
    double przecinekDuzy;       // -> %lf  -> zmiennoprzecinkowa, o dużym zakresie (zakresu nie musicie pamiętać)
    float przecinekMaly;        // -> %f   -> zmiennporzecinkowa, o mniejszym zakresie
    unsigned long long dluuuga; // -> %llu -> unsigned daje same dodatnie, a long to int, ale większy. Ogólnie w pizdu duzy zakres. Na tym robimy maski
                                // --- MASKA unsigned long long ---
                                dluuuga = 0x8000000000000000; // 8e15; Binarnie to jest 1 i 63 zera (10000...000). Dzięki temu możemy fajnie robić porównanie masek


    // --- ROZNE PRZYDATNE ---
    scanf_s("%s", &slowo, 15);   // gdy pobieramy scanf'em to pamiętaj o podaniu "&", oraz po przecinku indexu ostatniego możliwego elementu w tablicy s
    przecinekMaly = (float)(a);  //Rzutowanie -> zamiana typu zmiennej
    przecinekMaly = 1234.567;
    printf_s("%3.3f", przecinekMaly); // pokaże się 234.56



    // --- OPERACJE NA PLIKACH ---
    FILE *F; // deklaracja zmiennej "F" będącą wskaźnikiem do strumienia
    fopen_s(&F, "plik.txt", "rt"); // otwarcie pliku do ODCZYTU .txt
    fopen_s(&F, "plik.txt", "wt"); // otwarcie pliku do ZAPISU .txt
    fopen_s(&F, "plik.txt", "rb"); // otwarcie pliku do ODCZYTU .bin -> W zasadzie nie wiem czemu przekazujemy binarne, wychodzą hexy itd xD Jak ktoś wie, niech da znać #TajneGowno
    fopen_s(&F, "plik.txt", "wb"); // otwarcie pliku do ZAPISU .bin

    while (feof(F) == false) { // feof(F) -> sprawdza, czy doszliśmy już do końca pliku
        // --- ODCZYT Z PLIKU ---
        fscanf_s(F, "%s", &slowo, 15); // Strumienń, typ zmiennej, zmienna do zapisu, gdy string podajemy jeszcze index ostatniego elementu w tablicy.
                                       // pobranie z pliku (strumienia) pojedynczego ciągu znaków i "przejście do kolejnego".
                                       // zatrzymuje się na spacjach, enterach.
        fscanf_s(F, "%d", &liczba); // Tutaj dla liczby
        c = fgetc(F); // Pobranie pojedynczego znaku. Będzie on w postaci ASCII -> wykorzystaliśmy w Lab 6

        // --- ZAPIS DO PLIKU ---
        fprintf_s(F, "%s", slowo); // Zasada podobna do odczytu i printd_s
        fputc(c, F); // Zapis pojedynczego znaku w postaci ASCII. c jest rzutowane na unsigned char -> wykorzystaliśmy w Lab 6
    }

    fclose(F); // zamknięcie pliku. Zamykamy, gdy na pliku wykonaliśmy wszytskie operacje. Jak nie zamkniesz, to wszystko skopałeś, bo nic się nie odczyta, nie zapisze


    // --- KNIATOWSKIE FUNKCJE WYBORU ---
    char wyb = NULL;
    printf_s("Wybierz jakąś tam opcję poprzez znak \n A - coś \n B - coś innego \n C - coś innego, niż inne");
    wyb = vchar(); // Kniatowska wersja pobrania znaku, dzieki której nie mamy problemu z jakimiś "\n, \0" i kij wie czym jeszcze. Generalnie przydatne

    switch (wyb & 0x5F) { // na "wyb" nakładmay maskę 0x5f, co w zasadzie znaczy 101 1111 i dzięki temu czy podamy małą, czy duż literę to dostaniemy dużą
        case 'A': printf_s("Coś wykonuję \n"); break;
        case 'B': printf_s("Coś innego wykonuję \n"); break;
        case 'C': printf_s("Coś innego, niż inne wykonuję \n"); break;
        default: printf_s("Nie ma takiego znaku \n"); break;
    }


    // --- TABLICE DYNAMICZNE ---
    //-- Jednowymiarowa --
    int n;
    int *Tab;
    scanf_s("%d", &n);
    Tab = new int[n]; // Przyznanie miejsca w pamięci

    //-- Dwuwymiarowa --
    int k, w; // kolumna, wiersz
    scanf_s("%d", &k);
    int** Tab1 = new int *[k]; // tutaj tworzę k kolumn
    for (int i = 0; i < w; i++) Tab1[i] = new int[w]; // tutaj dla każdj kolumny tworzę komórki w dół

    // --- PRZEKAZYWANIE TABLIC do funkcji ---
    int tab[50];
    f(tab); // *Up: -> przekazanie do funkcji. Wyżej, jak może wyglądać funkcja


    // --- PRZEKAZYWANIE ZMIENNEJ REFERENCYJNEJ --- -> czyli nie tworzymy kopi zmiennej, tylko przekazujemy ją jako ją (wskaźnik do niej) i działamy na niej
    int x = 4;
    g(x); // **Up:


    // --- TABLICA FUNKCJI ---
    int index = 0;
    int cos = 123;
    void(*fun[])(int *, int &, int) = { f1,f2 }; //***Up: void - zwracany typ; (int *, int &, int) -> typu argumentów
    fun[0](tab, index, cos);


    // --- STRUKTURY ---
    // ****UP: -> definicja
    pracownik michalak;
    michalak.imie = new char[16]; // zmienna dynamiczna
    michalak.imie = "Szymon";
    scanf("%s", &michalak.nazwisko, 16); // pobranie ze strumienia
    michalak.placa = 3; // 3 złote <3 (idealnie na pączka, na Półwiejskiej xD)


    // --- OPERACJE NA STRINGACH ---
    char c = '6';
    int w = c - '0'; // Dzięki temu odejmiemy od ASCII 54 - 48 = 6. I własnie w = 6

    if (!strcmp("ola", "jola")) {}; // strcmp(); porównuje dwa ciągi znaków. Gdy będą takie same dostaniemy odp.: 0. Dlatego użyłem negacji w if'ie

    //-- gdzie korzystaliśmy z strcpy_s --
    pracownik ziomeczek;
    char bufor[32];

    printf_s("Nowy pracownik, Imię: ");
    scanf_s("%s", &bufor, 31); // Pamietaj o 3 argumencie!!!
    ziomeczek.imie = new char[strlen(bufor) + 1]; // deklaracja dynamiczna, bo imię tablicą dynamiczną
    strcpy_s(ziomeczek.imie, strlen(bufor) + 1, bufor); // dokad, jakie dlugie, skad

    // -- Zmiana stringa na liczbę --
    char string[16];
    int i = 0;
    int number = 0;
    while (string[i] != 0) {
        number = number * 10 + string[i] - '0';
        i++;
    }

    // -- Robienie z stringa liczbę, ale binarną!!! --
    while (string[i] != 0) {
        number = number * 2 + string[i] - '0';
        i++;
    }

    // --- OPERACJE BITOWE ---
    int a = 23; // 10111 <binarnie>
    a >>= 2;    // 101          // inaczek a = a >> 2;
    a <<= 3;    // 101000
    a &= 8;     // 8 -> 1000; czyli wynik tego to 1000
    a |= 3;     // 3 -> 11;   czyli wynik tego to 1000 | 11 => 1011
    a = ~a;     // negacja, czyli wyjdzie 0100
    a ^= 8;     // XOR, czyli 0100 ^ 1000 => 1100

    //-- szukanie najstarszego bitu --
    unsigned long long liczba;
    printf_s("Podaj liczbe: ");
    scanf_s("%llu", &liczba);

    unsigned long long maska = 0x8000000000000000;
    int indexL = 63;
    while ((liczba & maska) == 0) { // sprawdzenie czy znaleźliśmy jedynkę, czy ciągle zera i musimy zmniejszyć maskę
        maska >>= 1; // przesunięcie o jeden bit w prawo, co powoduje <symulacja> => 10000, 1000, 100, 10, 1
        indexL--; // zmienijszenie pozycji najstarszego bitu
    }
    printf_s("Najstarszy bit: %d (liczac od 0) \n", indexL);


    return 0;
}