v0

Makefile

+CCX = g++
+CXXFLAGS = -Wall -Wdeprecated -pedantic -DMEMTRACE -g 
+
+HEADERS := $(wildcard *.h) $(wildcard *.hpp)
+SOURCES := $(wildcard *.cpp)
+OBJECTS := $(SOURCES:%.cpp=%.o)
+
+main: $(OBJECTS)
+	$(CCX) $^ -g -o $@ -ldl
+	
+%.o: %.c $(HEADERS)
+	$(CCX) $(CXXFLAGS) -c $<
+	
+clean:
+	rm -rf $(OBJECTS) main
\ No newline at end of file

README.md

+# Állapotgép 2.0
+
+A állapotgépek (véges automaták) kézenfekvő megvalósítása a táblázatos megvalósítás, melynek lényege, hogy a pillanatnyi állapottól és az aktuális inputtól függően elővesszük egy táblázatból az új állapotot és az állapotátmenethez tartozó tevékenységet megvalósító függvény címét, amit végrehajtunk. Ezzel állapotgépünk algoritmusa így nézhet ki:
+```
+  while (van_input) {
+     új_állapot = állapot_tábla[akt_állapot][input]
+	 tevékenység = [akt_állapot][input]
+	 tevélenység_vegrehajtása
+	 akt_állapot = új_allapot
+  }
+```
+Így egy konkrét feladat (pl. ly számláló) implementálása csak a két táblázat megfelelő kitöltéséből áll, feltételezve, hogy mind az állapotokat, mind az inputot olyan módon kódoljuk, hogy azzal az adott nyelven lehet táblázatot (tárolót) indexelni. C nyelven az integrál típussal lehet indexelni. C++-ban már más a helyzet (ld. asszociatív tárolók). 
+A táblázatok (lehet összevont táblázat is) kitöltését segítheti valamilyen generátor, ekkor annak mérete nem nagyon érdekes, de lehet, hogy kézzel töltjük ki, ekkor érdemes a táblázat méretét csökkenteni. A legkézenfekvőbb csökkentési lehetőség, az állapotok összevonása és az inputot csoportokra bontása (ld. ly számláló példa).
+
+Az alábbiakban bemutatjuk a fenti, táblázatos módszer egy általánosított megvalósítását C++-ban. A feladat ennek megértése és felhasználásával két további állapotgéppel leírható probléma megoldása.
+
+## Állapotgép ősosztály
+
+Az újrafelhasználáshoz készítettünk egy `Allapotgep` ősosztályt(_allapotgep.hpp_), ami a következő template paraméterekkel rendelkezik:
+```c++
+template <
+    typename All, //az állapotokat kódoló típus
+    typename Inp, //az input csoportokat kódoló típus 
+    typename T    //az inpu típusa
+>
+class Allapotgep {
+    //...
+};
+```
+
+Az állapotgép a genetika szorgalmihoz viszonyítva a template paraméterezés mellett az alábbiakban tér el:
+ * minden állapotátmenetkor végrehajt egy akciót;
+ * tárolja a bevezetőben említett 2D táblázatban a következő állapotot és az akciót.
+ 
+A következő állapot és az akció tárolására heterogén kollekcióként tárolt objektumokat használunk, melynek alaposztálya a Nop osztály. Ez az osztály nem csinál semmit az _akcio_ során, csak eltárolja a következő állapotot. 
+
+```c++
+struct Nop {
+    /// következő állapot
+    All kov_allapot;
+    Nop(All kov_all) :kov_allapot(kov_all) {}
+
+    /// ha az állapotgép ebbe az állapotba ér, meghívja ezt a függvényt
+    /// @param ch - erre az input értékre léptünk ide
+    virtual void akcio(T ch) { }
+    virtual ~Nop() {}
+};
+```
+
+A 2D táblázathoz egy olyan osztályt definiáltunk, ami az All és Imp sablonparaméterként megadott típusokkal indexelhető, és törli a tárol elemeket, ha elérkezett az idő.
+```c++
+    struct AllTabla : public std::map<All, std::map<Inp, Nop*> > {
+        ~AllTabla() {
+            typename AllTabla::iterator i1 = this->begin();
+            while (i1 != this->end()) {
+                typename std::map<Inp, Nop*>::iterator i2 = i1->second.begin();
+                while (i2 != i1->second.end()) {
+                    delete i2->second;
+                    ++i2;
+                }
+                ++i1;
+            }
+        };
+    };
+```
+Az `Allapotgep` osztály továbbá a következő függvényekkel rendelkezik:
+```c++
+/// beállítja a kezdő állapotot és az állapottábla referenciáját
+Allapotgep(All kezdo, AllTabla& tab) : akt_allapot(kezdo), tab(tab) {}
+/// az input átalakítását végző segédfüggvény
+/// @param ch a kapott input
+/// @return az inputnak megfelelő Inp-ben kódolt érték
+virtual Inp input(T ch) const = 0;
+/// Input feldolgozása
+/// @param ch aktuális input
+/// @return az átmenet után melyik állapotba értünk
+All operator()(T ch) {
+    Inp akt_input = input(ch);
+    tab[akt_allapot][akt_input]->akcio(ch);
+    akt_allapot = tab[akt_allapot][akt_input]->kov_allapot;
+    return akt_allapot;
+}
+```
+Nézd meg az osztályt tartalmazó _allapotgep.hpp_ fejlécfájlt!
+
+## Lyszamlalo
+Az állapotgép használatát egy egyszerű, ismerős feladattal mutatom be: Számoljuk egy szövegben az ly-ok számát! Az állapotgép így *char* bemenetet kap. Az állapotok kódolására az LyAllapot típust, az input csoportok kódolására pedig az LyInput típust vettem fel. Az számláláshoz pedig felvettem egy int számlálót (sz).
+
+```c++
+//https://en.cppreference.com/w/cpp/language/enum#Scoped_enumerations
+enum class LyAllapot { alap, l_jott, ll_jott};
+enum class LyInput   { l, y, egyeb };
+class Lyszaml : public Allapotgep<LyAllapot, LyInput, char> {
+    Allapotgep::AllTabla tab;
+    int sz = 0;
+    //...
+}; //lyszamlalo.hpp
+```
+_Megjegyzés: a template paraméterek miatt nyugodtan használhattunk volna az enum-ok vagy akár a char helyett egy szimpla osztályt is. Így akár komplikáltabb logika is beépíthető. _
+
+Az egyes állapotokhoz kapcsolódó akciókat a következő módon definiáljuk: 
+
+```c++
+    struct Novel1 : public Nop {
+        Lyszaml& allapotgep;   // állapotgép referenciája, hogy elérje a számlálót
+        Novel1(LyAllapot all, Lyszaml& allapotgep) : Nop(all), allapotgep(allapotgep) {}
+        void akcio(char ch) { allapotgep.sz += 1; }
+    };
+    struct Novel2 : public Nop {
+        Lyszaml& allapotgep;
+        Novel2(LyAllapot all, Lyszaml& allapotgep) : Nop(all), allapotgep(allapotgep) {}
+        void akcio(char ch) { allapotgep.sz += 2; }
+    };
+	//lyszamlalo.hpp
+```
+
+Az átmeneteket pedig a következő kódrészletben adtuk meg. A táblázatból kiderül, hogy két esetben kell növelni a számlálót:
+ * jelenlegi állapot: *l_jott* és utána *y*-t kaptunk: +1-el növeljük, és utána *alap* állapotba lépünk
+ * jelenlegi állapot: *ll_jott* és utána *y*-t kaptunk: +2-el növeljük, és utána *alap* állapotba lépünk
+
+Minden más esetben nem kell tennünk semmit, csak az állapotokat kell nyilvántartani. 
+```c++
+Lyszaml::Lyszaml() : Allapotgep(LyAllapot::alap, tab), sz(0) {
+    tab[LyAllapot::alap] =   {{LyInput::l, new Nop(LyAllapot::l_jott)},
+                              {LyInput::y, new Nop(LyAllapot::l_jott)},
+                              {LyInput::egyeb, new Nop(LyAllapot::alap)}};
+    tab[LyAllapot::l_jott] = {{LyInput::l, new Nop(LyAllapot::ll_jott)},
+                              {LyInput::y, new Novel1(LyAllapot::alap, *this)},
+                              {LyInput::egyeb, new Nop(LyAllapot::alap)}};
+    tab[LyAllapot::ll_jott]= {{LyInput::l, new Nop(LyAllapot::ll_jott)},
+                              {LyInput::y, new Novel2(LyAllapot::alap, *this)},
+                              {LyInput::egyeb, new Nop(LyAllapot::alap)}};
+} //lyszamlalo.cpp
+```
+
+A bemenetet input csoportokká alakító függvény `Lyszamlalo` esetén magyarázatra nem szorul:
+```c++
+LyInput input(char ch) const {
+    if (ch == 'l') return LyInput::l;
+    if (ch == 'y') return LyInput::y;
+    return LyInput::egyeb;
+} //lyszamlalo.hpp
+```
+
+_Megjegyzés: használhattunk volna enum helyett olyan osztályt, ami az érkezett karaktertől függően úgy viselkedik, mint az _LyInput_
+
+Az `Lyszamlalo` **get()** függvénye visszaadja a megtalált _ly_-ok számát. Továbbá bevezetésre került egy segéd **str()** függvény is. Nézd meg a **runtests** statikus függvényhez tartozó teszteseteket!
+
+## Feladatok
+### Kommentezés
+A mintapélda lapján hozz létre egy `Komment` osztályt, ami a bemenetére érkező szabályos C programból kiszűri a /* ... */ alakú kommenteket! Feltételezzük, hogy szövegkonstansban nem szerepel "/\*", ill. "\*/" karaktersorozat. A megszűrt, komment nélküli programot az osztály **std::string get()** tagfüggvényével lehet lekérdezni. 
+
+Nézd meg a _main.cpp_-ben lévő teszteket, állítsd az _ELKESZULT_ makrót 1-re és próbáld megoldani a feladatot. A megoldás során a *komment.hpp* és *komment.cpp* fájlokban dolgozz!
+
+### Split
+Hozz létre egy `Split` osztályt ami a bemenetére érkező karaktereket úgy dolgozza fel, hogy a konstruktorában megadott karakter mentén feldarabolja és **get()** függvénye egy `std::vector<std::string>` példányt ad vissza a szétválasztott elemekkel! 
+
+Nézd meg a _main.cpp_-ben lévő teszteket, állítsd az _ELKESZULT_ makrót 2-re és próbáld megoldani a feladatot. A megoldás során a *split.hpp* és *split.cpp* fájlokban dolgozz!
+
+## Beadás
+Beadandó a *komment.hpp*, *komment.cpp*, *split.hpp* és *split.cpp* fájlok. 
\ No newline at end of file

