Commit b9082263 by Szeberényi Imre

v0

parents
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
# Á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
/**
* @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
<?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>
This diff is collapsed. Click to expand it.
/**
* @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"
/**
* @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
/**
* @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
}
/**
* @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
/**
* @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
This diff is collapsed. Click to expand it.
/*********************************
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*/
/**
* @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
/**
* @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
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or sign in to comment