#include <iostream>	//cin, cout
#include <iomanip>	//setw
#include <ctime>		//random
using namespace std;		//std névterület alkalmazása

void csere(int* a, int* b);
void csere_r(int& a, int& b);

int main()
{
	cout << "Double érteke: ";
	double d = 123456.123456;
	cin >> d;
	cout << "d: " << d << endl;

	int a = 15;
	cout << "Int erteke: ";
	cin >> a;
	cout << "a: " << a << endl;

	cout << "d: " << d << " a: " << a << endl;
	cout <<"d: " << setw(15) << d << " a: " << setw(8) << a << endl;
	cout <<"d: " << left << setw(15) << d << " a: " << setw(8) << a << endl;
	cout <<"d: " << setfill('*') << setw(15) << d << " a: " << setw(8) << setfill(' ') << a << endl;
	cout <<"d: " << setprecision(4) << setw(15) << d << " a: " << setw(8) << a << endl;
	cout <<"d: " << setw(15) << d << " a: 0x" << hex << setw(8)  << a << dec << endl;
	cout <<"d: " << fixed << setw(15) << d  << endl;
	cout <<"d: " << scientific << setw(15) << d  << endl;
	
	cout.unsetf(std::ios::floatfield);
	cout << "d: " << d << " a: " << a << endl;

	char betu = 65;
	cout << "Betu: " << betu << endl;

	wchar_t wc = L'ó';

	float f = 16.45f;

	bool l = false; //false
	cout << "Boolean: " << l << endl;

	//mutató
	int i = 100;
	int* p;
	p = &i;
	printf("i=%i *p=%i\n", i, *p);

	srand(unsigned int(time(NULL)));
	double* t =(double *)malloc(sizeof(double) * 10);
	if (t != NULL)
	{
		for (int i = 0; i < 10; i++)
		{
			*(t + i) = (double)(rand() % 21) / 2; //0..10 0,5 osztás
			cout << t[i] << " ";
		}
		cout << endl;
		free(t);
	}

	//c++
	double* tp = new double;
	delete tp;

	double* tpp = new double[10];
	for (int i = 0; i < 10; i++)
	{
		tpp[i] = (double)(rand() % 21) / 2; //0..10 0,5 osztás
		cout << tpp[i] << " ";
	}
	cout << endl;
	delete[] tpp;

	int** EE = new int* [3];
	for (int i = 0; i < 3; i++)
		EE[i] = new int[3];

	for (int i = 0; i < 3; i++)
		for (int j = 0; j < 3; j++)
				EE[i][j] = i == j;

	for (int i = 0; i < 3; i++)
	{
		for (int j = 0; j < 3; j++)
		{
			cout << EE[i][j] << " ";
		}
		cout << endl;
	}

	for (int i = 0; i < 3; i++)
		delete[] EE[i];
	delete[] EE;

	//referencia
	int alap = 13;
	int& r = alap;

	cout << "alap = " << alap << " r = " << r << endl;
	alap++;
	cout << "alap = " << alap << " r = " << r << endl;
	r++;
	cout << "alap = " << alap << " r = " << r << endl;

	int c = 15;
	int b = 20;

	cout << "c: " << c << " b: " << b << endl;
	csere(&c, &b);
	cout << "c: " << c << " b: " << b << endl;
	csere_r(c, b);
	cout << "c: " << c << " b: " << b << endl;
}

void csere(int* a, int* b)
{
	int tmp = *a;
	*a = *b;
	*b = tmp;
}

void csere_r(int& a, int& b)
{
	int tmp = a;
	a = b;
	b = tmp;
}

fgv.h

#pragma once
#ifndef FGV_H
#define FGV_H

//Függvények prototípusa //.h fájlban a helyük

/// <summary>
/// Csere pointerrel
/// </summary>
/// <param name="a">egyik</param>
/// <param name="b">masik</param>
void csere(int *a, int *b);

/// <summary>
/// Csere referenciával
/// </summary>
/// <param name="a">egyik</param>
/// <param name="b">masik</param>
void csere(int & a, int & b);

// saját névterület
namespace korszeru
{
	void kiir();
}

#endif // !FGV_H

fgv.cpp

#include "fgv.h"
#include <iostream>

void csere(int * a, int * b)
{
	int tmp = *a;
	*a = *b;
	*b = tmp;
}