allapotgep.hpp

+/**
+*    @file allapotgep.hpp
+*    Nem kell beadni!
+*/
+#ifndef ALLAPOTGEP_HPP
+#define ALLAPOTGEP_HPP
+
+#include <map>
+#include "memtrace.h"
+
+/**
+ * Allapotgep ősosztály
+ * @tparam All az állapotokat kódoló típus
+ * @tparam Inp az input csoportokat kódoló típus
+ * @tparam T az input típusa
+ */
+template <typename All, typename Inp, typename T>
+class Allapotgep {
+public:
+    /**
+     * Nop osztály
+     * Az állapotátmenetekhez tartozó következő állapotot tárolja,
+     * valamint az állapot során meghívandó akciót
+     */
+    struct Nop {
+        /// következő állapot
+        All kov_allapot;
+        Nop(All kov_all) :kov_allapot(kov_all) {}
+
+        /// ha az állapotgép ebbe az állapotba ér, meghívja ezt a függvényt
+        /// @param ch - erre az input értékre léptünk ide
+        virtual void akcio(T ch) {}
+        virtual ~Nop() {}
+    };
+    /**
+     * Az állapotátmenetek kódolását megkönnyítő Állapot/Input tábla
+     */
+    struct AllTabla : public std::map<All, std::map<Inp, Nop*> > {
+        ~AllTabla() {
+            typename AllTabla::iterator i1 = this->begin();
+            while (i1 != this->end()) {
+                typename std::map<Inp, Nop*>::iterator i2 = i1->second.begin();
+                while (i2 != i1->second.end()) {
+                    delete i2->second;
+                    ++i2;
+                }
+                ++i1;
+            }
+        };
+    };
+private:
+    /// éppen melyik állapotban vagyunk
+    All akt_allapot;
+    /// referencia az állapotátmenet táblára
+    AllTabla& tab;
+public:
+    /// beállítja a kezdő állapotot és az állapottábla referenciáját
+    Allapotgep(All kezdo, AllTabla& tab) : akt_allapot(kezdo), tab(tab) {}
+    /// az input átalakitását végző segédfüggvény
+    /// @param ch a kapott input
+    /// @return az inputnak megfelelő Inp-ben kódolt érték
+    virtual Inp input(T ch) const = 0;
+    /// Input feldolgozása
+    /// @param ch aktuális input
+    /// @return az átmenet után melyik állapotba értünk
+    All operator()(T ch) {
+        Inp akt_input = input(ch);
+        tab[akt_allapot][akt_input]->akcio(ch);
+        akt_allapot = tab[akt_allapot][akt_input]->kov_allapot;
+        return akt_allapot;
+    }
+    virtual ~Allapotgep() {}
+};
+
+#endif

