{"id":19811637,"url":"https://github.com/majkeloess/po1","last_synced_at":"2026-06-14T10:33:31.482Z","repository":{"id":244093887,"uuid":"814120338","full_name":"majkeloess/PO1","owner":"majkeloess","description":"Laboratoria z przedmiotu Programowanie Obiektowe 1","archived":false,"fork":false,"pushed_at":"2024-06-12T16:47:54.000Z","size":98,"stargazers_count":0,"open_issues_count":0,"forks_count":0,"subscribers_count":1,"default_branch":"main","last_synced_at":"2025-02-28T18:47:40.072Z","etag":null,"topics":["cpp","object-oriented-programming","oop","oop-in-cpp","oop-principles"],"latest_commit_sha":null,"homepage":"","language":"C++","has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":null,"status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/majkeloess.png","metadata":{"files":{"readme":"README.md","changelog":null,"contributing":null,"funding":null,"license":null,"code_of_conduct":null,"threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":null,"support":null,"governance":null,"roadmap":null,"authors":null,"dei":null,"publiccode":null,"codemeta":null}},"created_at":"2024-06-12T11:32:12.000Z","updated_at":"2024-06-12T16:47:57.000Z","dependencies_parsed_at":"2024-06-12T22:50:18.043Z","dependency_job_id":null,"html_url":"https://github.com/majkeloess/PO1","commit_stats":null,"previous_names":["majkeloess/po1"],"tags_count":0,"template":false,"template_full_name":null,"purl":"pkg:github/majkeloess/PO1","repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/majkeloess%2FPO1","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/majkeloess%2FPO1/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/majkeloess%2FPO1/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/majkeloess%2FPO1/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/majkeloess","download_url":"https://codeload.github.com/majkeloess/PO1/tar.gz/refs/heads/main","sbom_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/majkeloess%2FPO1/sbom","scorecard":null,"host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":286080680,"owners_count":34318523,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2026-05-26T15:22:16.424Z","status":"online","status_checked_at":"2026-06-14T02:00:07.365Z","response_time":62,"last_error":null,"robots_txt_status":"success","robots_txt_updated_at":"2025-07-24T06:49:26.215Z","robots_txt_url":"https://github.com/robots.txt","online":true,"can_crawl_api":true,"host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":["cpp","object-oriented-programming","oop","oop-in-cpp","oop-principles"],"created_at":"2024-11-12T09:27:13.617Z","updated_at":"2026-06-14T10:33:31.467Z","avatar_url":"https://github.com/majkeloess.png","language":"C++","funding_links":[],"categories":[],"sub_categories":[],"readme":"# Laboratoria z przedmiotu Programowanie Obiektowe 1\n\nRozwiązania laboratoriów z Programowania Obiektowego w języku C++. Poniżej załączone są treści, które są odpowiednio `Main.cpp` dla każdego z laboratoriów. \nMaina nie wolno było edytować trzeba było dopisać odpowiednie pliki `.h` i `.cpp` oraz odpowiadające im klasy oraz funkcje.\n\nW trakcie semestru przećwiczono:\n\n1. Przeładowania operatorów\n2. Dziedziczenie (zwykłe, wirtualne, wielokrotne)\n3. Funkcje wirtualne (polimorfizm, klasy abstrakcyjne)\n4. STL\n5. Wyrażenia Lambda\n6. Szablony\n7. Kontenery (std::vector, std:: array, iteratory)\n8. Wyjątki \n\nFoldery z odpowiadających im laboratoriów zawierają moje rozwiązania. Czasem brakowało czasu więc do wszystkich laboratoriów nie ma dokumentacji. \n\n## LAB01\n\n```cpp\n\n//Zaimplementuj klasę wektora Iwektor3D liczb typu int o rozmiarze 3, które wewnętrznie przechowywane są w postaci alokowanej dynamicznie tablicy (a nie std::vectora !) uwzględniając: konstruktory (w tym kopiujący), destruktor oraz następujące przeładowane operatory: operator przypisania, operatory + i - (dodawanie i odejmowanie wektorów), operator mnożenia przez liczbę całkowitą (powinien umożliwiać mnożenie z obu stron), operator mnożenia wektora przez wektor (iloczyn skalarny), operator [] (powinien umożliwiać zarówno pobieranie jak i ustawienie składowej wektora), jednoargumentowy operator - (zamiana na wektor przeciwny),\u003c\u003c wstawianie wektora do strumienia wyjściowego.\n//\n//Następnie zainicjuj dwa wektory:\n//v1=(2,2,2) i v2=(1,1,1)\n//i wypisz na standardowe wyjście wynik następujących operacji (w tej kolejności !):\n\nint main()\n{\n\n  Vector v1 = {2, 2, 2};\n  Vector v2 = {1, 1, 1};\n\n  std::cout \u003c\u003c v1 + v2 \u003c\u003c std::endl;\n  std::cout \u003c\u003c v1 - v2 \u003c\u003c std::endl;\n  std::cout \u003c\u003c v1 * 2 \u003c\u003c std::endl;\n  std::cout \u003c\u003c 2 * v1 \u003c\u003c std::endl;\n  std::cout \u003c\u003c v1 * v2 \u003c\u003c std::endl;\n  std::cout \u003c\u003c (v1[0] == ((v2[0]) = (2 * v2[0]))) \u003c\u003c std::endl;\n  std::cout \u003c\u003c (v1[0] != ((v2[0]) = (2 * v2[0]))) \u003c\u003c std::endl;\n  std::cout \u003c\u003c -v2 \u003c\u003c std::endl;\n\n  return 0;\n}\n```\n\n## LAB02\n\n```cpp\n// Prosze dopisac kod, dodac nowe pliki, tak aby program wykonywal się,\n// a wynik jego dzialania byl taki sam jak podany na końcu tego pliku.\n//\n//Szczegóły:\n//W tym zadaniu zaprogramujemy operatory indeksowania [] działające na indeksach całkowitych i typu string.\n//Zaprogramuj klasę do operowania na histogramach. Histogram będzie zbiorem obiektów klasy Series mających nazwę\n//i zawierających dynamicznie alokowaną tablicę wartości double.\n//Do pustego histogramu hist dodajemy serię metodą hist.add_series(\"nazwa\"). Z kolei do serii w histogramie\n//dodajemy wiersz metodą hist[\"nazwa\"].apppend(3.1415). Wreszcie, wartość konkretnego wiersza możemy zmodyfikować np.\n//wywołaniem hist[\"nazwa\"][3]=2.71 i pobrać np. wywołaniem double x=hist[\"nazwa\"][3]. Ponadto dla obiektów Series\n//zaimplementuj operator += umożliwiający dodawanie do siebie zawartości obiektów Series w zaktesie elementów ograniczonym\n//mniejszą z nich, tzn. min(hist[\"seria1\"].size(),hist[\"seria2\"].size()).\n//Próby sięgania poza zakres Serii lub wierszy powinny się kończyć wyrzuceniem odpowiednich wyjątków. W oparciu o\n//pliki nagłówkowe Histogram.h i Series.h zaprogramuj odpowiednie klasy i wykonaj ciąg poniższych operacji tak by uzyskać podany niżej wynik.\n\n//Program (tylko kod źródłowy plus ewentualny skrypt kompilujący) należy umieścić w folderze i spakować przy pomocy zip lub tar.gz.\n//Pamiętaj o dokumentacji.\n//Powodzenia!\n\n#include \"Histogram.h\"\n\nint main(int argc, const char * argv[]) {\n    // insert code here...\n//    std::cout\u003c\u003c\"Test\"\u003c\u003cstd::endl;\n    Histogram h1=Histogram();\n    h1.add_series(\"liczby dodatnie\");\n    h1[\"liczby dodatnie\"].append(10.5);\n    h1[\"liczby dodatnie\"].append(11.5);\n    h1[\"liczby dodatnie\"].append(12.5);\n    std::cout\u003c\u003c\"Seria dodatnia\"\u003c\u003cstd::endl;\n    std::cout\u003c\u003ch1[\"liczby dodatnie\"]\u003c\u003cstd::endl;\n\n    h1.add_series(\"liczby ujemne\");\n    h1[\"liczby ujemne\"].append(-10.5);\n    h1[\"liczby ujemne\"].append(-11.5);\n    h1[\"liczby ujemne\"].append(-12.5);\n    std::cout\u003c\u003c\"Seria ujemna\"\u003c\u003cstd::endl;\n    std::cout\u003c\u003ch1[\"liczby ujemne\"]\u003c\u003cstd::endl;\n    std::cout\u003c\u003c\"Ustawiam pierwszy element ujemnych na -10.5\"\u003c\u003cstd::endl;\n    h1[\"liczby ujemne\"][1]=-10.5;\n\n\n    std::cout\u003c\u003c\"Seria dodatnia\"\u003c\u003cstd::endl;\n    std::cout\u003c\u003ch1[\"liczby dodatnie\"]\u003c\u003cstd::endl;\n    std::cout\u003c\u003c\"Seria ujemna\"\u003c\u003cstd::endl;\n    std::cout\u003c\u003ch1[\"liczby ujemne\"]\u003c\u003cstd::endl;\n    std::cout\u003c\u003c\"Nagłówki serii:\"\u003c\u003cstd::endl;\n    for(auto x: h1.get_series_names())\n        std::cout\u003c\u003cx\u003c\u003cstd::endl;\n    std::cout\u003c\u003c\"Dodaję serię ujemną do dodatniej\"\u003c\u003cstd::endl;\n    h1[\"liczby dodatnie\"]+=h1[\"liczby ujemne\"];\n    std::cout\u003c\u003ch1[\"liczby dodatnie\"]\u003c\u003cstd::endl;\n    std::cout\u003c\u003c\"Dodaję serię dodatnią do ujemnej\"\u003c\u003cstd::endl;\n    h1[\"liczby ujemne\"]+=h1[\"liczby dodatnie\"];\n    std::cout\u003c\u003ch1[\"liczby ujemne\"]\u003c\u003cstd::endl;\n    return 0;\n}\n/* ---Program powinie\n Konstruktor klasy Histogram\n Kopiujący operator przypisania klasy Series\n Destruktor klasy Series\n Seria dodatnia\n [10.5,11.5,12.5]\n Kopiujący operator przypisania klasy Series\n Kopiujący operator przypisania klasy Series\n Destruktor klasy Series\n Destruktor klasy Series\n Seria ujemna\n [-10.5,-11.5,-12.5]\n Ustawiam pierwszy element ujemnych na -10.5\n Seria dodatnia\n [10.5,11.5,12.5]\n Seria ujemna\n [-10.5,-10.5,-12.5]\n Nagłówki serii:\n liczby dodatnie\n liczby ujemne\n Dodaję serię ujemną do dodatniej\n [0,1,0]\n Dodaję serię dodatnią do ujemnej\n [-10.5,-9.5,-12.5]\n Destruktor klasy Histogram\n Destruktor klasy Series\n Destruktor klasy Series\n */\n```\n\n## LAB03\n\n```cpp\n//Prosze dopisac kod, w razie potrzeby dodac nowe pliki, tak aby program wykonywal się,\n// a wynik jego dzialania byl taki sam jak podany na końcu tego pliku. Proszę nie modyfikować pliku main.cpp !\n//\n//Rozwijamy kod napisany na ostatnich zajęciach.\n//\n//Szczegóły:\n//1. Uzupełnij klasę Series o konstruktor przenoszący i przypisanie przenoszące (oba w wersji głośnej).\n//2. Operator \u003c\u003c klasy Series przepisz tak by wypisywał: \"nazwa serii: [wartości w wierszach].\"\n//3. Klasę Histogram uzupełnij o operator()(string name,unsigned row) umożliwiający dostęp (odczyt i zapis) do dowolnego wiersza w dowolnej Serii (tradycyjnie sięganie poza zakres ma się kończyć wyjątkiem).\n//4. Klasę Series uzupełnij o metodę vector\u003cdouble\u003e get_series_view(function\u003cbool(double)\u003e) przyjmującą jako parametr predykat (czyli obiekt klasy function\u003cbool(double)\u003e) i zwracającą vector elementów, dla których predykat jest prawdziwy. Działanie przetestuj na dwóch warunkach:\n//    - elementy serii \u003e10\n//    - elementy serii \u003e10 i \u003c20.\n\n#include \u003ciostream\u003e\n#include \"Histogram.h\"\n#include \"predicates.h\"\n\nint main(int argc, const char * argv[]) {\n\n    Series s1=Series(\"Test\",2);\n    s1[0]=1.2;\n    s1[1]=1.3;\n    std::cout\u003c\u003cs1\u003c\u003c\"\\n\";\n    Series s2=std::move(s1);\n    std::cout\u003c\u003cs2\u003c\u003c\"\\n\";\n    Series s3;\n    s3=std::move(s2);\n    s3.append(12);\n    s3.append(13);\n    s3.append(22);\n    std::cout\u003c\u003cs3\u003c\u003c\"\\n\";\n    std::cout\u003c\u003c\"------------------\\n\";\n\n    Histogram h1=Histogram();\n    h1.add_series(\"liczby dodatnie\");\n    h1[\"liczby dodatnie\"].append(1.5);\n    h1[\"liczby dodatnie\"].append(11.5);\n    h1[\"liczby dodatnie\"].append(12.5);\n    std::cout\u003c\u003ch1[\"liczby dodatnie\"]\u003c\u003c\"\\n\";\n    h1(\"liczby dodatnie\",2)=22.5;\n    std::cout\u003c\u003ch1[\"liczby dodatnie\"]\u003c\u003c\"\\n\";\n    h1[\"liczby dodatnie\"].append(22.5);\n    h1[\"liczby dodatnie\"].append(32.5);\n    h1[\"liczby dodatnie\"].append(17.5);\n    std::cout\u003c\u003ch1(\"liczby dodatnie\",4)\u003c\u003c\"\\n\";\n\n    std::cout\u003c\u003c\"-------------------\\n\";\n    std::vector\u003cdouble\u003e gt10=h1[\"liczby dodatnie\"].get_series_view(value_gt_10);\n    std::vector\u003cdouble\u003e btwn10and20=h1[\"liczby dodatnie\"].get_series_view(value_between_10_and_20);\n    std::cout\u003c\u003c\"\u003e10\\n\";\n    for(auto x: gt10)\n        std::cout\u003c\u003cx\u003c\u003c\"\\n\";\n    std::cout\u003c\u003c\"\u003e10 \u003c20\\n\";\n    for(auto x: btwn10and20)\n        std::cout\u003c\u003cx\u003c\u003c\"\\n\";\n    return 0;\n}\n\n//Test: [1.2,1.3]\n//Konstruktor przenoszący klasy Series\n//Test: [1.2,1.3]\n//Przenoszący operator przypisania klasy Series\n//Test: [1.2,1.3,12,13,22]\n//------------------\n//Konstruktor klasy Histogram\n//Przenoszący operator przypisania klasy Series\n//Destruktor klasy Series\n//liczby dodatnie: [1.5,11.5,12.5]\n//liczby dodatnie: [1.5,11.5,22.5]\n//32.5\n//-------------------\n//\u003e10\n//11.5\n//22.5\n//22.5\n//32.5\n//17.5\n//\u003e10 \u003c20\n//11.5\n//17.5\n//Destruktor klasy Histogram\n//Destruktor klasy Series\n//Destruktor klasy Series\n//Destruktor klasy Series\n//Destruktor klasy Series\n//Program ended with exit code: 0\n\n```\n\n## LAB04\n\n```cpp\n// Prosze dopisac kod, dodac nowe pliki, tak aby program wykonywal się,\n// a wynik jego dzialania byl taki sam jak podany na końcu tego pliku.\n//\n//Szczegóły:\n//Na podstawie outputu programu umieszczonego na dole pliku:\n//1. Zidentyfikuj potrzebne klasy i ich hierarchię dziedziczenia (w tym klasy abstrakcyjne o ile\n// takowe występują).\n//2. W maksymalnym stopniu stosuj hermetyzację oraz zasadę \"Do not repeat yourself\", czyli dziedzicz i stosuj polimorfizm.\n//Wskazówka: do obliczania pola trójkąta użyj wzoru x*(x-a)*(x-b)*(x-c), gdzie a, b, c to boki a x to obwód\n// trójkąta\n\n//Program (tylko kod źródłowy plus ewentualny skrypt kompilujący) należy\n//umieścić w folderze i spakować przy pomocy zip lub tar.gz.\n//Pamiętaj o dokumentacji.\n//Powodzenia!\n#include \u003ciostream\u003e\n\n#include \"Prostokat.h\"\n#include \"Kwadrat.h\"\n#include \"Kolo.h\"\n#include \"Trojkat.h\"\n\nint main() {\n    Prostokat p= Prostokat(1,2);\n    Kwadrat kw=Kwadrat(3);\n    Trojkat t=Trojkat(3,4,5);\n    Kolo ko=Kolo(2);\n\n\n    std::cout\u003c\u003cp\u003c\u003cstd::endl;\n    std::cout\u003c\u003ckw\u003c\u003cstd::endl;\n    std::cout\u003c\u003ct\u003c\u003cstd::endl;\n    std::cout\u003c\u003cko\u003c\u003cstd::endl;\n}\n\n//Prostokąt o bokach a=1.000000, b=2.000000, Pole: 2.000000, Obwód: 6.000000\n//Kwadrat o boku a=3.000000, Pole: 9.000000, Obwód: 12.000000\n//Trójkąt o bokach a=3.000000, b=4.000000,c =5.000000, Pole: 6.000000, Obwód: 12.000000\n//Koło o promieniu 2.000000, Pole: 12.566371, Obwód: 12.566371\n```\n\n## LAB05\n\n```cpp\n//Proszę nie modyfikować pliku main. Jeśli nazwy Państwa klas są inne to proszę użyć słowa kluczowego typedef by uzgodnić nazwy.\n//\n//Zaprogramowane wcześniej klasy reprezentujące n-wymiarowe wektory i macierze uzupełnij o metody/operatory umożliwiające\n//wykonanie poniższych operacji. Na podstawie klasy n-wymiarowego wektora stwórz klasę 3-wymiarowego wektora wzbogaconą o operator\n//obliczania iloczynu wektorowego, oznaczonego poniżej symbolem ^.\n//Poprawna implementacja powinna prowadzić do outputu takiego jak ten zamieszczony poniżej.\n\n#include \u003ciostream\u003e\n#include \"Vector.h\"\n#include \"Matrix.h\"\n#include \"Vector3d.h\"\n\nint main() {\n\n    Matrix a1 {{1.,2.,3.},{2.,3.,4.},{4.,0.,6.}};\n    std::cout\u003c\u003c\"a1:\\n\"\u003c\u003ca1\u003c\u003cstd::endl;\n    Matrix a2 {{1.,1.,1.},{1.,0.,1.},{1.,1.,1.}};\n    std::cout\u003c\u003c\"a2:\\n\"\u003c\u003ca2\u003c\u003cstd::endl;\n\n    std::cout\u003c\u003c\"a1+a2:\\n\"\u003c\u003ca1+a2\u003c\u003cstd::endl;\n    std::cout\u003c\u003c\"a1*a2:\\n\"\u003c\u003ca1*a2\u003c\u003cstd::endl;\n\n    std::cout\u003c\u003c\"Ślad: \"\u003c\u003c(a1*a2).trace()\u003c\u003cstd::endl;\n    std::cout\u003c\u003c\"Ślad: \"\u003c\u003c(a2*a1).trace()\u003c\u003cstd::endl;\n    a2[1][1]=1;\n    std::cout\u003c\u003c\"a2:\\n\"\u003c\u003ca2\u003c\u003cstd::endl;\n\n    Vector v0 {1,2,3,4,5,5,6,6,7,8,8};\n    std::cout\u003c\u003c\"v0: \"\u003c\u003cv0\u003c\u003cstd::endl;\n    Vector v1 {1.,2.,3.};\n    std::cout\u003c\u003c\"v1: \"\u003c\u003cv1\u003c\u003cstd::endl;\n    //std::cout\u003c\u003c\"a2*v1: \"\u003c\u003ca2*v1\u003c\u003cstd::endl;\n    Vector v2 {1.,2.,0.};\n\n    Vector3d d1 {1.,2.,3.};\n    Vector3d d2 {1.,2.,0.};\n    std::cout\u003c\u003c\"(d1xd2): \"\u003c\u003c(d1^d2)\u003c\u003cstd::endl;\n    std::cout\u003c\u003c\"(d1xd2)*d1: \"\u003c\u003c(d1^d2)*d1\u003c\u003cstd::endl;\n    std::cout\u003c\u003c\"(d1xd2)*d2: \"\u003c\u003c(d1^d2)*d2\u003c\u003cstd::endl;\n    return 0;\n}\n\n//a1:\n//[[1,2,3],\n//[2,3,4],\n//[4,0,6]]\n//a2:\n//[[1,1,1],\n//[1,0,1],\n//[1,1,1]]\n//a1+a2:\n//[[2,3,4],\n//[3,3,5],\n//[5,1,7]]\n//a1*a2:\n//[[9,6,9],\n//[11,8,11],\n//[13,12,13]]\n//Ślad: 30\n//Ślad: 30\n//a2:\n\n//[[1,1,1],\n//[1,1,1],\n//[1,1,1]]\n//v1: [1,2,3]\n\n//v0: [1,2,3,4,5,5,6,6,7,8,8]\n\n//a2*v1: [6,6,6]\n//(d1xd2): [-6,3,0]\n//(d1xd2)*d1: 0\n//(d1xd2)*d2: 0\n\n\n```\n\n## LAB06\n\n```cpp\n/* Celem zadania jest odnalezienie hierarchi klas.\n   To znaczy nalezy znalezc \"czesc wspolna\" pewnych obiektow, ktore wystepuja w temacie.\n   W szczegolnosci w rozwiazaniu moga wystapic tylko dwie implementacje funkcji eval.\n\n   UWAGA: Prosze zwrocic uwage na argumentowosc operacji logicznych.\n   UWAGA: Prosze pamietac ze zachowanie polimorficzne wystepuje tylko z \u0026 lub *\n\n */\n\n#include \u003ciostream\u003e\n#include \"Logical.h\"\n\nvoid p2(const TwoArg\u0026 op) {\n  std::cout \u003c\u003c \"p2  \" \u003c\u003c  op.result(true, false) \u003c\u003c std::endl;\n}\n\nint main() {\n  std::cout \u003c\u003c \"OR   \" \u003c\u003c  Logical::eval( OR(), false, false ) \u003c\u003c std::endl;\n  std::cout \u003c\u003c \"OR   \" \u003c\u003c  Logical::eval( OR(), false, true ) \u003c\u003c std::endl;\n  std::cout \u003c\u003c \"AND  \" \u003c\u003c  Logical::eval( AND(), false, false ) \u003c\u003c std::endl;\n  std::cout \u003c\u003c \"XOR  \" \u003c\u003c  Logical::eval( XOR(), true, true ) \u003c\u003c std::endl;\n  std::cout \u003c\u003c \"NOT  \" \u003c\u003c  Logical::eval( NOT(), false) \u003c\u003c std::endl;\n  std::cout \u003c\u003c \"AND  \" \u003c\u003c  Logical::eval( AND(), false, Logical::eval(NOT(), false) ) \u003c\u003c std::endl;\n  std::cout \u003c\u003c \"AND  \" \u003c\u003c  Logical::eval( AND(), Logical::eval(OR(), true, false ), true ) \u003c\u003c std::endl;\n\n  p2( OR() );\n  p2( AND() );\n  p2(XOR());\n}\n/* wynik\nOR   0\nOR   1\nAND  0\nXOR  0\nNOT  1\nAND  0\nAND  1\np2  1\np2  0\np2  1\n */\n```\n\n## LAB07\n\n```cpp\n/* Celem zadania jest odnalezienie hierarchi klas i wykorzystanie odpowiedniego sposobu rzutowania\n * dla klas polimorficznych.\n * Należy wykonać tylko dwa rzutowania.\n */\n#include \u003ciostream\u003e\n#include \"Widgets.h\"\n#include \u003cvector\u003e\nint main() {\n\n    std::vector\u003cWidget*\u003e widgets;\n    widgets.push_back(new Button());\n    widgets.push_back(new EditBox());\n    widgets.push_back(new RadioButton());\n    widgets.push_back(new MaskedEditBox());\n    for (auto x: widgets)\n        std::cout\u003c\u003cx-\u003ewidgetDescription()\u003c\u003cstd::endl;\n\n    (new WidgetPainter())-\u003epaintWidgets(widgets);\n\n    for (auto x: widgets)\n         std::cout\u003c\u003cx-\u003ewidgetDescription()\u003c\u003cstd::endl;\n     return 0;\n}\n//Wynik:\n//gray button\n//gray editbox\n//gray radiobutton\n//gray maskededitbox\n\n//blue button\n//red editbox\n//blue radiobutton\n//red maskededitbox\n\n\n```\n\n## LAB08\n\n```cpp\n/* W zadaniu nalezy poprawnie odwzorowac zaleznosci dziedziczenia wielokrotnego między klasami.\n\n   UWAGA: Klasa bazowa NIE dostarcza wspólnego interfejsu.\n   UWAGA: Przemyśleć implementację operatora \u003c\u003c.\n */\n#include \u003ciostream\u003e\n#include \"Mebel.h\"\n#include \"Sofa.h\"\n#include \"Lozko.h\"\n#include \"Kanapa.h\"\n\n\n\nint main() {\n  {\n    Mebel m(100, 120, 150);\n    std::cout \u003c\u003c \"jakis mebel \" \u003c\u003c m  \u003c\u003c std::endl;\n  }\n\n  {\n    Sofa* s = new Sofa(90, 100, 200, 180);\n    Mebel *x  = s;\n    std::cout \u003c\u003c \"jakas sofa \"  \u003c\u003c *x \u003c\u003c std::endl;\n    delete x;\n  }\n\n  {\n    Lozko* l = new Lozko(90, 100, 200, 190);\n    const Mebel* x  = l;\n    std::cout \u003c\u003c \"king bed \"  \u003c\u003c *x \u003c\u003c std::endl;\n    delete x;\n  }\n\n  { // wykorzystanie własności wielokrotnego dziedziczenia\n    Kanapa* k = new Kanapa( 80, 90, 220, 195, 200);\n    Sofa* s = k;\n    Lozko* l = k;\n//    l = 0;\n\n    std::cout \u003c\u003c \"kanapa z ikei \" \u003c\u003c *s \u003c\u003c std::endl;\n    delete s;\n  }\n\n}\n/* wynik\njakis mebel Mebel: sz:100 wys:120 dl:150\n~Mebel\njakas sofa Sofa: Mebel: sz:90 wys:100 dl:200  siedzisko: 180\n~Sofa\n~Mebel\nking bed Lozko: Mebel: sz:90 wys:100 dl:200  sz.spania: 190\n~Lozko\n~Mebel\nkanapa z ikei jako Mebel: sz:80 wys:90 dl:220\n jako Sofa: Mebel: sz:80 wys:90 dl:220  siedzisko: 195\n jako Lozko: Mebel: sz:80 wys:90 dl:220  sz.spania: 200\n~Kanapa\n~Lozko\n~Sofa\n~Mebel\n\n */\n\n```\n\n## LAB10\n\n```cpp\n//Zaimplementuj algorytm sortowania szybkiego z procedurami partycjonującymi Lomuto i Hoare. Odpowiednie pseudokody\n//znajdziesz na slajdach 21, 22 i 43 załączonego wykładu profesora Gawrońskiego.\n//Obie wersje procedur partycjonujacych, jak również wykorzystywana przez nie procedura SWAP powinny być zaimplemenowane\n//przy pomocy wyrażeń lambda.\n//Ponadto powinny jednocześnie obsługiwać tablice int[] i double[]. Sama procedura QuickSort nie musi być wyrażeniem lambda.\n\n//UWAGI:\n//1. Może być potrzebne skorzystanie z RTTI.\n//2. Do skompilowania fragmetów kodu wykorzystujących słowo kluczowe auto potrzebne jest C++ 20.\n\n//Wynik działania podano poniżej\n\nint main() {\n\n    int tab1[]={8,7,5,3,2,6,1,4,9};\n    int tab2[9];\n    std::copy(\u0026tab1[0],\u0026tab1[0]+9,\u0026tab2[0]);\n    double tab3[]={2.3,1.4,6.5,0.3,1.1};\n    double tab4[5];\n    std::copy(\u0026tab3[0],\u0026tab3[0]+5,\u0026tab4[0]);\n\n    std::cout\u003c\u003c\"QuickSort tablicy int z partycjonowaniem Lomuto:\\n\";\n    std::cout\u003c\u003c\"Przed: \";printArray(tab1,9);std::cout\u003c\u003cstd::endl;\n    QuickSort(tab1,0,8,lomutoPartition);\n    std::cout\u003c\u003c\"Po: \";printArray(tab1,9);std::cout\u003c\u003cstd::endl;\n    std::cout\u003c\u003c\"QuickSort tablicy int z partycjonowaniem Hoare:\\n\";\n    std::cout\u003c\u003c\"Przed: \";printArray(tab2,9);std::cout\u003c\u003cstd::endl;\n    QuickSort(tab2,0,8,hoarePartition);\n    std::cout\u003c\u003c\"Po: \";printArray(tab2,9);std::cout\u003c\u003cstd::endl;\n\n    std::cout\u003c\u003c\"QuickSort tablicy double z partycjonowaniem Lomuto:\\n\";\n    std::cout\u003c\u003c\"Przed: \";printArray(tab3,5);std::cout\u003c\u003cstd::endl;\n    QuickSort(tab3,0,4,lomutoPartition);\n    std::cout\u003c\u003c\"Po: \";printArray(tab3,5);std::cout\u003c\u003cstd::endl;\n    std::cout\u003c\u003c\"QuickSort tablicy double z partycjonowaniem Hoare:\\n\";\n    std::cout\u003c\u003c\"Przed: \";printArray(tab4,5);std::cout\u003c\u003cstd::endl;\n    QuickSort(tab4,0,4,hoarePartition);\n    std::cout\u003c\u003c\"Po: \";printArray(tab4,5);std::cout\u003c\u003cstd::endl;\n\n    return 0;\n}\n\n```\n\n## LAB11\n\n```cpp\n//Stwórz szablon funkcji mnożącej asynchronicznie (z użyciem std::async()) dwie macierze kwadratowe dowolnych rozmiarów.\n//Macierze te są reprezentowane przez wektory wektorów.\n//Każdy element macierzy wynikowej jest obliczany w oddzielnym wątku, którego zhaszowany identyfikator jest wypisywany na ekran,\n// tak jak to pokazano na wydruku poniżej.\n//\n//Wskazówka:\n//Do zhaszowania identyfikatora wątku użyj poniższych instrukcji:\n//std::hash\u003cstd::thread::id\u003e hasher;\n//long id =hasher(std::this_thread::get_id());\n\n#include \"MatMulAsync.h\"\n#include \u003ccomplex\u003e\nusing std::complex;\nusing namespace std::complex_literals;\nint main() {\n    // Przykładowe macierze\n    std::vector\u003cstd::vector\u003cint\u003e\u003e matrix1 = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};\n    std::vector\u003cstd::vector\u003cint\u003e\u003e matrix2 = {{9, 8, 7}, {6, 5, 4}, {3, 2, 1}};\n\n    // Mnożenie macierzy\n    std::vector\u003cstd::vector\u003cint\u003e\u003e result_int = multiplyMatrices(matrix1, matrix2);\n    // Wyświetlanie wyniku\n    std::cout \u003c\u003c \"Wynik mnożenia macierzy:\" \u003c\u003c std::endl;\n    displayMatrix(result_int);\n\n    std::vector\u003cstd::vector\u003cdouble\u003e\u003e matrix3 = {{1., 0., 0.}, {0., 1., 0.}, {0., 0., 1.}};\n    std::vector\u003cstd::vector\u003cdouble\u003e\u003e matrix4 = {{9.1, 8.1, 7.1}, {6.1, 5.1, 4.1}, {3.1, 2.1, 1.1}};\n\n    // Mnożenie macierzy\n    std::vector\u003cstd::vector\u003cdouble\u003e\u003e result_double = multiplyMatrices(matrix3, matrix4);\n    // Wyświetlanie wyniku\n    std::cout \u003c\u003c \"Wynik mnożenia macierzy:\" \u003c\u003c std::endl;\n    displayMatrix(result_double);\n\n    std::vector\u003cstd::vector\u003ccomplex\u003cdouble\u003e\u003e\u003e matrix5 = {{0., -1i}, {1i, 0.}};\n    std::vector\u003cstd::vector\u003ccomplex\u003cdouble\u003e\u003e\u003e matrix6 = {{0., -1i}, {1i, 0.}};;\n\n    // Mnożenie macierzy\n    std::vector\u003cstd::vector\u003ccomplex\u003cdouble\u003e\u003e\u003e result_complex = multiplyMatrices(matrix5, matrix6);\n    // Wyświetlanie wyniku\n    std::cout \u003c\u003c \"Wynik mnożenia macierzy:\" \u003c\u003c std::endl;\n    displayMatrix(result_complex);\n\n    return 0;\n}\n\n//Wątek -1643678212384661549 oblicza element (0,0)\n//Wątek 1362080638672535051 oblicza element (2,1)\n//Wątek 3734504096879222707 oblicza element (0,2)\n//Wątek 7192468387369268874 oblicza element (2,2)\n//Wątek 4615549267549480836 oblicza element (0,1)\n//Wątek -5993321486016935974 oblicza element (1,1)\n//Wątek 34040437824474923 oblicza element (2,0)\n//Wątek 2612129187665001469 oblicza element (1,0)\n//Wątek -866191707566161087 oblicza element (1,2)\n//Wynik mnożenia macierzy:\n//30 24 18\n//84 69 54\n//138 114 90\n//Wątek -1643678212384661549 oblicza element (0,0)\n//Wątek 4615549267549480836 oblicza element (0,1)\n//Wątek 3734504096879222707 oblicza element (0,2)\n//Wątek -1643678212384661549 oblicza element (1,0)\n//Wątek 2612129187665001469 oblicza element (1,1)\n//Wątek 4615549267549480836 oblicza element (1,2)\n//Wątek 3734504096879222707 oblicza element (2,0)\n//Wątek -1643678212384661549 oblicza element (2,1)\n//Wątek -5993321486016935974 oblicza element (2,2)\n//Wynik mnożenia macierzy:\n//9.1 8.1 7.1\n//6.1 5.1 4.1\n//3.1 2.1 1.1\n//Wątek -1643678212384661549 oblicza element (0,0)\n//Wątek 3734504096879222707 oblicza element (0,1)\n//Wątek -1643678212384661549 oblicza element (1,0)\n//Wątek 4615549267549480836 oblicza element (1,1)\n//Wynik mnożenia macierzy:\n//(1,0) (0,0)\n//(0,0) (1,0)\n\n\n```\n\n## LAB13\n\n```cpp\n//Z użyciem klas Book, BookManager oraz odpowiednich kontenerów zaprogramuj system do zarządzania\n// kolekcją książek.\n//W operacjach na kontenerach nie wolno wykorzystywać \"ifów\". Stosujemy wyłącznie iteratory i\n// algorytmy STL.\n#include \"BookManager.h\"\n\nint main() {\n    BookManager manager;\n    manager.addBook(\"1984\", \"George Orwell\", 1949, 19.84);\n    manager.addBook(\"Brave New World\", \"Aldous Huxley\", 1932, 15.99);\n    manager.addBook(\"Fahrenheit 451\", \"Ray Bradbury\", 1953, 18.99);\n\n    std::cout \u003c\u003c \"All books:\" \u003c\u003c std::endl;\n    manager.displayAllBooks();\n\n    std::cout \u003c\u003c \"\\nSorted by title:\" \u003c\u003c std::endl;\n    manager.sortBooksByTitle();\n    manager.displayAllBooks();\n\n    std::cout \u003c\u003c \"\\nFinding book by title '1984':\" \u003c\u003c std::endl;\n    auto book = manager.findBookByTitle(\"1984\");\n    if (book) displayBook(*book);\n\n    std::cout \u003c\u003c \"\\nRemoving book '1984' and displaying all books:\" \u003c\u003c std::endl;\n    manager.removeBook(\"1984\");\n    manager.displayAllBooks();\n\n    return 0;\n}\n\n//All books:\n//Title: 1984, Author: George Orwell, Year: 1949, Price: 19.84\n//Title: Brave New World, Author: Aldous Huxley, Year: 1932, Price: 15.99\n//Title: Fahrenheit 451, Author: Ray Bradbury, Year: 1953, Price: 18.99\n//\n//Sorted by title:\n//Title: 1984, Author: George Orwell, Year: 1949, Price: 19.84\n//Title: Brave New World, Author: Aldous Huxley, Year: 1932, Price: 15.99\n//Title: Fahrenheit 451, Author: Ray Bradbury, Year: 1953, Price: 18.99\n//\n//Finding book by title '1984':\n//Title: 1984, Author: George Orwell, Year: 1949, Price: 19.84\n//\n//Removing book '1984' and displaying all books:\n//Title: Brave New World, Author: Aldous Huxley, Year: 1932, Price: 15.99\n//Title: Fahrenheit 451, Author: Ray Bradbury, Year: 1953, Price: 18.99\n\n```\n\n## LAB14\n\n```cpp\n//Jest to nasz ostatni program na ocenę, zatem wykorzystamy cały poznany arsenał umiejętności, w tym stosowanie:\n//-dziedziczenia,\n//-polimorfizmu,\n//-szablonów metod i ich specjalizacji,\n//-kontenerów, iteratorów i algorytmów STL (nie używamy standardowych instrukcji sterujących).\n//\n//Co należy zrobić ?\n//Zaimplementuj klasy GroceryItem, ElectronicsItem, ClothingItem właściwie identyfikując relacje między nimi.\n//Zaimplementuj klasę ShoppingBasket będącą modelem koszyka na zakupy. Jego motoda addItem powinna być szablonowa z odpowiednimi\n//specjalizacjami.\n//Z użyciem wyżej wymienionych klas zaimplementuj poniższe operacje.\n\n#include \u003ciostream\u003e\n#include \"Item.h\"\n#include \"ShoppingBasket.h\"\n#include \"ClothingItem.h\"\n\nint main() {\n    ShoppingBasket basket;\n\n    //  Dodawanie różnych produktów z użyciem metody szablonowej\n    basket.addItem(GroceryItem(\"Jabłko\", 0.99));\n    basket.addItem(GroceryItem(\"Banan\", 0.59));\n    basket.addItem(ElectronicsItem(\"Smartfon\", 699.99, 24));  // 24 miesiące gwarancji\n    basket.addItem(ClothingItem(\"T-Shirt\", 19.99, \"L\"));\n\n    std::cout \u003c\u003c \"Produkty w koszyku:\" \u003c\u003c std::endl;\n    basket.displayItems();\n\n    std::cout \u003c\u003c \"Cena całkowita: zł \" \u003c\u003c basket.getTotalPrice() \u003c\u003c std::endl;\n\n    std::cout \u003c\u003c \"\\nProdukty posortowane po nazwie:\" \u003c\u003c std::endl;\n    basket.sortByName();\n    basket.displayItems();\n\n    std::cout \u003c\u003c \"\\nProdukty posortowane po cenie:\" \u003c\u003c std::endl;\n    basket.sortByPrice();\n    basket.displayItems();\n\n    return 0;\n}\n\n//Produkty w koszyku:\n//Produkt spożywczy: Jabłko, Cena: zł 0.99\n//Produkt spożywczy: Banan, Cena: zł 0.59\n//Produkt elektroniczny: Smartfon, Cena: zł 699.99, Gwarancja: 24 miesiące\n//Odzież: T-Shirt, Cena: zł 19.99, Rozmiar: L\n//Cena całkowita: zł 721.56\n//\n//Produkty posortowane po nazwie:\n//Produkt spożywczy: Banan, Cena: zł 0.59\n//Produkt spożywczy: Jabłko, Cena: zł 0.99\n//Produkt elektroniczny: Smartfon, Cena: zł 699.99, Gwarancja: 24 miesiące\n//Odzież: T-Shirt, Cena: zł 19.99, Rozmiar: L\n//\n//Produkty posortowane po cenie:\n//Produkt spożywczy: Banan, Cena: zł 0.59\n//Produkt spożywczy: Jabłko, Cena: zł 0.99\n//Odzież: T-Shirt, Cena: zł 19.99, Rozmiar: L\n//Produkt elektroniczny: Smartfon, Cena: zł 699.99, Gwarancja: 24 miesiące\n\n```\n","project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fmajkeloess%2Fpo1","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Fmajkeloess%2Fpo1","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fmajkeloess%2Fpo1/lists"}