void csere(int & a, int & b)
{
	int tmp = a; a = b; b = tmp;
}

int sajatvaltozo = 10;
void korszeru::kiir()
{
	std::cout << "sajat valtozo = " << sajatvaltozo << std::endl;
}

main.cpp

#include <iostream>
#include <ctime>

//saját modul betöltése
#include "fgv.h"
#include <string>
#include <cmath>

using namespace std;

extern int sajatvaltozo;

//tömb átlaga
double tatlag(double *, int);

//alapértelmezett érték
double polinom(double x, double a=3, double b=2, double c=1);

//sablon
template <typename T> 
T osszeg(T a, T b);

//rekurzív fgv
unsigned long long factorial(unsigned long long n);

//fgv. pointer
typedef double fgv(double x);
fgv negyzet;
fgv * matek;


int main()
{
	int a = 10, b = 20;
	csere(&a,&b);
	std::cout << "a = " << a << " b = " << b << std::endl;
	csere(a, b);
	std::cout << "a = " << a << " b = " << b << std::endl;

	korszeru::kiir();
	sajatvaltozo += 20;
	using namespace korszeru;
	kiir();

	int db = 10;
	double * tadat = new double[db];
	srand(unsigned int(time(NULL)));

	for (int i = 0; i < db; i++)
	{
		tadat[i] = double(rand()) / RAND_MAX * 10;
	}
	std::cout << "Atlag: " << tatlag(tadat,db) << std::endl;
	delete[] tadat;

	//HF tatlag int adattípusú tömbbel is!!!

	cout << "Polinom" << endl;
	cout << "3.2 5 6 7" << polinom(3.2, 5, 6, 7) << endl;
	cout << "3.2 5 6 1" << polinom(3.2, 5, 6) << endl;
	cout << "3.2 5 2 1" << polinom(3.2, 5) << endl;
	cout << "3.2 3 2 1" << polinom(3.2) << endl;

	cout << "Template" << endl;
	cout << osszeg(a, b) << endl;

	double c = 3.2, d = 5.4;
	osszeg<double>(a, c);

	cout << osszeg<int>(c, d) << endl;

	cout << "char : " << osszeg('1', '0') << endl;
	cout << "char : " << osszeg<int>('1', '0') << endl;

	cout << "szoveg :" << osszeg<string>("Ez", " mukodik") << endl;

	for (int i = 0; i < 30; i++)
	{
		cout << i << "! = " << factorial(i) << endl;
	}

	cout << negyzet << endl;

	cout << negyzet(2) << endl;

	matek = negyzet;

	cout << matek(2) << endl;

	matek = abs;

	cout << matek(-2343) << endl;


	matek = sin;

	cout << matek(2141) << endl;

	return 0;
}

double tatlag(double *t, int n)
{
	double sum = 0;
	for (int i = 0; i < n; i++)
			sum += t[i];
	return sum / n;
}

double polinom(double x, double a, double b, double c)
{
	return a + b*x + c*x*x;
}

unsigned long long factorial(unsigned long long n)
{
	if (n > 0)
		return n* factorial(n - 1);
	else
		return 1;
	
	//return (n > 0) ? n * factorial(n - 1) : 1;
}

template<typename T>
T osszeg(T a, T b)
{
	return a + b;
}

double negyzet(double x)
{
	return x * x;
}

#include <iostream>
#include <cmath>
using namespace std;

// külön .h fájlba
class Vektor
{
	//private adattagok
private:
	double x, y;

public:
	//statikus változó
	static int szam;

	//konstruktorok
	//paraméteres konstruktor
	Vektor(double x = 0, double y = 0);
	//másoló konstruktor
	Vektor(const Vektor& v);
	//destruktor
	~Vektor();

	//getter (const hogy ne tudjon módosítani)
	double getx() const;
	double gety() const;

	//setter
	void setx(double x);
	void sety(double y);

	//tagfüggvények
	void kiir();
	double hossz();
	void egysegre();

	friend ostream& operator << (ostream& o, const Vektor& v);
};

//.cpp-fájlban a helyük
Vektor::Vektor(double x, double y){
	this->x = x;
	this->y = y;
	cout << "Konstruktor hivasa" << endl;
}

Vektor::Vektor(const Vektor& v) {
	this->x = v.x;
	this->y = v.y;
	cout << "Masolo konstruktor hivasa" << endl;
}