allapotgep2.cbp

+<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
+<CodeBlocks_project_file>
+	<FileVersion major="1" minor="6" />
+	<Project>
+		<Option title="cipher" />
+		<Option pch_mode="2" />
+		<Option compiler="gcc" />
+		<Build>
+			<Target title="Debug">
+				<Option output="bin/Debug/cipher" prefix_auto="1" extension_auto="1" />
+				<Option object_output="obj/Debug/" />
+				<Option type="1" />
+				<Option compiler="gcc" />
+				<Compiler>
+					<Add option="-g" />
+					<Add option="-DMEMTRACE" />
+				</Compiler>
+			</Target>
+			<Target title="Release">
+				<Option output="bin/Release/cipher" prefix_auto="1" extension_auto="1" />
+				<Option object_output="obj/Release/" />
+				<Option type="1" />
+				<Option compiler="gcc" />
+				<Compiler>
+					<Add option="-O2" />
+				</Compiler>
+				<Linker>
+					<Add option="-s" />
+				</Linker>
+			</Target>
+		</Build>
+		<Compiler>
+			<Add option="-pedantic" />
+			<Add option="-Wall" />
+			<Add option="-std=c++11" />
+		</Compiler>
+		<Unit filename="allapotgep.hpp" />
+		<Unit filename="komment.cpp" />
+		<Unit filename="komment.hpp" />
+		<Unit filename="lyszamlalo.cpp" />
+		<Unit filename="lyszamlalo.hpp" />
+		<Unit filename="split.cpp" />
+		<Unit filename="split.hpp" />
+		<Unit filename="main.cpp" />
+		<Unit filename="gtest_lite.h" />
+		<Unit filename="memtrace.cpp" />
+		<Unit filename="memtrace.h" />
+		<Extensions>
+			<code_completion />
+			<envvars />
+			<debugger />
+		</Extensions>
+	</Project>
+</CodeBlocks_project_file>

