2 Podstawy



Zmienne

                                       bits
short int                         2 -32,768 to 32,767
unsigned short int         2 0 to 65,535
unsigned int                 4 0 to 4,294,967,295
int                                 4 -2,147,483,648 to 2,147,483,647
long int                         8 -2,147,483,648 to 2,147,483,647
unsigned long int         4 0 to 4,294,967,295
long long int                 8 -(2^63) to (2^63)-1
unsigned long long int 8 0 to 18,446,744,073,709,551,615
signed char                 1 -128 to 127
unsigned char                 1 0 to 255

#include <stddef.h>

size_t
Unsigned integral type of the result of the sizeof operator.

Fixed-width integers

These are defined as follows:
NameTypeRangeNotes
int8_t1 byte signed-128 to 127Treated like a signed char on many systems. See note below.
uint8_t1 byte unsigned0 to 255Treated like an unsigned char on many systems. See note below.
int16_t2 byte signed-32,768 to 32,767
uint16_t2 byte unsigned0 to 65,535
int32_t4 byte signed-2,147,483,648 to 2,147,483,647
uint32_t4 byte unsigned0 to 4,294,967,295
int64_t8 byte signed-9,223,372,036,854,775,808 to 9,223,372,036,854,775,807
uint64_t8 byte unsigned0 to 18,446,744,073,709,551,615
C++ officially adopted these fixed-width integers as part of C++11. They can be accessed by including the cstdint header, where they are defined inside the std namespace.

#include<cstdint>

..........


standardowo typy wbudowane wg definicji nie są określone po długości bajtów ale po pojemności liczb (patrz C) (jeśli chcesz wymusić długość bajtową patrz tabelka powyżej)

int  max =    std::numeric_limints<int>::max();               zwróci max ,   ::min() - zwróci min

CONST - stała

to samo co za pomocą preprocesora
#define MAX_INIT 5
ale on po prostu zamieni ciąg na 5 podczas kompilacji...


cout:
manipulator oct    hex   dec   / albo setbase(16) ??
int liczba=255
cout<<"Liczba 16tkowo"<<hex<<liczba;   raz uruchomiony hez na zmiennej liczba-działa
więc w następnej lini jeśli chcemy w dziesiętnym to <<dec<liczba;




Referencje (alias)
int a=5;
int &b=a;

b jest referancją do a. zapis do b zmieni a, zamiana a zmieni b

const int &k=a;

za pomocą k nie zmienimy a, ale zmiana a zmieni k

Referancja może być przypisana do czegoś co ma adres (inna zmienna).
Referancja jest wskaźnikiem, czyli jeśli przekazywana do funkcji jako parametr to zmiana w funkcji wpłynie na a.



Typedef , using
pozwala na istniejącemu już typowi nadanie nowej nazwy.

Deklaracja:
typedef int  napiecie;

albo:
using napiecie=int;

i teraz:
napiecie nap_progowe;      - to samo co:       int  nap_progowe;

Po co? Możemy w Łatwy sposób zmienić określony typ zmiennych w całym programie
np z int na double




String i vector
std::string    - ułatwia pracę z tekstem
std:vector    - ułatwia pracę z obiektami zebranymi w grupę

using namespace std;         - nie trzeba dopisywac std::



Definicja string:

std::string   solar{"Panel sloneczny"};

std:string  imie;     //pusta 
cin>>imie;


Porównywanie:

if(imie=="Jurek")
{
//...
}



Dodawanie:

string rozkaz;
rozkaz="Naprawic" + imie;             //dodał C-string  do stringa

rozkaz+="na koncu";                       //dodał na końcu na końcu tekstu



Zamiana:
rozkaz=komunikat;



Porównanie alfabetyczne:

if(imie<solar)
  //..;
else
  //..;



Zamiana liczby na stringa:

int a=5;
string  liczba_tekstowo = to_string(a);



Określenie długości:

int dlugosc=imie.size();



                                                             Vektor:
Dyrektywa Vektor:
#include <vector>


Definicja
std::vector<int>                  liczby;
std::vector<std::string>      imiona;               //vector<string>    imiona;


Definicja + wartości:
vector<double>  liczby{3, 10, 100, 1000};
vector<string> imiona{"Janek","Bach"};

indeksujemy od 0


Przykład użycia:

// Program z paragrafu 05_02
 #include <iostream>
 #include <vector>             // 1
 #include <string>
 using namespace std;             // 2