Vektor::~Vektor() {
	cout << "Destruktor hivasa" << endl;
}

double Vektor::getx() const { return x; }
double Vektor::gety() const { return y; }

void Vektor::setx(double x) {
	this->x = x;
}

void Vektor::sety(double y) {
	this->y = y;
}

void Vektor::kiir() {
	cout << "[" << x << " , " << y << "]" << endl;
}

double Vektor::hossz() {
	return sqrt(pow(x, 2) + pow(y, 2));
}

void Vektor::egysegre() {
	double h = this->hossz();
	this->x /= h;
	this->y /= h;
}

// külső függvény
// nem éri el az adattagokat
double hossz(const Vektor& v)
{
	return sqrt(pow(v.getx(), 2) + pow(v.gety(), 2));
}

// külső függvény
// barát, ezért elérni a belső adattagokat
ostream& operator << (ostream& o, const Vektor& v)
{
	o << "[" << v.x << " , " << v.y << "]";
	return o;
}

// statikus változó használata
int Vektor::szam = 0;

int main()
{
	{
		//Vektor A = Vektor(4, 3);
		Vektor A(4, 3);

		cout << "A: " << A.getx() << ", " << A.gety() << endl;	//kiíratás
		A.setx(2);
		cout << "A: " << A.getx() << ", " << A.gety() << endl;	//kiíratás

		Vektor B = A;

		cout << "B: ";
		B.kiir();	//kiíratás

		cout << "B hossza: " << B.hossz() << endl;

		B.egysegre();

		cout << B << " vektor" << endl;

		cout << "B hossza: " << hossz(B) << endl;

		Vektor::szam = 10;

		Vektor* D = new Vektor(4, 3);
		D->kiir();
		delete D;

	}
	cout << "Vege az oranak";
}

#include <iostream>       //cin, cout
#include <iomanip>        //setw
#include <string>         //szövegek
#include <sstream>        //konverzióhoz
using namespace std;

int main()
{
    //üres string
    string s0;
    //string s0();  //hiba, mert függvényfejlécként értelmezendő

    //másolás
    string s1("Mechatronika Tanszek");
    string s2 = "Tanszek";

    s1 = "Mechatronika, Optika es Gepeszeti Informatika tanszek";
    s1.assign("Mechatronika, Optika es Gepeszeti Informatika tanszek");
    cout << "Nev: " << s1 << endl;
    cout << s1.at(0) << s1.at(14) << s1.at(24) << s1.at(34) << endl;

    s1.at(0) = 'B';
    cout << s1[0] << s1[14] << s1[24] << s1[34] << endl;
    s1.front() = 'M';

    int size = s1.size();
    int length = s1.length();
    int capacity = s1.capacity();
    int max_size = s1.max_size();

    size_t pos = s1.find('t');  //5
    pos = s1.find('t', 13);     //16
    pos = s1.rfind('t');        //46
    pos = s1.find("tanszek");   //46
    if (s1.find("Tanszek") == string::npos) //npos
        cout << "Nincs Tanszek" << endl;

    s1.replace(pos, s2.size(), s2);
    cout << "Nev: " << s1 << endl;

    s1.erase(pos);
    s1.erase(pos, strlen("Tanszek"));
    s1.erase(pos, s2.length());

    // törlés
    s1.erase(s1.end() - 1);  // utolsó elem törlése iterátorral 

    s2.clear();              // s2 ürítése
    s2.erase(0);
    s2.erase(s2.begin(), s2.end());
    s2 = "";

    if (s2.empty()) cout << "ures" << endl;


    s2 = s1 + " ";
    s2 += s1;
    s2 += " ";
    s2.append(s1);

    s2 = "";
    for (int i = 0; i < s1.size(); i++)
        if (isupper(s1.at(i))) s2 += s1[i];

    cout << "A nev roviden: " << s2 << endl;

    cout << "BSc kepzes: " << s1.substr(0, s1.find(',')) << "i mernok" << endl;

    //Értékek bekérése:
    cout << "Hanyadik karaktert irjuk at ? ";
    cin >> pos;
    if (cin.fail())    //ha nem jó a konverzió
    {
        cout << "A megadott ertek nem szam!" << endl;
        pos = 1;
        cin.clear();                //törlöm a hibát
    }
    while (cin.get() != '\n');        //Enter leütését nyeli el
    cout << "Mire? ";
    char c;
    cin.get(c);    cin.get();
    s1.at(--pos) = c;
    cout << s1 << endl;

    //több szavas szöveg beolvasása
    cout << "Mi a teljes neved? ";
    //cin elválasztó karakterként értelmezi a space-t
    getline(cin, s2);   //cin.getline(char*, hossz);
    cout << s2 << endl;

    ///Konverziók
    //szöveg -> szám
    //stringstreammel - több értéket is feldolgozhatunk
    string s, stmp;
    stringstream stst;
    double d;
    s = "3.14 a pi erteke";
    stst << s;                        //ss tartalma "3.14 a pi erteke"
    stst >> d >> stmp;                //d=3.14    stmp="a" (a space elválasztó!)
    stst.str("");                        //stst tartalma "" , ki van ürítve
    stst.clear();                        //stst hibajelének törlése, ha hiba lépne fel
    cout << "Str -> szam: " << s << " => " << d << "\t es a maradek:" << stmp << endl;

    //szám -> szöveg
    //stringstreammel - manipulátorok használhatóak
    double pi = 3.14159265359;
    stst << setprecision(10) << pi;        //ss tartalma "3.141592654" , előtte  ki volt ürítve!
    s = stst.str();                        //ss >> s;        ss tartalma átmásolódik s-be
    cout << "Szam -> str: " << pi << " = " << s << endl;

    //szöveg -> szám
    //stod - figyelni kell a helyi beállításokra
    size_t hpos;
    d = stod(s, &hpos);            //d=3.14
    //hpos-ban kapjuk vissza a konverzió utáni hely értékét
    cout << "Str -> szam: " << s << " => " << d << "\t es a maradek:" << s.substr(hpos) << endl;


    //szám -> szöveg
    //to_string - hu esetén ','-vel tér vissza (max. 6 tizedes)
    s = to_string(pi);                    //s="3.141593"  (hu s="3,141593")
    cout << "Szam -> str: " << pi << " = " << s << endl;
    
}

		