komment.cpp

+/**
+*    @file komment.cpp 
+*    Be kell adni!
+*    Ide kerül a Komment osztály megvalósított függvényei
+*/
+
+#include <string>
+#include "memtrace.h"
+#include "komment.hpp"
+

komment.hpp

+/**
+*    @file komment.hpp 
+*    Be kell adni!
+*    Ide kerül a Komment osztály deklarációja
+*/
+
+#ifndef KOMMENT_HPP
+#define KOMMENT_HPP
+
+#include <string>  //használandó az std::string
+#include "memtrace.h"
+#include "allapotgep.hpp"
+
+class Komment {
+};
+
+#endif
\ No newline at end of file

lyszamlalo.cpp

+/**
+*    @file lyszamlalo.cpp
+*    Nem kell beadni! Példa megoldás
+*/
+
+#include <string>
+#include "memtrace.h"
+#include "lyszamlalo.hpp"
+#include "gtest_lite.h"
+
+/// Default konstruktor
+/// A kezdő állapot(alap) és az állapotátmenet tábla megadása és beállítása
+Lyszaml::Lyszaml() : Allapotgep(LyAllapot::alap, tab), sz(0) {
+    tab[LyAllapot::alap] =   {{LyInput::l, new Nop(LyAllapot::l_jott)},
+                              {LyInput::y, new Nop(LyAllapot::l_jott)},
+                              {LyInput::egyeb, new Nop(LyAllapot::alap)}};
+    tab[LyAllapot::l_jott] = {{LyInput::l, new Nop(LyAllapot::ll_jott)},
+                              {LyInput::y, new Novel1(LyAllapot::alap, *this)},
+                              {LyInput::egyeb, new Nop(LyAllapot::alap)}};
+    tab[LyAllapot::ll_jott]= {{LyInput::l, new Nop(LyAllapot::ll_jott)},
+                              {LyInput::y, new Novel2(LyAllapot::alap, *this)},
+                              {LyInput::egyeb, new Nop(LyAllapot::alap)}};
+}
+
+/// példa tesztek a demó programhoz
+void Lyszaml::runtests() {
+    TEST(Lyszaml Test, alma) {
+            Lyszaml szaml;
+            szaml.str("alma");
+            EXPECT_EQ(szaml.get(), 0);
+        } END
+
+    TEST(Lyszaml Test, bagoly) {
+            Lyszaml szaml;
+            szaml.str("bagoly");
+            EXPECT_EQ(szaml.get(), 1);
+        } END
+
+    TEST(Lyszaml Test, gally) {
+            Lyszaml szaml;
+            szaml.str("gally");
+            EXPECT_EQ(szaml.get(), 2);
+        } END
+}