//************************************************************
 int main()
 {
  vector<int> ww { 9,  4,  7,  -6,  2,  7 };       // 3
  cout << "ww[1]= " <<   ww[1]   << endl;        // 4

  int rozmiar = ww.size();         // 5
  cout << "Wektor ww ma elementów " << rozmiar << endl;

  for(unsigned int i = 0 ; i < ww.size() ; ++i) {       // 6
   cout << ww[i] << ", " ;          // 7
  }  cout << endl;

  int b = ww[4] + 500;     // 2 + 500    // 8
  ww[2] = ww[3] * 10;     // –6 * 10    // 9
  cout << "b = " << b << " ww[2] = " << ww[2] << endl;

  cout << "Obecna zawartosc wektora ww: " << endl;
  for(unsigned  int nr = 0 ; nr < ww.size() ; ++nr)      // 10
  {
    cout << "ww[" << nr << "] = " << ww[nr];
    if(ww[nr] == 2) {        // 11
        cout << " <->dwa!";
     }
    cout << endl;
  }
  

    vector<int> m;          // 12
  vector<char> symbole(10);         // 13
  vector<char> litery(12, '.');          // 14
  cout << "Tresc wektora litery:\n";
  for(unsigned int i = 0 ; i < litery.size() ; ++i)  cout << litery[i];
  cout << endl;

  litery[0]   = 'M';          // 15
  litery[6]   = 'B';  litery[10] = 'X';

  for(unsigned int i = 0 ; i < litery.size() ; ++i)  cout << litery[i] ;
  cout << endl;


  // ciąg dalszy programu
  vector<string> fizycy { "G. Galilei", "I. Newton", "A. Einstein" };    // 16

  vector<string> muzycy;           // 17
  cout << "a) muzycy.size() = " << muzycy.size() << endl;

  muzycy.push_back("Chopin");         // 18
  cout << "b) muzycy.size() = " << muzycy.size() << endl;    // 19

  muzycy.push_back("Lutoslawski");
  muzycy.push_back("Debussy");

  for(unsigned int i = 0 ; i < muzycy.size() ; ++i)      // 20
  {
   cout << "muzycy[" << i << "] to: " << muzycy[i] << endl;
  }

  // zamiana treści
  muzycy[1] = "Moniuszko";          // 21
  muzycy[2] = muzycy[0];           // 22
  cout << "Podaj samo nazwisko kompozytora: ";       // 23
  string ulubiony;
  cin >> ulubiony;
  muzycy.push_back(ulubiony);          // 24

  for(unsigned int i = 0 ; i < muzycy.size() ; ++i)    cout << muzycy[i] << ", ";
  cout << endl;
 }



ENUMS
enum Color {
    Red = 0, 
    Green, 
    Blue
};

int foo(int);

int main() {
    Color c = Red;

    foo(c);
}


Tablice
int main() {
    int tabl[] = { 1,2,3,4 };
    int size = sizeof(tabl) / sizeof(int);
}

albo:
#include <array>

int main() {
    std::array<int, 10> array {0,1,2,3,4,5,6,7,8,9};
    array.size(); 
    std::array<int, 10> duplicate; 

    duplicate = array;
}



Konwersja typów

niejawna:
void foo(int);
int main() {
    float z = 5.0f;
    foo(z);
}

jawna:
void foo(int);
int main() {
    float z = 5.0f;
    foo(static_cast<int>(z));
}



Zakresowe FOR

dla:
int main() {
    std::array<int, 10> arr;


iteruje value po kopiach
for(int value: arr) {}

iteruje valuue po referancji (szybsze niz po kopiach)
for(int& value: arr) {}

iteruje po referencji ale nie pozwala jej zmienić
for(const int& value: arr) {}


Ćwiczenie
Wypełnij tablice 100 losowymi elementami i znajdź największy:
#include <iostream>
#include <array>
#include <cstdlib>
using namespace std;

 
int main()
{ 
int maks=0;
 
std::array<int,100>arr;

for(int& value: arr)
{
value=rand()%1000;
}

for(const int& value: arr) 
{
if (value>maks)
  {
  maks=value; 
  }

}

cout<<maks;

}

.
Przykłady tworzenia tablic wraz z inicjalizacjami, 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;
}


Przykład tworzenia statycznego obiektu w klasie:


#include<iostream>
#include<string>


struct Human {

    Human(): name("prawda"){std::cout<<"konstruktor1 Human"<<std::endl;}
    Human( std::string a): name(a){std::cout<<"konstruktor2 Human"<<std::endl;}
    std::string name ;

    void drukuj() const noexcept
    {
    std::cout<<name<<std::endl;
    }
};

struct Man  {

Man () : obj("dupa") {std::cout<<"konstruktor Man"<<std::endl;}

Human obj; 

void drukuj()
    {
    obj.drukuj();
    }

};


int main()
{

Man bbb;
bbb.obj.drukuj();

return 0;
}


Jak widać, żeby stworzyć statyczny (nie za pomoca new) obiekt  klasy (tu obj klasy Human tworzony w klasie Man) w innej klasie, trzeba zainicjalizować go na liście inicjalizacyjnej w konstruktorze.