#include <iostream>
#include <string>	// szöveg
#include <sstream>	// konverzió
#include <fstream>	// fájl
using namespace std;

string fname = "ttt_BMEGEMIBMOO_2024o.csv";
string zhido = "L02_ZH.txt";

// tördelés
string resz(string s, char c, int db);

int main()        
{
    /*
    // tördelés
    string s = "12.4;15.4;45.4;48.4;123;47.4";
    stringstream stst(s);
    string tmp;
    double szum = 0;
   
    while (getline(stst, tmp, ';')) {
        cout << tmp << endl;
        szum += stod(tmp);
    }
    cout <<"Az osszeg:" << szum << endl;
    */

    //setlocale(LC_ALL, "hun"); // magyar karakterek miatt, de nem javasolt
	
    ifstream fin(fname); // fájl nyitása olvasásra
    if (!fin.is_open()) // sikerült a fájl nyitása?
    {
        cout << "Nem sikerult megnyitni a(z) " << fname << " fajlt" << endl;
        return -1;
    }

    ofstream fout;  // fájl kimenetnek
    fout.open(zhido, fstream::out); // megnyitás írásra (hozzáírás esetén fstream::app)
    fout << "L02-es kurzus ZH idopontjai:" << endl;


    string sor;
    getline(fin, sor);    // előolvasás - fejléc

    
    while (!fin.eof())  // feldolgozás a fájl végéig
	{ 
        getline(fin, sor); // egy egész sor beolvasása

        if (sor.empty()) continue; // ha üres a sor

        string adat;
        stringstream stst(sor);
        getline(stst, adat, ';');  //tárgykód
        getline(stst, adat, ';');  //tárgynév
        getline(stst, adat, ';');  //kurzus
        
		// kurzus beazonosítása/szűrése
        // if (adat.find("L02") == string::npos) continue; //vagy
        // if (adat.compare("24o_L02_LAPTOP") != 0) continue; //vagy
        if (adat != "24o_L02_LAPTOP") continue;
        
        //cout << sor << endl;
        for(int i=4; i<=7 ; i++)
            getline(stst, adat, ';');  // ZH fajtája
        cout << adat << ": ";      
        fout << adat << ": ";       // kiírás fájlba

        for (int i = 8; i <= 11; i++)
            getline(stst, adat, ';'); // kezdő dátum  pl.: 2024.10.25 12:15
        cout << adat << "-";
        fout << adat << "-";

        getline(stst, adat, ';');	  // vég dátum  pl.: 2024.10.25 14:00
        cout << adat.substr(adat.find(' ')+1) << endl; // csak az idő
        fout << adat.substr(adat.find(' ')+1) << endl;
        

		/* 
        if (resz(sor, ';', 3) != "24o_L02_LAPTOP") continue;
        cout << resz(sor, ';', 7) << ": " << resz(sor, ';', 11) << "-";
        string stmp = resz(sor, ';', 12); 
        cout << resz(stmp,' ',2) << endl;
		*/

    }

	fin.close();    //fájl bezárása
	fout.flush();   //fájl kiírásának kényszerítése
	fout.close();   //fájl bezárása
}