lyszamlalo.hpp

+/**
+*    @file lyszamlalo.hpp
+*    Nem kell beadni! Példa megoldás
+*/
+
+#ifndef LYSZAML_HPP
+#define LYSZAML_HPP
+
+#include <string>
+#include "memtrace.h"
+#include "allapotgep.hpp"
+
+/**
+ * Állapotok és input csoportok kódolása
+ * Ún. scoped enum típust használunk (az enum nem osztály)
+ *
+ * https://en.cppreference.com/w/cpp/language/enum#Scoped_enumerations
+ * hogy több enum esetén lehessen azonos név alatt elem
+ */
+enum class LyAllapot { alap, l_jott, ll_jott};
+enum class LyInput   { l, y, egyeb };
+
+class Lyszaml : public Allapotgep<LyAllapot, LyInput, char> {
+    Allapotgep::AllTabla tab;
+    int sz = 0;     // számláló
+
+    /// Akciók és állapotátmenetek megvalósítása
+    struct Novel1 : public Nop {
+        Lyszaml& allapotgep;   // állapotgép referenciája, hogy elérje a számlálót
+        Novel1(LyAllapot all, Lyszaml& allapotgep) : Nop(all), allapotgep(allapotgep) {}
+        void akcio(char ch) { allapotgep.sz += 1; }
+    };
+    struct Novel2 : public Nop {
+        Lyszaml& allapotgep;
+        Novel2(LyAllapot all, Lyszaml& allapotgep) : Nop(all), allapotgep(allapotgep) {}
+        void akcio(char ch) { allapotgep.sz += 2; }
+    };
+public:
+    Lyszaml();
+    LyInput input(char ch) const {
+        if (ch == 'l') return LyInput::l;
+        if (ch == 'y') return LyInput::y;
+        return LyInput::egyeb;
+    }
+    int get() const {
+        return sz;
+    }
+    void str(std::string str) {
+        for(char c : str)
+            (*this)(c);
+    }
+    static void runtests();
+};
+
+#endif

main.cpp

