Spis Treści





----- materiały egzamin cpa - c++ institute -----

CPA Podsumowanie plik doc 

10 CPA 8 Operators and enumerated types








----- C++ -----

2 Podstawy

24 High Performance book

 Auto

Move Semantics


                                                               *************************************

Auto

const reference vs mutable

Return type

Syntactic variants (a, b, and c correspond to the same result):

Value

auto val() const                // a) auto, deduced type

auto val() const -> int         // b) auto, trailing type

int val() const                 // c) explicit type

Const reference

auto& cref() const              // a) auto, deduced type

auto cref() const -> const int& // b) auto, trailing type

const int& cref() const         // c) explicit type

Mutable reference

auto& mref()                    // a) auto, deduced type

auto mref() -> int&             // b) auto, trailing type

int& mref()                     // c) explicit type


decltype(auto) - nie musimy decydowa czy dac auto  czy auto& - sam rozpozna

auto val_wrapper() { return val(); }   // Returns int

auto mref_wrapper() { return mref(); } // Also returns int

decltype(auto) val_wrapper() { return val(); }   // Returns int

decltype(auto) mref_wrapper() { return mref(); } // Returns int&


I recommend using const auto for fundamental types (int, float, and so on) and small non-fundamental types like std::pair and std::complex. For bigger types that are potentially expensive to copy, use const auto&. 

auto& and auto should only be used when you require the behavior of a mutable reference or an explicit copy; 



Move Semantics

konstruktory:

03 class Clazz {
04 public:
05 Clazz() noexcept;                                             // Konstruktor domyślny.
06 Clazz(const Clazz& other);                             // Konstruktor kopiujący.
07 Clazz(Clazz&& other) noexcept;                    // Konstruktor przenoszący.
08 Clazz& operator=(const Clazz& other);          // Kopiujący operator przypisania.
09 Clazz& operator=(Clazz&& other) noexcept; // Przenoszący operator przypisania.
10 virtual ~Clazz() noexcept;                                // Destruktor.

&& rvalue - it is just an object that is not tied to a named variable

• It's coming straight out of a function

• We make a variable an rvalue by using std::move()


str 33

...


23 CMake, CONAN, remote

 CMake


CMakeLists.txt  podstawowy

cmake_minimum_required(VERSION 3.0)

set(CMAKE_BUILD_TYPE Debug)


project(zad3)

add_executable(
   zad3 
   zad3.c
)


zad3 - nazwa pliku uruchamialnego
zad3.c - plik z programem
dodaj kolejne plik *.c    i   *.h


ale może być tak, że mamy w głównym katalogu CMake, który dodaje podkatalogi.

tylko w podkatalogach sa pliki cpp i hpp oraz osobne CMake


wtedy główny CMakeLists.txt dodaje tylko katalogi

cmake_minimum_required (VERSION 3.8)

project ("CMakeProject22")

# Include sub-projects.
add_subdirectory ("CMakeProject22")
a w folderze CMakeProject22, poza plikami CMakeProject22.cpp i h mamy CMakeList.txt
o zawartosci

cmake_minimum_required (VERSION 3.8)

# Add source to this project's executable.
add_executable (CMakeProject22 "CMakeProject22.cpp" "CMakeProject22.h")

CMake ZDALNE na Visual Studio do Linuxa na VMvare
- stworz nowy projekt CMake
  standardowo stworzy konfiguracje x64-Debug, daj Manage Configuration (rozwin x64-Debug)
- wybierz  Linux-GCC-Debug  dla linuxa - powstanie plik CMakeSettings.json  (Mingw64-Debug lub Release  konfiguracje(dla windows)

-po dodaniu konfiguracji zmien generator CMake z ninja na Unix Makefile (json CMAKe settings under advance settings)
- dodaj znalna maszyne Tool->Options->Cross Platform
-skopiuje pliki na twoja virtualna maszyne


To speed up compilation time we can define parallel compilation flag -j or –jobs followed by an integer that represent number of recipes to execute at once in Cmake Settings view under Build command arguments
Troubleshooting:
• Is good practice to Deleting CMake Cache and run fresh Cache generation, when we do some changes to CMakeLists.txt files or CMakeSettings.json.
• Do not copy Cmake configuration in Visual Studio. Visual Studio do not copy environments variables better option is to copy by hand or create and modify new configuration.
• If CMake can’t find C/C++ compilator make sure that you have added directory that was mentioned in MSYS2 installation chapter.
Notes:
• Most of the option of building our application on remote machine are defined in CMakeSettings.json like output build and installation folder on remote machine excluded files from copy, etc.
• Currently only console application is supported to show an output of the application open a Linux Console. (Debug→Linux Console).
• In case of problem whit IntelliSense for Linux specific headers you can update remote headers by going to Tool→Options→Croos Platform→Connection Manager→Remote Headers IntelliSense Manager (Visual Studio should automatically update headers files)

na VMware linux w katalogu .vs/NazwaProjektu/numer/
stworzy 
OUT - gdzie w /build/Linux-GCC-Debug/CMakeNazwaProj  tworzy PLIK WYNIKOWY 
(Clean Build czyści go!!!) (delete cache czyści cały out (usuwa katalog Linux-GCC-Debug  )
SRC - kopia plików źródłowych na których Linux uruchamia budowanie 
w folderze projektu pliki CPP i H te same co w projekcie VS


to co tworzy generate cache (w out/build/Linux-GCC-Debug/) to robocze pliki CMake uzywane do zbudowania pliku wynikowego
więcej

*********************************************************************************


RECZNE uruchomienie CMake w stworzonych katalogach na VMware OUT i SRC

Jeśli mamy w OUT stworzony przez VS  cache (w build stworzony jest Linux-GCC-Debug i zawiera plik:
                   CMakeCache.txt
                   i folder:
                   CMakeFiles


                   
to z folderu out/build/Linux-GCC-Debug dajemy komende
cmake .

Jesli brak CMakeCache.txt i CMakeFiles, to musimy cmake pokazac gdzie znajduje sie CMakeList.txt projektu
ten jest w SRC, więc z katalogu out/build/Linux-GCC-Debug/   (zeby tu stworzyl pliki MAKE)     dajemy komende:
cmake ../../../src/

da wynik (pokaze kompilator)

-- The C compiler identification is GNU 9.3.0
-- The CXX compiler identification is GNU 9.3.0
-- Check for working C compiler: /usr/bin/cc
-- Check for working C compiler: /usr/bin/cc -- works
-- Detecting C compiler ABI info
-- Detecting C compiler ABI info - done
-- Detecting C compile features
-- Detecting C compile features - done
-- Check for working CXX compiler: /usr/bin/c++
-- Check for working CXX compiler: /usr/bin/c++ -- works
-- Detecting CXX compiler ABI info
-- Detecting CXX compiler ABI info - done
-- Detecting CXX compile features
-- Detecting CXX compile features - done
-- Configuring done
-- Generating done
-- Build files have been written to: /home/marcin/.vs/CMakeProject23/83a0f6bd-aa75-488e-8070-ca4c3923cd43/out/build/Linux-GCC-Debug

CXX znaczy C++

teraz żeby zbudować ręcznie plik wynikowy dajemy
cmake --build .               (uruchomi MAKE)

mamy stworzony plik wykonywalny w out/build/Linux-GCC-Debug/CMakeProject2




CMAKE Library:
jeśli dodamy pliki z funkcjami ktore inkludujemy, np Hello

to żeby potrafił to zbudować trzeba albo dodać Hello.cpp w lokalnym CMLists.txt

cmake_minimum_required (VERSION 3.8)

# Add source to this project's executable.
add_executable (CMakeProject2 "CMakeProject2.cpp" "CMakeProject2.h" "Hello.cpp")
jeśli nie dodasz:
błąd:
CMakeProject2/CMakeProject2.cpp:11: undefined reference to `Hello()'

ale można dodać to jako nową bibliotekę:



i wtedy przejdzie linkowanie 
(po cmake ../../../src/ nie bedzie błędu undefined reference to `Hello()'
ale przy próbie cmake --build . 
pokaze ze linkuje dodana  bibliotekę, ale dalej nie może sie do niej odnieść


trzeba pokazac w CMakeLists do czego podlaczyc dodana bibliotekę poleceniem (tam gdzie jest add_executable)

targer_link_libraries(nazwa_executables PRIVATE  dodana_biblioteka)

PRIVATE to link interface mode - tutaj mode = private
polecenie dodajemy w CMakeLists.txt tam gdzie jest okreslone executable
(w naszym przypadku nie w głównym gdzie dodajemy tylko subdirectories ale w kat. Projektu)



polecenie 
add_library moze określać rownież jakiego typu jest biblioteka, standardowo jest statyczna (STATIC)
ale mozna dac SHARED



i wtedy gdy uruchomimy plik wynikowy przez LDD

ldd prints the shared libraries required by each program or shared library specified on the command line.

to widać bibliotekę hello



trzeci typ to MODULE (cmake zwróci z nim jednak błąd)

można zmienić domyślny tryb budowania bibliotek
cmake -D BUILD_SHARED_LIBS=TRUE .
teraz domyslnie shared



Podkatalogi
Jesli biblioteki w osobnym folderze i uruchamialne(main) też  w osobnym to wazne by w głównym CMakeLists.txt tam gdzie są tylko dodane subdirectory, by biblioteki były dodane wczesniej przed hello-exe (nazwa executable)



i wtedy CMakeList z SRC wygląda tak




a CMakeLists z uruchamialnej czesci projektu tak





CMakeLists z SRC ma dodaną linię
target_include_directories(say-hello PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/src")

jak to działa....
target_link_libraries (z executable, trzeci z powyższych) linkuje say-hello do projektu(executable)

dodanie do biblioteki say-hello "target_include_directories" w SRC z podaną flagą PUBLIC i scieżką
sprawi, że projekt dodając tą bibliotekę odziedziczy rowniez informacje o katalogu SRC

i wtedy gdy w naszym pliku CPP chcemy includować tą bibliotekę nie musimy dawać "" z pełną scieżką
#include "../src/say-hello/Hello.h"

tylko <> ze scieżką względną
#include <say-hello/Hello.h>




target_compile_definitions  
tworzenie predefiniowanych zmiennych w plikach CMakeLists

jesli dodamy w naszym pliku CMake linie



to możemy się w kodzie posługiwać stworzoną predefiniowaną zmienna kompilatora tu równa 4




jeśli jest PRIVATE wtedy mozemy dodać tylko do Hello (jako ze ten CMake dotyczy tych bibliotek)
ale nie mozemy użyć tej zmiennej np w main.
jeśli jest INTERFACE to możemy w main ALE nie możemy w Hello.




SCRIPTING

dwie podstawowe komendy to minimalne wymagania wersji CMake i project (name)




wszytsko w nawiasach jest stringiem, odzielone spacjami, nie kropkami


jak chcesz wyświetlic wiadomosc podczas uruchomienia CMake

message(STATUS "tresc wiadomosci")

co ważne, tresc musi być w  " "



jak chcesz stworzyć zmienna w CMake
set(NAZWA "Wartosc zmiennej")

jak chcesz wykorzystać zmienna umieśc w ${ }



podanie jako zmiennej PROJECT_NAME
wyswietli wartosc z project, tutaj  "MyProject"

podanie jako zmiennej PROJECT_VERSION
wyswietlo wartosc z project, tutaj    1.1.2


Control Flow   and   Auto-dereferencing

if("TRUE")   - string traktuje jako spełniony warunek, 

mozna uzyc elseif ( )  koniecznie z argumentem

jeśli używamy zmiennej, podajemy ja jako argument do if



albo podajemy ją w "${ }"





mozna zanegować zmienna poprzez NOT




można porównać dwa stringi STREQUAL





można stosować logikę  i porównywać z liczbami, STREQUAL porównuje stringi, EQUAL liczby



można rownież uzywac  while, tu przyklad z wyrazeniem matematycznym




mozna rowniez foreach
tutaj  item - stworzona zmienna ktorej mozemy uzyc
IN   - szukaj w
ITEMS foo  bar  baz  quz      - stworz liste w tymi elementami
czyli przeiteruje nam te elementy




dla foreach mozna zastosowac rowniez   RANGE



jesli RANGE  0 99   to w zakresie
jesli RANGE  0 99 5  to w zakresie co 5



2c od poczatku





.
Youtube:
https://www.youtube.com/watch?v=rKBdoMzY3cA&list=PLK6MXr8gasrGmIiSuVQXpfFuE1uPT615s&index=9


22 Rozne QUEUE,std::bind,msgs, protobuf

Kontenery (vector, queue, list, map )
calbacki w c++ (std::bind expressions)
MSGS i testowanie
Google protobuf
C++17 If statement with initializer


                                                                                                                                              Kontenery 

                                                                                        Container adaptors(different interface: fifo, stack-LIFO,priority_queue )
std::queue If you need fast insertion and deletion at both its beginning and its end - FIFO data structure

Sequence containers (can be accessed sequentially)
std::vector dynamic array -If you need random access to elements
std::deque   double-ended queue
std::list doubly-linked list, when there are frequent insertions and deletions from the middle of the sequence  

Associative containers(can be quickly searched)
std::map  collection of key-value pairs, sorted by keys, keys are unique


Dodawanie elementów:

VECTOR:
można dodawać na początek i na konieć vektora (co go poszerza i zmienia iteratory)

mojv.push_back(10);      lub push_front


ale moża zastosować insert lub emplace , w miejsce iteratora wstawi wartość, ale nie zastąpi tylko przesunie resztę, jeśli it był początkiem, to wstawi na początek a dotychczasowy pierwszy będzie drugi (jeden i drugi)

mojv.insert(it,10);
mojv.emplace(it,10);

jeśli vektor był pusty nie zadziała, jeśli był stworzony tylko jako
vector<int> mojv ;

to musimy albo resize (i wypełni zerami lub przypadkowymi wartosciami

mojv.resize(10);              tym można też zmniejszyć

albo

myvec.assign(10,0);       (rozmiar, czym ma wypełnić ) też może zmniejszyć

CO WAŻNE OPERACJE MOGĄ UNIEWAŻNIĆ ITERATORY
vector<int>::iterator it;
it=mojv.begin();

JEŚLI DO ITERATORA DODAMY WARTOŚĆ WIĘKSZA NIŻ ROZMIAR ITERATORA I SPROBUJEMY ZAPISAC *(it)  TO NADPISZEMY PAMIĘĆ

DLATEGO LEPIEJ UZYWAĆ DOSTĘPU PRZEZ  AT

mojvector.at(liczba);

clear- czysci cały vector
erase(it) - czysci miejsce i zwraca iterator do nastepnego po nim

LISTA
Tworzenie
list<typ>  nazwa;

niemożliwy dostęp przez  []

iterator trzeba iterować, żeby dostać się do kolejnych elementów.

te same metody co Vektor

QUEUE
Element access:
front                   access the first element
back                   access the last element

Modifiers
push                   inserts element at the end
emplace(C++11)constructs element in-place at the end
pop                     removes the first element


Czym się różnią push i Emplace ?
Emplace takes the arguments necessary to construct an object in place, whereas push takes (a reference to) an object.
push                   copies objects into the queue.
emplace      construct them inside of the queue.


MAP inaczej słownik

zbiór par, klucz wartość, wstawianie wolne ale szybkie szukanie (drzewo się samo balansuje)
tylko 1 klucz na mapę i musi być porównywalny, dane jak w vektorze
złożoność obliczeniowa szukania lepsza niżliniowa (log N)

Tworzenie

map<typklucza,typdanych> nazwa={{1,"slowo"} , {2,"slowo2"},...

trzecim elementem w < > jest komparator do porównywania większe mniejsze, można go zmienić jak potrzeba, ale jak inny do nie pasuje do innych map bez takiego.






calbacki w c++
https://stackoverflow.com/questions/2298242/callback-functions-in-c
https://en.cppreference.com/w/cpp/utility/functional/placeholders



std::bind expressions

jeśli obiekt wewnętrzny ma wywołać metodę obiektu zewnętrznego to można by mu przekazać w konstruktorze wskaźnik na właściciela. Jesli jednak nie chceż używać zwykłych wskaźników, a zastosowanie smartpointera w takiej sytuacji jest kłopotliwe to można zostosować std:bind.

obiekt zewnętrzny tworzy typ calbacka oparty o std:function
using procCallback_t = std::function<void(ConnectionStateTp)>;

gdzie ConnectionStateTp  to typ argumentu funkcji

w obiekcie zewnętrznym tworzymy metodę "handleProcedures" wywoływaną calbackiem

void FRUConfServer::handleProcedures(ConnectionStateTp connectionState)
  {
    switch (connectionState)
    {
      case ConnectionStateTp::Connected:
        break;
      case ConnectionStateTp::Disconnected:
      case ConnectionStateTp::Error:
        removeConnection();
        break;
    }
  }


teraz do obiektu wewnetrznego przekazujemy namiary na powyzsza metode calbacka

m_connection->start(m_facade, std::bind(&FRUConfServer::handleProcedures, this, std::placeholders::_1));


tylko jeden placeholder bo tylko jeden argument w calbacku
std::placeholders::_1

a teraz jak wygląda implementacja metody start obiektu wewnetrznego (ta która przyjmuje std::binda)

void FRUConfServerConnection::start(const facade_t::IMessagingFacade::Ptr& facade, procCallback_t procedureCallback)
{
  ....tresc metody
  m_callback = procedureCallback;
}


i teraz mamy sposób jak wywołać z wewnętrznego obiektu metodę (calback) obiektu zewnętrznego

poniewaz był tylko jeden placeholder, mamy jeden argument (handleProcedures ma 1 arg)
wiec wywołanie to:
m_callback(ConnectionStateTp::Disconnected);

przykład w kodzie:

obiekt zewnetrzny:
/repo/eblzmrc/encl_ss/source/oamAdapterBl/FRUConfigurationServerSwU/src/FRUConfServer.cpp

obiekt wewnetrzny:
/repo/eblzmrc/encl_ss/source/oamAdapterBl/FRUConfigurationServerSwU/src/FRUConfServerConnection.cpp

Przykład Arka2 (2 placeholdery i jeden dodatkowy posrednik)
wew: /repo/eblzmrc/encl_ss/source/powerControlBl/dataChangeServerSwU/src/DataChangeServerConnection.cpp
posredni: /repo/eblzmrc/encl_ss/source/powerControlBl/dataChangeServerSwU/src/DataChangeServer.cpp
zew(z calbackiem):/repo/eblzmrc/encl_ss/source/powerControlBl/dataChangeServerSwU/src/DataChangeController.cpp



MSGS i testowanie
msgs link

przykład asynchronicznej komunikacji client i server łączą się z nameserwerem, nie ma procesu subskrypcji, klient wysyła do servere ind (tak zwane reverseind)
klient: /repo/eblzmrc/encl_ss/source/powerControlBl/FRUConfigurationClientSwU/src/FRUConfClient.cpp
server: /repo/eblzmrc/encl_ss/source/oamAdapterBl/FRUConfigurationServerSwU/src/FRUConfServer.cpp
serverCon: /repo/eblzmrc/encl_ss/source/oamAdapterBl/FRUConfigurationServerSwU/src/FRUConfServerConnection.cpp

server startowany w oamAdapterMAin.cpp
FRUServer->publish();

klient w AplicationPC
m_FRUClient_sp->connect();

klient ma metodę sendProductData która wysyła msg do servera.

Testowanie:
ponieważ kożystamy z MSGS i mamy nameserwer który łączy klienta i servera trzeba testować w specyficzny sposób:
jeden z testów klienta: /repo/eblzmrc/encl_ss/source/powerControlBl/FRUConfigurationClientSwU/test/src/FRUConfClientTest.cpp
TEST_F(FRUConfClientTest, sendIndication)
{
  triggerConnection();
  sut->sendProductData(ind);
  PROS__RECEIVE_MESSAGE(procedureTestFixture, SendProdDatRInd_t, procedureCall, indSent);
  EXPECT_THAT(true, isIndEqual(ind, indSent));
}


makro PROS__RECEIVE_MESSAGE symuluje msgs, tutaj oczekuje wiadomosci typu SendProdDatRInd_t  pod zmienna indSent1

ponieważ typ nie ma operatora == zastosowano matchery (patrz tresc testu)

możemy porównać to co wysyłaliśmy, z tym co "otrzymał" msgs zas pomoca EXPECT_THAT

w Przypadku testu servera : /repo/eblzmrc/encl_ss/source/oamAdapterBl/FRUConfigurationServerSwU/test/src/FRUConfServerTest.cpp
nic nie wysyłamy, wiec nie mozemy zastosować makra  PROS__RECEIVE_MESSAGE.
w Unacknowledge stosujemy zamiast tego makra:
uint32_t procedureRef = procedureTestFixture->newProcedureRef();

i wysyłka:
SendProdDatRInd_t indSent1;
  indSent1.set_productiondate(100);
  procedureTestFixture->dispatch(procedureRef, std::move(indSent1));

porównanie:
EXPECT_THAT(true, isIndEqual(ind, indSent1));
...

Testy dla synchronicznej komunikacji, patrz:
/repo/eblzmrc/encl_ss/source/oamAdapterBl/SSMConfigurationServerSwU/test/src/SSMConfServerTest.cpp
/repo/eblzmrc/encl_ss/source/powerControlBl/SSMConfigurationClientSwU/test/src/SSMConfClientTest.cpp

W tym przypadku server subskrybuje klienta (ktory otrzymuje cfm) i server rozsyła wiadomosci do zabsubskrybowanych.


Testy - symulacja onError i on Destroy
TEST_F(FRUConfServer, receivedOnError)
{
  triggerConnection();
  mockFacade->triggerError(cons_t::ConnectionError::REMOTE_TERMINATED);
  EXPECT_THAT(ConnectionState::Disconnected , sut->getConnectionState());
}


TEST_F(FRUConfServer, receivedOnDestroyed)
{
  triggerConnection();
  mockFacade->triggerDestroy();
  EXPECT_THAT(ConnectionState::Disconnected , sut->getConnectionState());
}


Tworzenie wiadomości i ustawianie jej pól:

auto rIndProcedure = pros_t::client::createUnacknowledgedRequest<PcChangeDataRInd_t>(m_facade->getProcedureManager(),
                                                                                         "DataChangeRInd");
    rbs::catiw1::ssm::dataChangeIf::PcChangeDataRInd rInd{};
    rInd.mutable_productdata()->set_productnumber(productData.getProductNumber());
    rInd.mutable_productdata()->set_productrevision(productData.getProductRevision());
    rInd.mutable_productdata()->set_productname(productData.getProductName());
    rInd.mutable_productdata()->set_productserialnumber(productData.getProductSerialNumber());
    rInd.mutable_productdata()->set_productiondate(productData.getProductionDate());
    rIndProcedure->send(std::move(rInd));


albo

rInd.set_allocated_productdata(
        new rbs::catiw1::ssm::commonDataTypes::ProductData(hwProductData.convertToGpbFormat()));
    rInd.set_allocated_powerprofiledata(
        new rbs::catiw1::ssm::commonDataTypes::PowerProfileData(hwPowerProfileData.convertToGpbFormat()));





Google protobuf
syntax="proto2";

package rbs.catiw1.ssm.commonDataTypes;

message ProductData
{
  optional string productnumber = 1;
  optional string productrevision = 2;
  optional string productname = 3;
  optional string productiondate = 4;
  optional string productserialnumber = 5;
}


tworzenie obiektu
rbs::catiw1::ssm::commonDataTypes::ProductData proData;

odczyt zawartości odbywa się przez potraktowanie pola jak metoda (wtedy staje sie get)
proData.productnumber();

zapis

proData.set_productnumber("101");

jeśli msg sklada się z innej wiadomości (np z tej powyzszej)

syntax="proto2";

import "CommonDataTypes.proto";

package rbs.catiw1.ssm.fruConfigurationHandlerIf;

enum InterfaceName
{
  FRU_CONFIGURATION_SERVER = 0;
}

message sendProductDataRInd{
    enum metaData{MESSAGE_NUMBER=0XBAD2900;};
    optional rbs.catiw1.ssm.commonDataTypes.ProductData productdata = 1;
}



to zapisujemy go wykorzystujac wczesniej stworzoną wiadomość wewnetrzną

rbs::catiw1::ssm::fruConfigurationHandlerIf::sendProductDataRInd ind;

ind.set_allocated_productdata(proData);

(w tym przypadku proData musi byc wskaźnikiem !!)

a odczytujemy go
ind.productdata().productnumber()


Jeśli chcemy zapisać Bez pośrednictwa obiektu proData:
ind.mutable_productdata()->set_productnumber("1");


C++17 If statement with initializer

// C++17 if statement with initializer
   if (int random_num = rand(); random_num % 2 == 0) {
      cout << random_num << " is an even number\n";
   } else {
      cout << random_num << " is an odd number\n";
   }



.