string resz(string s, char c, int db)
{
    stringstream stst(s);
    string stmp;
    for (int i = 0; i < db; i++) {
        stmp = "";
        getline(stst, stmp, c);
    }
    return stmp;
}

#include <iostream>
using namespace std;

class Masodfoku;

class komplex {
    double re, im;
public:
    komplex(double re, double im = 0);
    komplex(const komplex& k);
    ~komplex();

    // getter/setter
    double getRe() const { return re; }
    double getIm() const { return im; }
    void setRe(double re) { this->re = re; }
    void setIm(double im) { this->im = im; }

    // tagfüggvények
    komplex& operator=(const komplex& k);
    komplex operator+(const komplex& k);
    komplex& operator++(); // előtag
    komplex operator++(int post); // utótag
    komplex operator*(double n);
    komplex& operator*=(double n);

    // külső barát függvények
    friend ostream& operator<<(ostream& os, const komplex& k);
    friend komplex operator-(const komplex& a, const komplex& b);
    friend komplex operator--(komplex& k);
    friend komplex operator--(komplex& k, int post);
    friend komplex operator*(double n, const komplex& k);
	//  barát osztály
    friend Masodfoku;
};

//külső fgv.
ostream& operator<<(ostream& os, const komplex& k) {
    ios::fmtflags save = os.flags();
    os << k.getRe() << showpos << k.im << "i";
    os.flags(save);
    return os;
}

komplex operator-(const komplex& a, const komplex& b) {
    return komplex(a.re - b.re, a.im - b.im);
}

komplex operator--(komplex& k) {
    --k.re;
    --k.im;
    return k;
}

komplex operator--(komplex& k, int post) {
    komplex seged(k);
    k.re--;
    k.im--;
    return seged;
}

komplex operator*(double n, const komplex& k) {
    return komplex(k.re * n, k.im * n);
}

int main()
{

    komplex k1(10, 20), k2(20);
    {
        komplex k3 = k1; // másoló konstruktor     komplex k3(k1)
        k1 = k2;         // operator=  k1.operator=(k2)
        k1 = k1 + k2;    // +   k1.operator+(k2)   // tag fgv.
        k1 = k1 - k2;    // -   operator-(k1,k2)   // külső fgv.
    }
    cout << "k1: " << k1 << endl;
    cout << "++k1:" << ++k1 << endl;
    cout << "k1++:" << k1++ << endl;
    cout << "k1: " << k1 << endl;
    cout << "k1 * 3: " << k1 * 3 << endl;   // k1.operator*(3)
    cout << "3 * k1: " << 3 * k1 << endl;   // operator*(3,k1) 
    k1 *= 3;
    cout << "k1: " << k1 << endl;


}

komplex::komplex(double re, double im):re(re),im(im)
{
#ifdef _DEBUG
    cout << "Letrehoz " << *this << endl;
#endif
}

komplex::komplex(const komplex& k):re(k.re),im(k.im)
{
#ifdef _DEBUG
    cout << "Masol " << *this << endl;
#endif
}

komplex::~komplex()
{
#ifdef _DEBUG
    cout << "Torol " << *this << endl;
#endif
}

komplex& komplex::operator=(const komplex& k)
{
    this->re = k.re;
    this->im = k.im;
#ifdef _DEBUG
    cout << "Ertekadas " << *this << endl;
#endif
    return *this;
}

komplex komplex::operator+(const komplex& k)
{
    return komplex(re + k.re, im + k.im);
}

komplex& komplex::operator++()
{
    re++;
    im++;
    return *this;
}