+/**
+*    @file main.cpp 
+*    Nem kell beadni!
+*/
+#include <iostream>
+#include <string>
+#include "memtrace.h"
+#include "gtest_lite.h"
+#include "allapotgep.hpp"
+#include "lyszamlalo.hpp"
+#include "komment.hpp"
+#include "split.hpp"
+
+/*
+ELKESZULT makro
+    == 0 - a demó program fut le az Lyszaml-val
+    == 1 - kommentes tesztek
+    == 2 - komment és split állapotgépes tesztek   */
+#define ELKESZULT 0
+#if ELKESZULT == 0
+
+int main() {
+    Lyszaml::runtests();
+
+    std::cout << "Input olvasása EOF-ig:" << std::endl;
+    Lyszaml ly;
+    char ch;
+    while (std::cin >> std::noskipws >> ch)
+        ly(ch);
+    std::cout << std::endl << ly.get() << std::endl;
+
+    return 0;
+}
+#elif ELKESZULT > 0
+
+template <typename T>
+void runstr(T& allapotgep, std::string str) {
+    for(char c : str)
+        allapotgep(c);
+}
+
+int main() {
+    GTINIT(std::cin);
+#if ELKESZULT > 0
+    TEST(Komment, nincs) {
+        Komment k;
+        runstr(k, "/alma*/ **\\/valami");
+        EXPECT_STREQ("/alma*/ **\\/valami", k.get().c_str());
+        runstr(k, "c++");
+        EXPECT_STREQ("/alma*/ **\\/valamic++", k.get().c_str());
+    } END
+    TEST(Komment, egyszeru) {
+        Komment k;
+        runstr(k, "akarmi/*geza*/valami");
+        EXPECT_STREQ("akarmivalami", k.get().c_str());
+        runstr(k, "c++");
+        EXPECT_STREQ("akarmivalamic++", k.get().c_str());
+    } END
+    TEST(Komment, latin) {
+        Komment k;
+        runstr(k, "/*c++**/*Ad maiorem Dei gloriam/**:)(*/ Alea iacta est /**/Et tu mi fili, Brute?");
+        EXPECT_STREQ("*Ad maiorem Dei gloriam Alea iacta est Et tu mi fili, Brute?", k.get().c_str());
+    } END
+#endif
+
+#if ELKESZULT > 1
+    TEST(Split, gyumolcsok) {
+        Split split(';');
+        runstr(split, "alma;banan;korte;");
+        EXPECT_STREQ("alma",  split.get()[0].c_str());
+        EXPECT_STREQ("banan", split.get()[1].c_str());
+        EXPECT_STREQ("korte", split.get()[2].c_str());
+        EXPECT_EQ(3u, split.get().size());
+        runstr(split, "szilva");
+        EXPECT_EQ(3u, split.get().size());
+        split(';');
+        EXPECT_STREQ("szilva", split.get()[3].c_str());
+    } END
+
+    TEST(Split, gyumolcsok2.0) {
+        Split split('/');
+        runstr(split, "alma//banan///korte/");
+        EXPECT_STREQ("alma",  split.get()[0].c_str());
+        EXPECT_STREQ("banan", split.get()[1].c_str());
+        EXPECT_STREQ("korte", split.get()[2].c_str());
+    } END
+#endif
+
+    GTEND(std::cerr);
+    return 0;
+}
+#endif
\ No newline at end of file

memtrace.h

