Struktúrák

felhasználó által definiált összetett adattípusok
az eddig használt típusok:
- egyszerűek (primitív típusok):
```
    int, bool, char, float, double,
    char *, int * stb.
```
- tömbök (egy- vagy többdimenziósak), amik eddig egyszerű típusú adatokból álltak
egy struktúrában lehet egy vagy több adattag (mező, attribútum), mindegyik adott típusú és mindegyikre a nevével hivatkozunk

Szintaxis:

    struct TipusNev
    {
        tipus1 nev1;
        tipus2 nev2;
        ...
    } opcionálisan globális változók nevei;


    int main()
    {
        //...
        TipusNev x;
        x.nev1 = ....;
        cout << x.nev2 << endl;
        //...
    }

Az adattagokat a “.” operátorral tudjuk elérni.

Példa: pontok a síkban

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
#include <iostream>
#include <cmath>
using namespace std;

struct Pont
{
    double x;
    double y;
};

double tavolsag(Pont a, Pont b)
{
    double dx = a.x - b.x;
    double dy = a.y - b.y;

    return sqrt(dx*dx + dy*dy);
}

void kiir(Pont p)
{
   cout << "(" << p.x << "," << p.y << ")" << endl;
}

int main()
{
    Pont p1, p2;

    // cin >> p1.x;
    p1.x = 3;
    p1.y = 2;

    p2.x = 4;
    p2.y = 4;

    kiir(p1);
    kiir(p2);

    cout << tavolsag(p1, p2) << endl;

    return 0;
}

Struktúrák inicializálása

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
#include <iostream>
#include <cmath>
using namespace std;

struct Pont
{
    double x;
    double y;
};

int main()
{
    Pont a {1,2}; // ekkor: a.x == 1, a.y == 2
    // az adattagok (mezők, attribútumok) deklarálásának
    // sorrendjében adjuk meg az értékeket

    return 0;
}

Példa: alkalmazottak nyilvántartása

Beolvasunk alkalmazottakat (vezetéknév, keresznév, születési év, kereset formában, az adattagokat szóközök választják el egymástól). Tároljuk őket és írjuk ki az 5000 lejnél többet keresők születési éveit!

Példa bemenet:

    3
    Setőfi Pándor 1823 10000
    Edy Andre 1877 2000
    Ristiano Chronaldo 1985 99999

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
#include <iostream>
#include <fstream>
using namespace std;

struct Alkalmazott
{
    char vezeteknev[100];
    char keresztnev[100];
    int szuletesi_ev;
    double fizetes;
};

Alkalmazott beolvas()
{
    Alkalmazott x;

    cin >> x.vezeteknev >> x.keresztnev
        >> x.szuletesi_ev >> x.fizetes;

    return x;
}

int main()
{
    ifstream fin("input.txt");

    int n;
    fin >> n;

    Alkalmazott t[100];

    for (int i = 0; i < n; i++) {
        fin >> t[i].vezeteknev >> t[i].keresztnev
            >> t[i].szuletesi_ev >> t[i].fizetes;
    }

    for (int i = 0; i < n; i++) {
        if (t[i].fizetes > 5000) {
            cout << t[i].szuletesi_ev << endl;

        }
    }

    return 0;
}

Megjegyzések:

a struktúrák másolása működik = operátorral (byte-ról byte-ra másol)
lehet paraméterként átadni struktúrát (alapból másolódik ha nem használunk referenciát)
lehet visszatéríteni is egy függvényből struktúrát

Feladat: műveletek racionális számokkal

Implementáljunk függvényeket, amelyek struktúraként tárolt racionális számokkal végeznek műveleteket (+, -, *, /).

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
#include <iostream>
using namespace std;

struct Racionalis
{
    int szamlalo;
    int nevezo;
};

void kiir(Racionalis r) // pl. 2 / 3
{
    if (r.nevezo == 1)
        cout << r.szamlalo;
    else
        cout << r.szamlalo << " / " << r.nevezo;
}

int lnko(int a, int b)
{
    if (a < 0) a = -a;
    if (b < 0) b = -b;

    /*if (b == 0)
        return a;
    return lnko(b, a%b);*/

    int eredmeny = 1;
    for (int i = 2; i <= a && i <= b; i++)
        if (a % i == 0 && b % i == 0)
            eredmeny = i;

    return eredmeny;
}


void egyszerusit(Racionalis &r)
{
    int d = lnko(r.szamlalo, r.nevezo);

    r.szamlalo = r.szamlalo / d;
    r.nevezo = r.nevezo / d;

    if (r.nevezo < 0) {
        r.nevezo = -r.nevezo;
        r.szamlalo = -r.szamlalo;
    }
}

Racionalis szoroz(Racionalis r1, Racionalis r2)
{
    Racionalis eredmeny;

    eredmeny.szamlalo = r1.szamlalo * r2.szamlalo;
    eredmeny.nevezo = r1.nevezo * r2.nevezo;

    egyszerusit(eredmeny);
    return eredmeny;
}

