/*
    Adattípusok C++-ban

    Ért. "adattípus" - megadja, hogy:
        - egy adatdarab hogy van ábrázolva a memóriában
        - milyen műveleteket lehet vele végezni
        - milyen tartományban változhatnak az értékei
          (pl. egy változónak)

Gyakran használt típusok x86_64-es architektúrán:

   Név                  Hány byte    Min.       Max.
   ------------------------------------------------------
   bool                 1           false (0)   true (1)

   short / short int    2           -2^15       2^15-1
   int                  4           -2^31       2^31-1
   long / long int      4           -2^31       2^31-1
   long long            8           -2^63       2^63-1

   char                 1           0           255
                              VAGY: -128        +127

Példák konstansokkal történő értékadásokra:
*/
/*
#include <iostream>
using namespace std;

int main()
{
    bool b = true;
    cout << b << endl; // 1

    b = false;
    cout << b << endl; // 0

    int i = 15; // tízes számrendszerben
    cout << i << endl;

    i = 0x1a;   // tizenhatos számrendszer
    cout << i << endl; // 26

    i = 012;    // nyolcas számrendszer
    cout << i << endl; // 10

    long long a = 1LL; // long long típusú konstans

    char c = 'a'; // karakter konstans
    cout << c << endl; // a
    c++;
    cout << c << endl; // b

    return 0;
}
*/

/*
    Az unsigned módosító - hatására előjel nélkülivé válik a típus

    Név                 Méret   Min   Max
    --------------------------------------------
    unsiged short       2 B     0     2^16-1
    unsigned int        4 B     0     2^32-1
    unsigned long long  8 B     0     2^64-1

Lebegőpontos számtípusok
    - valós számok (közelítő) értékének ábrázolására használjuk

    Név         Méret
    float       4 B
    double      8 B
    long double 16 B

    Példák lebegőpontos konstansokra:

        double d = 1.23;
        d = -1.23;
        d = .5; // 0.5
        d = 1.2e20; // 1.2*10^20
                    // "scientific notation"
*/

// Műveletvégzés valós számokkal:

/*
#include <iostream>
using namespace std;

int main()
{
    double d1, d2;
    cin >> d1 >> d2;

    cout << "+: " << d1 + d2 << endl;
    cout << "-: " << d1 - d2 << endl;
    cout << "*: " << d1 * d2 << endl;
    cout << "/: " << d1 / d2 << endl;
    cout << endl;
    cout << "d1/2: " << d1 / 2 << endl;
    cout << "d1/2.0: " << d1 / 2.0 << endl;
    cout << endl;
    cout << "5/2: " << 5 / 2 << endl;
    cout << "5/2.0: " << 5 / 2.0 << endl;

    return 0;
}
*/

// További beépített műveletek valós számokkal (#include <cmath>)
#include <iostream>
#include <cmath>
using namespace std;

int main()
{
    // négyzetgyök
    cout << sqrt(17) << endl; // 4.12311

    // hatvány - pow(alap, kitevő)
    cout << pow(2.2, 3) << endl; // 10.648

    cout << endl << endl;

    // kerekítések:
    // round(...), floor(...), ceil(...)
    //  kerekít,    egész rész, legkisebb egész,
    //                          ami nagyobb nála

    cout << round(3.2) << " "   // 3
         << floor(3.2) << " "   // 3
         << ceil(3.2) << endl;  // 4

    cout << round(3.8) << " "   // 4
         << floor(3.8) << " "   // 3
         << ceil(3.8) << endl;  // 4

    cout << round(3.5) << " "   // 4
         << floor(3.5) << " "   // 3
         << ceil(3.5) << endl;  // 4

    return 0;
}

/*
A műveletvégzések típusa; típuskonverzió

- két típus:
    - implicit (magától történik):
    különböző típusú értékekkel végzett műveletek esetén
    a művelet a nagyobb értékkészletű típuson végződik el
    (és az eredmény is ilyen típusú)

        int és double  ->  double
        short és int   ->  int

        (!) de: int / int  ->  int (elhagyással)

    - explicit (mi adjuk meg):
      (új típus) érték

        Pl.   25  ->  int
              25 / 2  == 12

              (double) 25  ->  double
              (double) 25 / 2 == 12.5

        cout << 25 / 2 << endl;            // 12
        cout << (double) 25 / 2 << endl;   // 12.5

        cout << (int) 1.99 << endl;        // 1
*/