+/*********************************
+Memoriaszivargas-detektor
+Keszitette: Peregi Tamas, BME IIT, 2011
+            petamas@iit.bme.hu
+Kanari:     Szeberenyi Imre, 2013.,
+VS 2012:    Szeberényi Imre, 2015.,
+mem_dump:   2016.
+inclue-ok:  2017., 2018. 2019.
+*********************************/
+
+#ifndef MEMTRACE_H
+#define MEMTRACE_H
+
+#if defined(MEMTRACE)
+
+/*ha definiálva van, akkor a hibakat ebbe a fajlba írja, egyébkent stderr-re*/
+/*#define MEMTRACE_ERRFILE MEMTRACE.ERR*/
+
+/*ha definialva van, akkor futas kozben lancolt listat epit. Javasolt a hasznalata*/
+#define MEMTRACE_TO_MEMORY
+
+/*ha definialva van, akkor futas kozben fajlba irja a foglalasokat*/
+/*ekkor nincs ellenorzes, csak naplozas*/
+/*#define MEMTRACE_TO_FILE*/
+
+/*ha definialva van, akkor a megallaskor automatikus riport keszul */
+#define MEMTRACE_AUTO
+
+/*ha definialva van, akkor malloc()/calloc()/realloc()/free() kovetve lesz*/
+#define MEMTRACE_C
+
+#ifdef MEMTRACE_C
+	/*ha definialva van, akkor free(NULL) nem okoz hibat*/
+	#define ALLOW_FREE_NULL
+#endif
+
+#ifdef __cplusplus
+	/*ha definialva van, akkor new/delete/new[]/delete[] kovetve lesz*/
+	#define MEMTRACE_CPP
+#endif
+
+#if defined(__cplusplus) && defined(MEMTRACE_TO_MEMORY)
+	/*ha definialva van, akkor atexit helyett objektumot hasznal*/
+	/*ajanlott bekapcsolni*/
+	#define USE_ATEXIT_OBJECT
+#endif
+
+/******************************************/
+/* INNEN NE MODOSITSD                     */
+/******************************************/
+#ifdef NO_MEMTRACE_TO_FILE
+	#undef MEMTRACE_TO_FILE
+#endif
+
+#ifdef NO_MEMTRACE_TO_MEMORY
+	#undef MEMTRACE_TO_MEMORY
+#endif
+
+#ifndef MEMTRACE_AUTO
+    #undef USE_ATEXIT_OBJECT
+#endif
+
+#ifdef __cplusplus
+	#define START_NAMESPACE namespace memtrace {
+	#define END_NAMESPACE } /*namespace*/
+	#define TRACEC(func) memtrace::func
+	#include <new>
+#else
+	#define START_NAMESPACE
+	#define END_NAMESPACE
+	#define TRACEC(func) func
+#endif
+
+// THROW deklaráció változatai
+#if defined(_MSC_VER)
+  // VS rosszul kezeli az __cplusplus makrot
+  #if _MSC_VER < 1900
+    // * nem biztos, hogy jó így *
+	#define THROW_BADALLOC
+	#define THROW_NOTHING
+  #else
+    // C++11 vagy újabb
+	#define THROW_BADALLOC noexcept(false)
+	#define THROW_NOTHING noexcept
+  #endif
+#else
+  #if __cplusplus < 201103L
+	// C++2003 vagy régebbi
+	#define THROW_BADALLOC throw (std::bad_alloc)
+	#define THROW_NOTHING throw ()
+  #else
+    // C++11 vagy újabb
+	#define THROW_BADALLOC noexcept(false)
+	#define THROW_NOTHING noexcept
+  #endif
+#endif
+
+START_NAMESPACE
+	int allocated_blocks();
+END_NAMESPACE
+
+#if defined(MEMTRACE_TO_MEMORY)
+START_NAMESPACE
+        int mem_check(void);
+END_NAMESPACE
+#endif
+
+#if defined(MEMTRACE_TO_MEMORY) && defined(USE_ATEXIT_OBJECT)
+#include <cstdio>
+START_NAMESPACE
+	class atexit_class {
+		private:
+			static int counter;
+			static int err;
+		public:
+			atexit_class() {
+#if defined(CPORTA) && !defined(CPORTA_NOSETBUF)
+			    if (counter == 0) {
+                        setbuf(stdout, 0);
+                        setbuf(stderr, 0);
+			    }
+#endif
+			counter++;
+			}
+
+			int check() {
+				if(--counter == 0)
+					err = mem_check();
+                return err;
+			}
+
+			~atexit_class() {
+			    check();
+            }
+	};
+
+static atexit_class atexit_obj;
+
+END_NAMESPACE
+#endif/*MEMTRACE_TO_MEMORY && USE_ATEXIT_OBJECT*/
+
+/*Innentol csak a "normal" include eseten kell, kulonben osszezavarja a mukodest*/
+#ifndef FROM_MEMTRACE_CPP
+#include <stdlib.h>
+#ifdef __cplusplus
+	#include <iostream>
+/* ide gyűjtjük a nemtrace-vel összeakadó headereket, hogy előbb legyenek */
+
+	#include <fstream>  // VS 2013 headerjében van deleted definició
+	#include <sstream>
+	#include <vector>
+	#include <list>
+	#include <map>
+	#include <algorithm>
+	#include <functional>
+	#include <memory>
+	#include <iomanip>
+	#include <locale>
+	#include <typeinfo>
+	#include <ostream>
+	#include <stdexcept>
+#endif
+#ifdef MEMTRACE_CPP
+	namespace std {
+		typedef void (*new_handler)();
+}
+#endif
+
+#ifdef MEMTRACE_C
+START_NAMESPACE
+	#undef malloc
+	#define malloc(size) TRACEC(traced_malloc)(size,#size,__LINE__,__FILE__)
+	void * traced_malloc(size_t size, const char *size_txt, int line, const char * file);
+
+	#undef calloc
+	#define calloc(count,size) TRACEC(traced_calloc)(count, size, #count","#size,__LINE__,__FILE__)
+	void * traced_calloc(size_t count, size_t size, const char *size_txt, int line, const char * file);
+
+	#undef free
+	#define free(p) TRACEC(traced_free)(p, #p,__LINE__,__FILE__)
+	void traced_free(void * p, const char *size_txt, int line, const char * file);
+
+	#undef realloc
+	#define realloc(old,size) TRACEC(traced_realloc)(old,size,#size,__LINE__,__FILE__)
+	void * traced_realloc(void * old, size_t size, const char *size_txt, int line, const char * file);
+
+	void mem_dump(void const *mem, size_t size, FILE* fp = stdout);
+
+
+END_NAMESPACE
+#endif/*MEMTRACE_C*/
+
+#ifdef MEMTRACE_CPP
+START_NAMESPACE
+	#undef set_new_handler
+	#define set_new_handler(f) TRACEC(_set_new_handler)(f)
+	void _set_new_handler(std::new_handler h);
+
+	void set_delete_call(int line, const char * file);
+END_NAMESPACE
+
+void * operator new(size_t size, int line, const char * file) THROW_BADALLOC;
+void * operator new[](size_t size, int line, const char * file) THROW_BADALLOC;
+void * operator new(size_t size) THROW_BADALLOC;
+void * operator new[](size_t size) THROW_BADALLOC;
+void operator delete(void * p)  THROW_NOTHING;
+void operator delete[](void * p) THROW_NOTHING;
+
+/* Visual C++ 2012 miatt kell, mert háklis, hogy nincs megfelelő delete, bár senki sem használja */
+void operator delete(void *p, int, const char *) THROW_NOTHING;
+void operator delete[](void *p, int, const char *) THROW_NOTHING;
+
+
+#define new new(__LINE__, __FILE__)
+#define delete memtrace::set_delete_call(__LINE__, __FILE__),delete
+
+#ifdef CPORTA
+#define system(...)  // system(__VA_ARGS__)
+#endif
+
+#endif /*MEMTRACE_CPP*/
+
+#endif /*FROM_MEMTRACE_CPP*/
+#else
+#pragma message ( "MEMTRACE NOT DEFINED" )
+#endif /*MEMTRACE*/
+
+#endif /*MEMTRACE_H*/

split.cpp

+/**
+*    @file split.cpp 
+*    Be kell adni!
+*    Ide kerül a Split osztály megvalósítása
+*/
+
+#include "split.hpp"
+#include "memtrace.h"
\ No newline at end of file

split.hpp

+/**
+*    @file split.hpp 
+*    Be kell adni!
+*    Ide kerül a Split osztály deklarációja
+*/
+
+#ifndef SPLIT_HPP
+#define SPLIT_HPP
+
+#include <string>
+#include "memtrace.h"
+#include "allapotgep.hpp"
+
+class Split {
+};
+
+#endif
\ No newline at end of file