Racionalis osszead(Racionalis r1, Racionalis r2)
{
    Racionalis eredmeny;

    eredmeny.szamlalo = r1.szamlalo * r2.nevezo
                        + r2.szamlalo * r1.nevezo;
    eredmeny.nevezo = r1.nevezo * r2.nevezo;

    egyszerusit(eredmeny);
    return eredmeny;
}

Racionalis kivon(Racionalis r1, Racionalis r2)
{
    Racionalis eredmeny;

    eredmeny.szamlalo = r1.szamlalo * r2.nevezo
                        - r2.szamlalo * r1.nevezo;
    eredmeny.nevezo = r1.nevezo * r2.nevezo;

    egyszerusit(eredmeny);
    return eredmeny;
}

Racionalis inverz(Racionalis r)
{
    return {r.nevezo, r.szamlalo};
}

Racionalis oszt(Racionalis r1, Racionalis r2)
{
    return szoroz(r1, inverz(r2));
}

int main()
{
    Racionalis a {1,-2}, b {2,3};
    kiir(a);
    cout << endl;
    kiir({1,3});
    cout << endl;
    kiir({5,1});
    cout << endl;

    kiir(szoroz(a,b)); //  1/3
    cout << endl;
    kiir(osszead(a,b)); //  7/6
    cout << endl;

    kiir(kivon(b,a)); // 7/6
    cout << endl;

    a = {1,-2};
    b = {-1,3};
    kiir(osszead(a,b));  // -5/6
    cout << endl;

    kiir(oszt(a,b)); // 3/2
    cout << endl;

    return 0;
}

Feladat: műveletek komplex számokkal

Implementáljunk függvényeket, amelyek struktúraként tárolt komplex számokkal végeznek műveleteket (+, -, *, /, modulusz, konjugált).

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
#include <iostream>
#include <cmath>
using namespace std;

struct Komplex
{
    double re; // valos_resz
    double im; // imaginarius_resz_egyutthatoja;
};

Komplex osszead(Komplex x, Komplex y)
{
    Komplex eredmeny;

    eredmeny.re = x.re + y.re;
    eredmeny.im = x.im + y.im;

    return eredmeny;
}

Komplex kivon(Komplex x, Komplex y)
{
    Komplex eredmeny;

    eredmeny.re = x.re - y.re;
    eredmeny.im = x.im - y.im;

    return eredmeny;
}


Komplex konjugalt(Komplex x)
{
    return {x.re, -x.im};
}

Komplex szoroz(Komplex x, Komplex y)
{
    Komplex eredmeny;

    /* (a+bi)(c+di) */
    eredmeny.re = x.re * y.re - x.im * y.im;
    eredmeny.im = x.re * y.im + x.im * y.re;

    return eredmeny;
}

Komplex oszt(Komplex x, Komplex y)
{
    Komplex eredmeny = szoroz(x, konjugalt(y));

    double nevezo = y.re * y.re + y.im * y.im;
    eredmeny.re /= nevezo;
    eredmeny.im /= nevezo;

    return eredmeny;
}

void kiir(Komplex k)
{
    if (k.im == 0)
        cout << k.re;
    else {
        if (k.re == 0)
            if (k.im == 1)
                cout << "i";
            else if (k.im == -1)
                cout << "-i";
            else
                cout << k.im << "i";
        else { // egyik sem 0
            if (k.im == 1)
                cout << k.re << "+i";
            else if (k.im == -1)
                cout << k.re << "-i";
            else if (k.im > 0)
                cout << k.re << "+" << k.im << "i";
            else
                cout << k.re << k.im << "i";
        }
    }
}

double modulusz(Komplex k)
{
    return sqrt(k.re*k.re + k.im*k.im);
}

int main()
{
    //Komplex k {1,2};
    //kiir(k);

    kiir({1,2}); cout << endl;
    kiir({0,0}); cout << endl;
    kiir({0,-2}); cout << endl;
    kiir({1,-2}); cout << endl;
    kiir({1,0}); cout << endl;
    kiir({-1,0}); cout << endl;
    kiir({-1,-2}); cout << endl;
    kiir({-5,1}); cout << endl;
    kiir({-5,-1}); cout << endl;
    kiir({0,1}); cout << endl;
    kiir({0,-1}); cout << endl;


    //return 0;

    Komplex z1 {1,2}, z2;
    z2.re = -1;
    z2.im = -3;

    Komplex z3 = osszead(z1, z2);
    kiir(z3);
    cout << endl;

    //Komplex z3 = szoroz(z1, z2);
    //kiir(z3);

    //kiir(konjugalt({-1, 2}));
    //cout << endl;

    //Komplex z3 = oszt(z1, z2);
    //kiir(z3);
    //cout << endl;

    //kiir(szoroz(z2,z3));
    //cout << endl;
    //kiir(z1);

    cout << modulusz(z2) << endl;

    z3 = kivon(z1, z2);
    kiir(z3);
    cout << endl;

    return 0;
}