komplex komplex::operator++(int valami)
{
    komplex seged(re, im);
    re++; im++;
    return seged;
}

komplex komplex::operator*(double n)
{
    return komplex(re*n, im*n);
}

komplex& komplex::operator*=(double n)
{
    re *= n;
    im *= n;
    return *this;
}

#define _USE_MATH_DEFINES
#include <iostream>
#include <cmath>
using namespace std;
 
class p2D
{
public:
    p2D(double x, double y) :x(x), y(y) {};
    void setX(double x) { this->x = x; }
    void setY(double y) { this->y = y; }
    double getX() const { return x; }
    double getY() const { return y; }
    void mozgat(double x, double y)
    {
        this->x = x;
        this->y = y;
    }
    double tav(const p2D & b)
    {
        return sqrt(pow(x - b.x, 2) + pow(y - b.y, 2));
    }
    friend ostream & operator << (ostream & o, const p2D &p)
    {
        o << p.x << ";" << p.y << endl;
        return o;
    }
    p2D operator*(double m);
    p2D& operator*=(double m)    //saját magát megváltoztató fgv.
    {
       this->x *= m;
       this->y *=m;
       return *this;
    }
    friend class Kor;
protected:
    double x, y;
};
 
//belső fgv.
p2D p2D::operator*(double m)
{
    return p2D(x * m, y * m);
}
 
//külső fgv. (lehetne akár friend is)
p2D operator*(double m, const p2D& p)
{
    return p2D(p.getX() * m, p.getY() * m);
}
 
//absztrakt osztály
class Sikidom
{
public:
    virtual double ker() = 0;       //tisztán virtuális
    virtual double ter() = 0;
    virtual void kiir()         //virtuális
    {
        cout << "Kerulet: " << ker() << endl;
        cout << "Terulet: " << ter() << endl;
    }
    virtual void mozgat(double x, double y) = 0;
};
 
class Kor : public Sikidom
{
public:
    Kor(double x, double y, double r) :O(x, y), r(r)
    {
        if (r <= 0) this->r = 1;
    }
    Kor(const p2D &p, double r) :O(p), r(r)
    {
        if (r <= 0) this->r = 1;
    }
    // set/get r,x,y    HF
    void kiir()
    {
        cout << endl << "Kor" << endl << "R:" << r << " O:" << O;
        Sikidom::kiir();
    }
    // Örökölt tisztán virtuális függvények Sikidom-tól
    // ki kell fejteni
    virtual double ker() override
    {
        return 2 * r * M_PI;
    }
    virtual double ter() override
    {
        return r * r * M_PI;
    }
    virtual void mozgat(double x, double y) override
    {   //friend
        O.x = x;
        O.y = y;
    }
private:
    double r;
    p2D O;      //p2D beépítésre kerül
};
 
class Negyzet : public Sikidom
{
public:
    Negyzet(p2D & p, double a) :O(p), a(a) {}
    double getA() { return a; }
    void setA(double a) { this->a = a; }
    void kiir()
    {
        cout << endl << "Negyzet" << endl << "a:" << a << " O:" << O;
        Sikidom::kiir();
    }
    virtual double ker() override { return 4 * a; }
    virtual double ter() override { return a * a; }
    virtual void mozgat(double x, double y) override
    {
        O.setX(x);
        O.setY(y);
    }
private:
    double a;
    p2D &O;     //p2D-re csak hivatkozunk
};
 
class Teglalap : public p2D, public Sikidom //p2D öröklés
{
public:
    Teglalap(double x, double y, double a, double b) :p2D(x, y), a(a), b(b) {}
    Teglalap(p2D p, double a, double b) :p2D(p), a(a), b(b) {}
    void kiir()
    {
        cout << endl << "Teglalap" << endl << "a:" << a << " b:"
            << b << " O:" << p2D::x << ";" << p2D::y << endl;
        Sikidom::kiir();
    }
    virtual double ker() override { return 2 * (a + b); }
    virtual double ter() override { return a * b; }
    virtual void mozgat(double x, double y) override
    {
        this->x = x;
        p2D::y = y;
    }
private:
    double a, b;
};
 
// Absztrakt osztály felhasználása
void Origoba(Sikidom & s)
{
    s.mozgat(0, 0);
    s.kiir();
}
 
int main()
{
    //Pont osztály
    p2D p1(10, 20);
    p2D p2(20, 20);
    p1.mozgat(2, 5);
    cout << p1 << p1.tav(p2) << endl;
 
    //Ismétlés
    //belső fgv
    p2 = p1 * 3;    
    p2 = p1.operator*(3);
 
    //külső fgv.
    p2 = 3 * p1;
    p2 = operator*(3, p1);
 
    //saját magát megváltoztató fgv.
    p1 *= 2;
    cout << p1;
 
    //Kompozició
    Kor k1(p2, 10);
    k1.kiir();
    p2.mozgat(2, 5);
    k1.kiir();
    k1.mozgat(-10, 40);
    k1.kiir();
 
    //Aggregáció
    Negyzet n1(p2, 10);
    n1.kiir();
    p2.mozgat(10, 25);
    n1.kiir();
    n1.mozgat(2, 4);
    n1.kiir();
    cout << p2;
 
    //Öröklés
    Teglalap t1(p1, 10, 20);
    t1.kiir();
    p1.mozgat(1, 1);
    t1.kiir();
    t1.mozgat(3, 3);
    t1.kiir();
    cout << (p2D(t1));        //ős
    t1.p2D::mozgat(5, 8);   //ősben található függvény előhívása
    t1.kiir();
    p2D p3 = t1;
    cout << p3 << endl;
    cout << t1 << endl;     //ez is az ős p2D-t hívja meg
 
    //Virtuális metódusok használata
    Origoba(k1);
    k1.kiir();
 
    Origoba(n1);
    n1.kiir();
 
    Origoba(t1);
    t1.kiir();
}
                	
		

#include <iostream>
#include <fstream>
#include <string>

// STL tárolók
#include <vector>
#include <list>
// STL iterátor
#include <iterator>
// STL algoritmus
#include <algorithm>
#include <numeric>

using namespace std;

// Double számot kiíró függvény
void Kiir(double d) { cout << d << endl; }

// Fahreinheit-be átszámoló hagyományos függvény
void CtoF(double& t) { t = t * 9 / 5 + 32; }

// Celsius-ba átszámoló fgv. objektum
class FtoC {
public:
    // operátor ()-t kell elkészíteni!
    void operator()(double& t) { t = (t -32) * 5 / 9; }
};

class Szemely {
private:
    string vnev, knev;
    list<string> tel;
public:
    Szemely(string vnev, string knev, string t = "") : vnev(vnev), knev(knev) {
        if (t != "") tel.push_back(t);
    }
    string getvnev() const { return vnev; }
    string getknev() const { return knev; }
    void setvnev(string s)  { vnev = s; }
    void setknev(string s)  { knev = s; }
    void kiir(bool knevszerint = false) {
        if(knevszerint)  cout << knev << ", " << vnev << " ";
        else cout << vnev << " " << knev << " "; 
        copy(tel.begin(), tel.end(), ostream_iterator<string>(cout, " | "));
        cout << endl;
    }
    void addTel(string t) {
        tel.push_back(t);
        tel.sort();
    }
    bool operator==(const Szemely& b) { // find művelethez
        return vnev == b.vnev && knev == b.knev;
    }
    bool operator<(const Szemely & b) { // sort művelethez
        return vnev < b.vnev;
    }
};

int main()
{
    vector<double> adatok;  // vektor adatok számára / nincs megadva a kezdőmérete

    ifstream fbe("adatok.txt"); // soronként számokat tartalmazó szövegfájl
    if (!fbe.is_open())
    {
        cout << "Nincs meg az adatok.txt fajl!";
        return -1;
    }

    while (!fbe.eof()) {
        string sor;
        getline(fbe, sor);
        if (sor.empty()) continue;
        adatok.push_back(stod(sor)); // adat vektor végéhez adása
    }
    fbe.close();

    vector<double>::iterator it;    // iterátor a vektor bejárásához
    for (it = adatok.begin(); it != end(adatok); it++) // az elejétőõl a végéig
        cout << *it << endl;        // *it az iterátor által mutatott adat


    //it = min(adatok.begin(), adatok.end());           // ez csak két elemet hasonlít össze pl. min(10,42)
    //cout << "Min:" << *it << endl;                    
    it = min_element(begin(adatok), end(adatok));       // tartományban szereplő adatokra min_element kell
    cout << "Min:" << *it << endl;
    it = max_element(begin(adatok), end(adatok));
    cout << "Max:" << *it << endl;

    // algoritmusok testre szabása, fgv. pointerrel, fgv. objektummal, vagy lambda kifejezéssel
    for_each(adatok.begin(), adatok.end(), CtoF );   // fgv. pointerrel
    for_each(adatok.begin(), adatok.end(), Kiir );   // nem kell a zárójel!
    for_each(adatok.begin(), adatok.end(), FtoC());  // fgv. objektum, kell a () operátor
    for_each(adatok.begin(), adatok.end(), Kiir);

    double szum = 0;    // külső változó az összeg tárolására
    for_each(begin(adatok), end(adatok), 
             [&szum](double d) { szum += d; });     // lambda kifejezés használta, &szum átadása, mert külső és megváltoztatható
    cout << "Az osszeg: " << szum << endl;

    szum = accumulate(adatok.begin(), adatok.end(), 0.0); // összegző algoritmus bemutatása
    cout << "Az osszeg: " << szum << endl;

    // Tároló elemeszámának és kapacításáanak bemutatása
    cout << "Elemszam: " << adatok.size() << " Kapacitas: " << adatok.capacity() << endl;
    adatok.push_back(12);     // plusz elemek hozzáadása ...
    adatok.push_back(12);     // ha kinövi a kapacitást, akkor elköltözik
    cout << "Elemszam: " << adatok.size() << " Kapacitas: " << adatok.capacity() << endl;

    // elemek rendezése, nincs sort tagfüggvénye a vectornak, de van sort algoritmus
    sort(adatok.begin(), adatok.end());
    for_each(adatok.begin(), adatok.end(), Kiir );
    // rendezés csökkenő sorrendbe beépített functional használatával
    sort(adatok.begin(), adatok.end(), greater<double>());
    for_each(adatok.begin(), adatok.end(), Kiir);


    // Személy létrehozása és plusz telefonszám hozzáadása
    Szemely szemely("Kiss", "Istvan", "06/70 568-4589");
    szemely.addTel("06/70 478-7857");

    // Telefonkönyv
    list<Szemely> szemelyek;
    szemelyek.push_back(szemely);
    szemelyek.push_back(Szemely("Nagy", "Bianka", "06/30 457-4789"));
    szemelyek.back().addTel("06/20 478-7894"); // az utolsó elem referenciáját adja vissza a back()
	szemelyek.emplace_back("Meszaros", "Gabor", "06/20 478-6912"); // példányosítás + hozzáadás 
    szemelyek.insert(next(szemelyek.begin(),1),			 // beszúrás az első után, next() léptet
		Szemely("Kovacs", "Kata", "06/20 145-4789")); 

    // szemely keresése a listában
    list<Szemely>::iterator szit;
    szemely = Szemely("Kovacs", "Kata");
    szit = find(szemelyek.begin(), szemelyek.end(), szemely);  // szemely megkeresése == operátor alapján
    if (szit != szemelyek.end()) // ha megtalálta
        szit->addTel("06/70 457-7895");
		
	// szemely keresése név alapján
    string vnev = "Meszaros", knev = "Gabor";
    szit = find_if(szemelyek.begin(), szemelyek.end(), 
        [vnev, knev](const Szemely& sz)->bool {return sz.getvnev() == vnev && sz.getknev() == knev; });
    if (szit != szemelyek.end()) // ha megtalálta
        szit->addTel("06/70 237-1452");

    cout << "\nTelefonkonyv:" << endl;
    // sorba rendezés a < operátor alapján
    szemelyek.sort();
    for (szit = szemelyek.begin(); szit != szemelyek.end(); szit++) 
        szit->kiir();
 
    cout << "\nKeresztnev szerint:" << endl;
    // sorba rendezés lambda kifejezés alapján, keresztnév szerint
    szemelyek.sort(
        [](const Szemely& a, const Szemely& b)->bool { return a.getknev() < b.getknev(); });
    for (szit = szemelyek.begin(); szit != szemelyek.end(); szit++)
        szit->kiir(true);

    // átalakítás
    vector<string> nevek(szemelyek.size());
    transform(szemelyek.begin(), szemelyek.end(), nevek.begin(),
    	[](const Szemely& a)->string { return a.getvnev() + " " + a.getknev(); });
    sort(nevek.begin(), nevek.end());
    cout << "\nNevek:" << endl;
    for (auto nev : nevek) cout << nev << endl;

}