V0

Kesz/Doxyfile

+# Doxyfile 1.4.6
+
+#---------------------------------------------------------------------------
+# Project related configuration options
+#---------------------------------------------------------------------------
+PROJECT_NAME           = "NHF Vgleges"
+PROJECT_NUMBER         = 
+OUTPUT_DIRECTORY       = 
+CREATE_SUBDIRS         = NO
+OUTPUT_LANGUAGE        = Hungarian
+USE_WINDOWS_ENCODING   = YES
+BRIEF_MEMBER_DESC      = YES
+REPEAT_BRIEF           = YES
+ABBREVIATE_BRIEF       = "The $name class" \
+                         "The $name widget" \
+                         "The $name file" \
+                         is \
+                         provides \
+                         specifies \
+                         contains \
+                         represents \
+                         a \
+                         an \
+                         the
+ALWAYS_DETAILED_SEC    = NO
+INLINE_INHERITED_MEMB  = NO
+FULL_PATH_NAMES        = NO
+STRIP_FROM_PATH        = 
+STRIP_FROM_INC_PATH    = 
+SHORT_NAMES            = NO
+JAVADOC_AUTOBRIEF      = YES
+MULTILINE_CPP_IS_BRIEF = YES
+DETAILS_AT_TOP         = YES
+INHERIT_DOCS           = YES
+SEPARATE_MEMBER_PAGES  = NO
+TAB_SIZE               = 8
+ALIASES                = 
+OPTIMIZE_OUTPUT_FOR_C  = YES
+OPTIMIZE_OUTPUT_JAVA   = NO
+BUILTIN_STL_SUPPORT    = NO
+DISTRIBUTE_GROUP_DOC   = NO
+SUBGROUPING            = YES
+#---------------------------------------------------------------------------
+# Build related configuration options
+#---------------------------------------------------------------------------
+EXTRACT_ALL            = YES
+EXTRACT_PRIVATE        = NO
+EXTRACT_STATIC         = NO
+EXTRACT_LOCAL_CLASSES  = NO
+EXTRACT_LOCAL_METHODS  = NO
+HIDE_UNDOC_MEMBERS     = NO
+HIDE_UNDOC_CLASSES     = NO
+HIDE_FRIEND_COMPOUNDS  = NO
+HIDE_IN_BODY_DOCS      = NO
+INTERNAL_DOCS          = NO
+CASE_SENSE_NAMES       = NO
+HIDE_SCOPE_NAMES       = NO
+SHOW_INCLUDE_FILES     = YES
+INLINE_INFO            = YES
+SORT_MEMBER_DOCS       = YES
+SORT_BRIEF_DOCS        = NO
+SORT_BY_SCOPE_NAME     = NO
+GENERATE_TODOLIST      = NO
+GENERATE_TESTLIST      = NO
+GENERATE_BUGLIST       = NO
+GENERATE_DEPRECATEDLIST= NO
+ENABLED_SECTIONS       = 
+MAX_INITIALIZER_LINES  = 30
+SHOW_USED_FILES        = YES
+SHOW_DIRECTORIES       = NO
+FILE_VERSION_FILTER    = 
+#---------------------------------------------------------------------------
+# configuration options related to warning and progress messages
+#---------------------------------------------------------------------------
+QUIET                  = NO
+WARNINGS               = YES
+WARN_IF_UNDOCUMENTED   = YES
+WARN_IF_DOC_ERROR      = YES
+WARN_NO_PARAMDOC       = NO
+WARN_FORMAT            = "$file:$line: $text"
+WARN_LOGFILE           = 
+#---------------------------------------------------------------------------
+# configuration options related to the input files
+#---------------------------------------------------------------------------
+INPUT                  = 
+FILE_PATTERNS          = *.cpp \
+                         *.hpp
+RECURSIVE              = NO
+EXCLUDE                = 
+EXCLUDE_SYMLINKS       = NO
+EXCLUDE_PATTERNS       = 
+EXAMPLE_PATH           = 
+EXAMPLE_PATTERNS       = 
+EXAMPLE_RECURSIVE      = NO
+IMAGE_PATH             = 
+INPUT_FILTER           = 
+FILTER_PATTERNS        = 
+FILTER_SOURCE_FILES    = NO
+#---------------------------------------------------------------------------
+# configuration options related to source browsing
+#---------------------------------------------------------------------------
+SOURCE_BROWSER         = YES
+INLINE_SOURCES         = YES
+STRIP_CODE_COMMENTS    = YES
+REFERENCED_BY_RELATION = NO
+REFERENCES_RELATION    = NO
+USE_HTAGS              = NO
+VERBATIM_HEADERS       = NO
+#---------------------------------------------------------------------------
+# configuration options related to the alphabetical class index
+#---------------------------------------------------------------------------
+ALPHABETICAL_INDEX     = NO
+COLS_IN_ALPHA_INDEX    = 5
+IGNORE_PREFIX          = 
+#---------------------------------------------------------------------------
+# configuration options related to the HTML output
+#---------------------------------------------------------------------------
+GENERATE_HTML          = YES
+HTML_OUTPUT            = html
+HTML_FILE_EXTENSION    = .html
+HTML_HEADER            = 
+HTML_FOOTER            = 
+HTML_STYLESHEET        = 
+HTML_ALIGN_MEMBERS     = YES
+GENERATE_HTMLHELP      = NO
+CHM_FILE               = 
+HHC_LOCATION           = 
+GENERATE_CHI           = NO
+BINARY_TOC             = NO
+TOC_EXPAND             = NO
+DISABLE_INDEX          = NO
+ENUM_VALUES_PER_LINE   = 4
+GENERATE_TREEVIEW      = NO
+TREEVIEW_WIDTH         = 250
+#---------------------------------------------------------------------------
+# configuration options related to the LaTeX output
+#---------------------------------------------------------------------------
+GENERATE_LATEX         = NO
+LATEX_OUTPUT           = latex
+LATEX_CMD_NAME         = latex
+MAKEINDEX_CMD_NAME     = makeindex
+COMPACT_LATEX          = NO
+PAPER_TYPE             = a4wide
+EXTRA_PACKAGES         = 
+LATEX_HEADER           = 
+PDF_HYPERLINKS         = NO
+USE_PDFLATEX           = NO
+LATEX_BATCHMODE        = NO
+LATEX_HIDE_INDICES     = NO
+#---------------------------------------------------------------------------
+# configuration options related to the RTF output
+#---------------------------------------------------------------------------
+GENERATE_RTF           = YES
+RTF_OUTPUT             = rtf
+COMPACT_RTF            = YES
+RTF_HYPERLINKS         = NO
+RTF_STYLESHEET_FILE    = 
+RTF_EXTENSIONS_FILE    = 
+#---------------------------------------------------------------------------
+# configuration options related to the man page output
+#---------------------------------------------------------------------------
+GENERATE_MAN           = NO
+MAN_OUTPUT             = man
+MAN_EXTENSION          = .3
+MAN_LINKS              = NO
+#---------------------------------------------------------------------------
+# configuration options related to the XML output
+#---------------------------------------------------------------------------
+GENERATE_XML           = NO
+XML_OUTPUT             = xml
+XML_SCHEMA             = 
+XML_DTD                = 
+XML_PROGRAMLISTING     = YES
+#---------------------------------------------------------------------------
+# configuration options for the AutoGen Definitions output
+#---------------------------------------------------------------------------
+GENERATE_AUTOGEN_DEF   = NO
+#---------------------------------------------------------------------------
+# configuration options related to the Perl module output
+#---------------------------------------------------------------------------
+GENERATE_PERLMOD       = NO
+PERLMOD_LATEX          = NO
+PERLMOD_PRETTY         = YES
+PERLMOD_MAKEVAR_PREFIX = 
+#---------------------------------------------------------------------------
+# Configuration options related to the preprocessor   
+#---------------------------------------------------------------------------
+ENABLE_PREPROCESSING   = YES
+MACRO_EXPANSION        = NO
+EXPAND_ONLY_PREDEF     = NO
+SEARCH_INCLUDES        = YES
+INCLUDE_PATH           = 
+INCLUDE_FILE_PATTERNS  = 
+PREDEFINED             = 
+EXPAND_AS_DEFINED      = 
+SKIP_FUNCTION_MACROS   = YES
+#---------------------------------------------------------------------------
+# Configuration::additions related to external references   
+#---------------------------------------------------------------------------
+TAGFILES               = 
+GENERATE_TAGFILE       = 
+ALLEXTERNALS           = NO
+EXTERNAL_GROUPS        = YES
+PERL_PATH              = /usr/bin/perl
+#---------------------------------------------------------------------------
+# Configuration options related to the dot tool   
+#---------------------------------------------------------------------------
+CLASS_DIAGRAMS         = YES
+HIDE_UNDOC_RELATIONS   = YES
+HAVE_DOT               = YES
+CLASS_GRAPH            = YES
+COLLABORATION_GRAPH    = YES
+GROUP_GRAPHS           = YES
+UML_LOOK               = YES
+TEMPLATE_RELATIONS     = YES
+INCLUDE_GRAPH          = YES
+INCLUDED_BY_GRAPH      = YES
+CALL_GRAPH             = YES
+GRAPHICAL_HIERARCHY    = YES
+DIRECTORY_GRAPH        = NO
+DOT_IMAGE_FORMAT       = png
+DOT_PATH               = 
+DOTFILE_DIRS           = 
+MAX_DOT_GRAPH_WIDTH    = 1024
+MAX_DOT_GRAPH_HEIGHT   = 1024
+MAX_DOT_GRAPH_DEPTH    = 1000
+DOT_TRANSPARENT        = NO
+DOT_MULTI_TARGETS      = NO
+GENERATE_LEGEND        = YES
+DOT_CLEANUP            = YES
+#---------------------------------------------------------------------------
+# Configuration::additions related to the search engine   
+#---------------------------------------------------------------------------
+SEARCHENGINE           = NO

Kesz/Makefile

+#
+# Pelda make a hazihoz.
+#
+
+PROG	= gen_array3_main
+OBJ	= gen_array3_main.o memtrace.o
+HEAD	= gen_array3.hpp duma_u8.h duma_latin.h cross_platform.h
+TEST	= standard_input.txt
+DATA	= valami_adat.dat
+
+JPORTA_PACK = gen_array3_main.cpp $(HEAD)
+
+CXXFLAGS= -std=c++11 -Wall -Werror -g -DCPORTA -DMEMTRACE 
+
+all:	$(PROG)
+
+gen_array3_main: $(OBJ)
+	$(CXX) -o $(PROG) $(OBJ)
+
+$(OBJ): $(HEAD)
+
+test:	$(PROG) $(TEST)
+	for i in $(TEST); do \
+	  ./$(PROG) < $$i ; \
+	done 
+
+clean:	
+	rm -f $(PROG) $(OBJ)
+
+tar:	
+	tar -czf $(PROG).tgz $(SRC) $(HEAD) $(TEST) $(DATA)
+
+zip:	
+	zip kesz.zip $(JPORTA_PACK)

Kesz/README.md

+**Végleges házi feladat feltöltése**
+
+A feltöltött programot a feladatbeadó rendszer lefordítja és összeszerkeszti. 
+Feltételezheti, hogy a fordítás során a **CPORTA** és **MEMTRACE** azonosítók definiáltak. 
+A feladat csak akkor fogadható el, ha a fordítás és szerkesztés eredményeként hibaüzenet nem keletkezik! Sikeres fordítás után a rendszer lefuttatja a programot a megadott tesztadatokkal. Ellenőrizze, hogy a memória szivárgást vizsgáló tesztek sikeresen lefutottak-e. A sikeres automatikus tesztek után, a feladatot laborvezetője fogja elfogadni, akinek a működő programot személyesen is be kell mutatni a tárgykövetelményben megadott határidőig.
+
+**Feltöltendő állományok:** 
+
+1. **Forrásfájlokat** tartalmazó *zip* fájl (pl. *kesz.zip*). A fájlok az archívum gyökérében legyenek, ne legyen alkatalógus az archívumban! 
+2. **Adatfájlokat** tartalmazó *zip* fájl (opcionális) (pl. *valami_adat.zip*). Ezt az archívumot a *Jporta* a feladat futtatása előtt abban a katalógusban bontja ki, amelyből a futtatható programot indítja. Így a benne levő állományokat a futó program közvetlenül eléri. (pl. f.open("valami_adat.dat");)    
+3. **Szabványos bemenetre** irányítandó szöveg fájl (opcionális) (pl: *standard_input.txt*), melynek tartalmát a *Jporta* futtatáskor a futtatott program szabványos bemenetére irányítja. A fájlt szövegfájlnak tekinti, ezért a *Jporta* futtató környezetének (LINUX) megfelelő formára konvertálja, azaz eldobjuk a \r\n sorozatból a \r karaktert, ha van. 
+4. **Dokumentációt** tartalmazó .pdf formátumú fájl (opcionális) (pl. *NHF4.pdf*). A fájl feltöltése a feladat kiértékeléséhez nem szükséges, csak **a végleges beadásnál elvárt**, hiánya a megoldás laborvezetői elutasítását vonja maga után. 
+ 
+**Megjegyzések, tanácsok:**
+
+- A fenti felsorolásban példaként zárójelben a minta HF-ben használt neveket adtuk meg. 
+- **Ne** használjon ékezetes karaktereket, szóközöket az állományok nevében!
+- **Ne** töltsön fel *memtrace.h*, *memtrace.cpp* és *gtest_lite.h* nevű fájlokat! 
+Ha mégis feltöltene ilyen nevű fájlokat, akkor azokat a rendszer **felülírja**.
+- A forrásfájlokat **ne** UTF-16 kódban csomagolja a zip-be! (Microsoft VS hajlamos ilyen módon kódolni.)
+- Ha az **adatfájlokat** (fenti példában a *valami_adat.zip* tartalma) szövegfájlként dolgozza fel, akkor wegye figyelembe, hogy a feladatbeadó rendszer LINUX operációs rendszer alatt fut, ami feltételezi, hogy a szövegfájlokban a sor végét egyetlen karakter a **\n** jelzi, míg pl. Windows alatt a sorok végét a **\r\n** sorozat jelzi, amiből a beolvasó rutinok eldobják a **\r** karaktert. LINUX alatt beolvasáskor ilyen nem történik, így beolvasáskor **\r** is megjelenik.   
+- A szabványos bemenetre irányított fájlnál ezzel a problémával nem kell számolnia, mert a *Jporta* ezt a fájlt a feltöltéskor konvertálja ée eldobja a **\r** karaktereket. Adatfájl esetén konverzió nem történik, hiszen egy adatban bármilyen érték előfordulhat. 
+- Elemezze a [NHF 4 - végleges](https://git.ik.bme.hu/Prog2/ell_feladat/NHF.git) mintafeladatot! Próbaként akár fel is töltheti a megfelelő fájlokat!
+- Problémakeresésben [segít ez az oldal](https://infocpp.iit.bme.hu/jporta/NHF)
+  
\ No newline at end of file

Kesz/cross_platform.h

+#ifndef CROSS_PLATFORM_H
+#define CROSS_PLATFORM_H
+
+#include <iostream>
+#include <string>
+
+namespace cp {	    //cross-platform getline
+// Működik WinX/Linux/MAC környezetben is.
+// Kezeli a \n , a \r\n és a \n\r végű sorokat is.
+// Ez utóbbi csak nagyon régi (MAC OS X előtti) MAC rendszerekben fordul elő
+std::istream& getline(std::istream& is, std::string& str) {
+    std::getline(is, str);
+    if (str.size()) {
+        if (*str.rbegin() == '\r')
+            str.erase(str.size()-1);
+        else if  (*str.begin() == '\r')
+            str.erase(str.begin());
+    }
+    return is;
+}
+
+} // namespace cp
+#endif // CROSS_PLATFORM_H

Kesz/duma_latin.h

+/**
+ * \file duma_latin.h
+ *
+ * latin2 kodolasu szovegek
+ *
+ * Windows alatt ez kell
+ */
+
+#define T_NEM1250 "\
+A nem 1250 kodolast hasznal a futtato kornyezet. \
+Az ekezetes szovegek lehet, hogy hibasan fognak megjelenni."
+
+#define T_TNR   "\nTeszteset sorszma: "
+#define T_INT50 "\
+default (50) elem int tmb\n\
+Adja meg a sorok szmat, majd az index - rtk prokat!\n"
+
+#define T_DOUBLE100 "\
+100 elem double tmb\n\
+Adja meg a sorok szmat, majd az index - rtk prokat!\n"
+
+#define T_STRING11 "\
+11 elem sztring tmb sajt kivetelosztllyal\n\
+Adja meg a sorok szmat, majd az index - sztring prokat!\n"
+
+#define T_DUMA1 "\
+A mintafeladat bemutatja az kezetes karakterek hasznlatt is.\n\
+Ez a szveg UTF-8 kdols:\n\
+rvztrtkrfrgp RVZTRTKRFRGP"
+
+#define T_ADAT1 "\nMost beolvassuk a valami_adat.dat fjlt, ami WINX szveg:"
+
+#define T_ADAT2 "\nMost beolvassuk jra, de a cross-platform getline-nal:"
+
+#define T_BEIR_TXT "Bla bcsi tzolt"
+
+#define T_BEIR  "\nMost berjuk a '" T_BEIR_TXT "' szveget a sajat.txt fjlba."
+
+#define T_ADAT3 "\nBeolvassuk a sajt krnyzetben ketezett sajat.txt fjlt."
+
+#define T_NINCS "Nics ilyen teszteset!"
+
+#define T_SKIV  "Sajat kivtel jtt."
+
+#define T_NAGYB "*** Nagy baj van! ****"

Kesz/duma_u8.h

+/**
+ * \file duma_u8.h
+ * utf8 kodolasu szovegek
+ *
+ * LINUX alatt ez kell
+ */
+
+
+#define T_NEMUTF "\
+A nem UTF-8 kodolast hasznal a futtato kornyezet. \
+Az ekezetes szovegek lehet, hogy hibasan fognak megjelenni."
+
+#define T_TNR   "\nTeszteset sorszáma: "
+#define T_INT50 "\
+default (50) elemű int tömb\n\
+Adja meg a sorok számat, majd az index - érték párokat!\n"
+
+#define T_DOUBLE100 "\
+100 elemű double tömb\n\
+Adja meg a sorok számat, majd az index - érték párokat!\n"
+
+#define T_STRING11 "\
+11 elemű sztring tömb saját kivetelosztállyal\n\
+Adja meg a sorok számat, majd az index - sztring párokat!\n"
+
+#define T_DUMA1 "\
+A mintafeladat bemutatja az ékezetes karakterek megjelenítését is:\n\
+Ez a szöveg UTF-8 kódolású:\n\
+árvíztűrőtükörfúrógép ÁRVÍZTŰRŐTÜKÖRFÚRÓGÉP"
+
+#define T_ADAT1 "\nMost beolvassuk a valami_adat.dat fájlt, ami WINX szöveg:"
+
+#define T_ADAT2 "\nMost beolvassuk újra, de a cross-platform getline-nal:"
+
+#define T_BEIR_TXT "Béla bácsi tűzoltó"
+
+#define T_BEIR  "\nMost beírjuk a '" T_BEIR_TXT "' szöveget a sajat.txt fájlba."
+
+#define T_ADAT3 "\nBeolvassuk a saját környzetben ketezett sajat.txt fájlt."
+
+#define T_NINCS "Nics ilyen teszteset!"
+
+#define T_SKIV  "Sajat kivétel jött."
+
+#define T_NAGYB "*** Nagy baj van! ****"
+

Kesz/gen_array3.hpp

+/**
+ * \file gen_array3.hpp
+ *
+ * Generikus tmb NHF plda feladatnak bemutatshoz.
+ * Ksz (vgleges) feladat.
+ *
+ * Feladat:
+ *   Fix mret Generikus tmb megvalstsa.
+ */
+
+#include <sstream>          /// csak a hibajelzs miatt kell
+
+/// Generikus tmb osztly statikus mrettel
+/// @param T - adattpus
+/// @param s - mret, default: 50
+/// @param E - hibaosztly (indexelsi hiba esetn hvdik) defalul: std::range_error
+template <class T, int s = 50, typename E = std::out_of_range>
+class Array {               // osztlysablon
+    T t[s];                 /// adattag, template paramter a mrete
+public:
+    /// Indexels.
+    /// @param i - index
+    /// @return - referencia az adott index elemre
+    /// @return - hibs indexrtk esetn E() kivtelt dob
+    T& operator[](int i);
+
+    /// Indexels konstans fggvnye.
+    /// @param i - index
+    /// @return - referencia az adott index elemre
+    /// @return - hibs indexrtk esetn E() kivtelt dob 
+    const T& operator[](int i) const;
+};	
+
+/// index opertor megvalstsa
+template <class T, int s, typename E>
+T& Array<T, s, E>::operator [](int i) {
+    if (i < 0 || i >= s) {
+        // megprblunk sszerakni egy rtelmes hibajelzst
+        // persze ez gy nagyon fapados s ronda
+        std::stringstream err;
+        err << " **Indexhiba** idx: " << i << " [0," << s-1 << "]";
+        throw E(err.str()); // template paramterknt kapott osztly egy pldnyt dobjuk
+    }
+    return t[i];    // megfelel elem referencijval trnk vissza
+}
+
+/// konstans pldny index opertor megvalstsa
+template <class T, int s, typename E>
+const T& Array<T, s, E>::operator [](int i) const {
+    if (i < 0 || i >= s) {
+        // megprblunk sszerakni egy rtelmes hibajelzst
+        // persze ez gy nagyon fapados s ronda
+        std::stringstream err;
+        err << " **Indexhiba** idx: " << i << " [0," << s-1 << "]";
+        throw E(err.str()); // template paramterknt kapott osztly egy pldnyt dobjuk
+    }
+    return t[i];    // megfelel elem referencijval trnk vissza
+}

Kesz/gen_array3_main.cpp

+/**
+ * \file gen_array3_main.cpp
+ *
+ * Egyszerű tesztprogram a jporta NHF példafeladat bemutatásához.
+ *
+ * Feladat:
+ *   Fix méretű Generikus tömb megvalósítása.
+ *
+ * A mintaprogram lokális nyelvi környezetet is állít a magyar ékezetes
+ * szövegek megjelenítéséhez.
+ * Az ékezetes szövegkonstansok a duma_u8.h és a duma_latin.h fájlokban vannak.
+ * A megoldás fordításidejű, és csak egy gyenge próbálkozás, melynek lényege:
+ *  - A program minden a szövegkonstansokra makrókkal (#define) defininiált azonosítókkal
+ *    hivatkozik pl: cout << T_DUMA1 << endl;
+ *  - A makrók két külön fájlban vannak definiálva. At egyikben latin2, a maikban UTF-8 kódolással.
+ *  - Attól függően, hogy a fordítás WinX, vagy más rendszerben történik, latin2 kódolású fájl
+ *    include-olja, vagy az UTF-8-as kódolásút.
+ *
+ * Ez a fajta megoldás akár nyelvek közötti váltásra is alkalmas, de az igazi rendes megoldás
+ * futásidőben cseréli le szövegkonstansokat a megfelelő nyelvűre.
+ * Ilyen pl. a GNU gettext, ami egy komplex, jól használható megoldást ad a problémára.
+ *
+ * A jelenlegi WinX rendszerek magyar nyelvi beállítással a 1250-es kódlapot használják,
+ * ami lényegében latin2.
+ * A helyes megjelenéshez magyar Windows alatt az 1250-es kódlapot kell
+ * beállítani:
+ *   regedit:
+ *     [HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Nls\CodePage]
+ *        OEMCP=1250
+ *    Ezen felül az output képernyő fontkészletét Lucida Console típusúra kell
+ *    állítani.
+ *
+ * Linux/UNIX: A modern Linuxok UTF-8-as kódolást használnak alapból: ha a
+ * fájlt így mentjük, helyesen fognak megjelenni az ékezetek. (Például
+ * LANG=hu_HU.UTF8 beállításokkal.)
+ *
+ * Linux/UNIX rendszerekben az export LANG=hu_HU paranccsal lehet az adott
+ * parancsértelmező számára megadni a használandó locale-t. Ebben az esetben
+ * ISO-8859-2 (más néven latin2) kódolással kell a fájlt menteni.
+ *
+ * Jporta: UTF-8 kódolású fájlokat érdemes használni, ha fontos a helyes
+ * ékezetes megjelenítés.
+ *
+ * Egy fájl karakterkódolása egyszerűen váltható az iconv programmal,
+ * a CodeBlocks editorával, vagy pl. a notepad++ programmal.
+ */
+
+#include <iostream>
+#include <fstream>
+#include <string>
+#include <stdexcept>
+#include <locale>
+#if defined(WIN32) || defined(_WIN32) || defined(WIN64) || defined(_WIN64)
+  #define WINX
+  #include <windows.h>
+#endif
+
+#include "memtrace.h"
+#include "gen_array3.hpp"           // sablon
+#include "cross_platform.h"
+
+#ifdef WINX
+  #include "duma_latin.h"
+#else
+  #include "duma_u8.h"
+#endif // WINX
+
+
+//#define JPORTA_INPUT_SIM  // Jporta std in szimuláció
+
+using std::cout;
+using std::endl;
+using std::cin;
+using std::cerr;
+using std::string;
+
+/// Saját kivételosztály a teszthez.
+class BajVan {
+public:
+    /// @param - nem használjuk semmire
+    BajVan(const string&) {}
+};
+
+
+/// TESZT 4
+/// Adatfájl beolvasásának bemutatásához.
+/// Csak demó nincs funkciója ebben a feladatban.
+void test_4() {
+
+    // A mintafeladat bemutatja az ékezetes karakterek megjelenítését is:
+    cout << T_DUMA1 << endl;
+
+
+    std::fstream os;                        // file stream
+    os.exceptions(std::ifstream::badbit);   // file kezelési hiba esetén dobjon kivétel
+
+    // Most beolvassuk a valami_adat.dat fájlt"
+    cout << T_ADAT1 << endl;
+    // fájl megnyitása
+    os.open("valami_adat.dat", std::fstream::in);
+
+    // beolvasás
+    string line;
+    while (getline(os, line)) {
+       cout << "len:" << line.size() << " " << line << endl;
+       memtrace::mem_dump(line.c_str(), line.size(), stdout);
+    }
+    // fájl lezárása
+    os.close();
+
+    // Most beolvassuk újra, de cross-platform getline-nal
+    cout << T_ADAT2 << endl;
+    // fájl megnyitása
+    os.open("valami_adat.dat", std::fstream::in);
+
+    // beolvasas
+    while (cp::getline(os, line)) {
+       cout << "len:" << line.size() << " " << line << endl;
+       memtrace::mem_dump(line.c_str(), line.size(), stdout);
+    }
+    // fájl lezárása
+    os.close();
+
+    // Most beírunk a T_BEIRT_TXT szöveget a fájlba
+    cout << T_BEIR << endl;
+    // fájl megnyitása írásra
+    os.open("valami_adat2.dat", std::fstream::out);
+
+    // Kiírás
+    os << T_BEIR_TXT << endl;
+
+    // Most beolvassuk a valami_adat2.dat fájlt"
+    cout << T_ADAT3 << endl;
+    // fájl megnyitása
+
+    os.close();
+    os.open("valami_adat2.dat", std::fstream::in);
+
+    // beolvasás
+    // Itt nem fontos (nem is hiba) a cp:getline, mert a környezet
+    //    kompatibilis saját magával (reméljük)
+    while (getline(os, line)) {
+       cout << "len:" << line.size() << " " << line << endl;
+       memtrace::mem_dump(line.c_str(), line.size(), stdout);
+    }
+    os.close();
+}
+
+/// TESZT 1
+/// standard inputról beolvas egy darabszámot
+/// majd számpárokat, akol az első szám az index, a második az érték.
+void test_1() {
+    Array<int> arr;                 // default (50) elemű int tömb
+    cout << T_INT50;
+    int sorok;
+    (cin >> sorok).ignore(200, '\n'); // elddobjuk az esetleges kommentet
+    int i = 0, idx, value;
+    while (i++ < sorok && cin >> idx >> value) {
+        arr[idx] = value;
+        cout << "arr[" << idx << "]=" << arr[idx] << endl;
+    }
+}
+
+/// TESZT 2
+/// standard inputról beolvas egy darabszámot
+/// majd számpárokat, akol az első szám az index, a második az érték.
+void test_2() {
+    Array<double, 100> darr;        // 100 elemű double tömb
+    cout << T_DOUBLE100;
+    int sorok;
+    (cin >> sorok).ignore(200, '\n'); // eldobjuk az esetleges kommentet
+    int i = 0, idx;
+    double value;
+    while (i++ < sorok && cin >> idx >> value) {
+        darr[idx] = value;
+        cout << "darr[" << idx << "]=" << darr[idx] << endl;
+    }
+}
+
+/// TESZT 3
+/// standard inputról beolvas egy darabszámot
+/// majd egy idexet és a sor végéig eg stringet
+void test_3() {
+    Array<string, 11, BajVan> sarr;  // 11 elemű sztring saját kivétellel
+    cout << T_STRING11;
+    int sorok;
+    (cin >> sorok).ignore(200, '\n'); // eldobjuk az esetleges kommentet
+    int i = 0, idx;
+    string value;
+    while (i++ < sorok && cin >> idx && getline(cin, value)) {
+        sarr[idx] = value;
+        cout << "sarr[" << idx << "]=" << sarr[idx] << endl;
+    }
+}
+
+/// Főprogram a standard inputról olvas egy egész számot, majd
+/// meghívja az annak megfelelő tesztesetet.
+/// A további bemenetet és kimenetet a tesztesetek kezelik.
+int main() {
+    char *p = setlocale(LC_ALL, "");  // a rendszer környezeti változójában megadott nyelvi környezet beállítása
+    string loc;
+    if (p != NULL)
+	loc = p;
+    cout << "Locale: " << loc << endl;
+    #ifdef WINX
+      if (loc.find("1250") == string::npos) {
+        cout << T_NEM1250;
+      }
+      /// a CP1250 latin2-nek felel meg.
+      /// WinX alatt nem sikerült találnom működő utf8-as kódlapot
+      SetConsoleCP(1250);
+      SetConsoleOutputCP(1250);
+    #else
+      if (loc.find("UTF-8") == string::npos && loc.find("utf8") == string::npos) {
+        cout << T_NEMUTF;
+      }
+    #endif
+
+/// Jporta std in szimuláció
+#ifdef JPORTA_INPUT_SIM
+    // Ha definiált, akkor a standard_input.txt nevű fájlból veszi az inputot.
+    // Ez az a fájl, amit a Jporta rendszerbe a minta feladatban feltöltünk mint std. in.
+    std::ifstream in("standard_input.txt");
+    std::cin.rdbuf(in.rdbuf());     // cin mostantól az in-ből olvas
+#endif // JPORTASIM
+
+
+    // Teszteset sorszáma
+    cout << T_TNR;
+    int nr;
+    while (cin >> nr && nr > 0) {    // hanyadik teszteset
+        // A sorszám után komment is lehet a sor végéig.
+        string megj;
+        getline(cin, megj);
+        cout << endl << nr << ". teszteset: " << megj << endl;
+        try {
+            switch (nr) {
+                case 4:
+                    test_4();   // txt fájl kezelését bemutató demó
+                break;
+
+                case 1:
+                    test_1();   // default (50) elemű int tömb
+                break;
+
+                case 2:
+                    test_2();   // 100 elemű double tömb
+                break;
+
+                case 3:
+                    test_3();   // 11 elemű string saját kivételosztállyal
+                break;
+
+                default:
+                    cout << T_NINCS << endl;
+            } // switch
+        // kivételek kezelése
+        } catch (std::exception& e) {
+            // kiírjuk, hogy milyen kivétel jött
+            cout << e.what() << endl;
+        } catch (BajVan&) {
+            cout << T_SKIV << endl;
+        } catch (...) {
+            cout << T_NAGYB << endl;
+        }
+        cout << T_TNR;
+    } // while
+    return 0;
+}
+

Kesz/kesz.cbp

+<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
+<CodeBlocks_project_file>
+	<FileVersion major="1" minor="6" />
+	<Project>
+		<Option title="kesz" />
+		<Option pch_mode="2" />
+		<Option compiler="gcc" />
+		<Build>
+			<Target title="Debug">
+				<Option output="bin/Debug/kesz" 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/kesz" 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="-std=c++11" />
+			<Add option="-Wall" />
+			<Add option="-fexceptions" />
+		</Compiler>
+		<Unit filename="cross_platform.h" />
+		<Unit filename="duma_latin.h" />
+		<Unit filename="duma_u8.h" />
+		<Unit filename="gen_array3.hpp" />
+		<Unit filename="gen_array3_main.cpp" />
+		<Unit filename="memtrace.cpp" />
+		<Unit filename="memtrace.h" />
+		<Extensions>
+			<code_completion />
+			<debugger />
+			<DoxyBlocks>
+				<comment_style block="0" line="0" />
+				<doxyfile_project />
+				<doxyfile_build />
+				<doxyfile_warnings />
+				<doxyfile_output />
+				<doxyfile_dot />
+				<general />
+			</DoxyBlocks>
+			<envvars />
+		</Extensions>
+	</Project>
+</CodeBlocks_project_file>

Kesz/kesz.vcproj

+<?xml version="1.0" encoding="windows-1250"?>
+<VisualStudioProject
+	ProjectType="Visual C++"
+	Version="9,00"
+	Name="kesz"
+	ProjectGUID="{022FD5D0-F6F4-459A-966B-FC1B83BF09AE}"
+	Keyword="Win32Proj"
+	TargetFrameworkVersion="131072"
+	>
+	<Platforms>
+		<Platform
+			Name="Win32"
+		/>
+	</Platforms>
+	<ToolFiles>
+	</ToolFiles>
+	<Configurations>
+		<Configuration
+			Name="Debug|Win32"
+			OutputDirectory="Debug"
+			IntermediateDirectory="Debug"
+			ConfigurationType="1"
+			InheritedPropertySheets="$(VCInstallDir)VCProjectDefaults\UpgradeFromVC71.vsprops"
+			CharacterSet="2"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="0"
+				PreprocessorDefinitions="WIN32;_DEBUG;_CONSOLE;MEMTRACE"
+				MinimalRebuild="true"
+				BasicRuntimeChecks="3"
+				RuntimeLibrary="1"
+				UsePrecompiledHeader="0"
+				WarningLevel="3"
+				Detect64BitPortabilityProblems="false"
+				DebugInformationFormat="4"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				OutputFile="$(OutDir)/HF_pelda_kesz.exe"
+				LinkIncremental="2"
+				GenerateDebugInformation="true"
+				ProgramDatabaseFile="$(OutDir)/HF_pelda_kesz.pdb"
+				SubSystem="1"
+				RandomizedBaseAddress="1"
+				DataExecutionPrevention="0"
+				TargetMachine="1"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+		<Configuration
+			Name="Release|Win32"
+			OutputDirectory="Release"
+			IntermediateDirectory="Release"
+			ConfigurationType="1"
+			InheritedPropertySheets="$(VCInstallDir)VCProjectDefaults\UpgradeFromVC71.vsprops"
+			CharacterSet="2"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				PreprocessorDefinitions="WIN32;NDEBUG;_CONSOLE"
+				RuntimeLibrary="0"
+				UsePrecompiledHeader="0"
+				WarningLevel="3"
+				Detect64BitPortabilityProblems="true"
+				DebugInformationFormat="3"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				OutputFile="$(OutDir)/HF_pelda_kesz.exe"
+				LinkIncremental="1"
+				GenerateDebugInformation="true"
+				SubSystem="1"
+				OptimizeReferences="2"
+				EnableCOMDATFolding="2"
+				RandomizedBaseAddress="1"
+				DataExecutionPrevention="0"
+				TargetMachine="1"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+	</Configurations>
+	<References>
+	</References>
+	<Files>
+		<Filter
+			Name="Source Files"
+			Filter="cpp;c;cxx;def;odl;idl;hpj;bat;asm;asmx"
+			UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}"
+			>
+			<File
+				RelativePath=".\gen_array3_main.cpp"
+				>
+			</File>
+			<File
+				RelativePath=".\memtrace.cpp"
+				>
+			</File>
+		</Filter>
+		<Filter
+			Name="Header Files"
+			Filter="h;hpp;hxx;hm;inl;inc;xsd"
+			UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}"
+			>
+			<File
+				RelativePath=".\gen_array3.hpp"
+				>
+			</File>
+			<File
+				RelativePath=".\memtrace.h"
+				>
+			</File>
+		</Filter>
+	</Files>
+	<Globals>
+	</Globals>
+</VisualStudioProject>

Kesz/memtrace.cpp

+/*********************************
+Memoriaszivargas-detektor
+Keszitette: Peregi Tamas, BME IIT, 2011
+            petamas@iit.bme.hu
+Kanari:     Szeberenyi Imre, 2013.
+VS 2012:    Szebernyi Imre, 2015.,
+mem_dump:   2016.
+meset felszabaditaskor: 2018.
+*********************************/
+
+/*definiealni kell, ha nem paracssorbol allitjuk be (-DMEMTRACE) */
+/*#define MEMTRACE */
+
+#ifdef _MSC_VER
+	#define _CRT_SECURE_NO_WARNINGS 1
+#endif
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+#include <ctype.h>
+
+#ifdef MEMTRACE
+#define FROM_MEMTRACE_CPP
+#include "memtrace.h"
+
+#define FMALLOC 0
+#define FCALLOC 1
+#define FREALLOC 2
+#define FFREE 3
+#define FNEW 4
+#define FDELETE 5
+#define FNEWARR 6
+#define FDELETEARR 7
+#define COMP(a,d) (((a)<=3 && (d)<=3) || ((d)==(a)+1))
+#define PU(p)   ((char*)p+CANARY_LEN)	// mem pointerbol user poi
+#define P(pu)   ((char*)pu-CANARY_LEN)	// user pointerbol mem poi
+#define XSTR(s) STR(s)
+#define STR(s)  #s
+/*******************************************************************/
+/* Segedfuggvenyek es egyebek */
+/*******************************************************************/
+START_NAMESPACE
+    static FILE *fperror;
+    #ifdef MEMTRACE_TO_MEMORY
+    	static const unsigned int CANARY_LEN = 64;
+    #else
+    	static const unsigned int CANARY_LEN = 0;
+    #endif
+    static const unsigned char canary_byte1 = 'k';
+    static const unsigned char canary_byte2 = 'K';
+    static unsigned char random_byte;
+
+	typedef enum {FALSE,TRUE} BOOL;
+
+	static const char * pretty[] = {"malloc(", "calloc(", "realloc(", "free(",
+                                        "new", "delete", "new[]", "delete[]"};
+
+	static const char * basename(const char * s) {
+		const char *s1,*s2;
+		s1 = strrchr(s,'/');
+		if(s1==NULL) s1 = s; else s1++;
+		s2 = strrchr(s1, '\\');
+		if(s2==NULL) s2 = s1; else s2++;
+		return s2;
+	}
+
+	static char *StrCpy(char ** to, const char * from) {
+        	if(from == NULL) {
+			*to = NULL;
+        	} else {
+            		*to = (char*)malloc(strlen(from)+1);
+            		if(*to) strcpy(*to, from);
+        	}
+        	return *to;
+	}
+
+	static void *canary_malloc(size_t size, unsigned char data) {
+		char *p = (char *)malloc(size+2*CANARY_LEN);
+		if (p) {
+			memset(p, canary_byte1, CANARY_LEN);
+			memset(p+CANARY_LEN, data, size);
+			memset(p+CANARY_LEN+size, canary_byte2, CANARY_LEN);
+		}
+		return p;
+	}
+
+	static int chk_canary(void *p, size_t size) {
+		unsigned char *pc = (unsigned char*)p;
+		unsigned int i;
+		for (i = 0; i < CANARY_LEN; i++)
+			if (pc[i] != canary_byte1)
+				return -1;
+		pc += CANARY_LEN+size;
+		for (i = 0; i < CANARY_LEN; i++)
+			if (pc[i] != canary_byte2)
+				return 1;
+		return 0;
+	}
+
+	typedef struct {
+		int f;  /* allocator func */
+		int line;
+		char * par_txt;
+		char * file;
+	} call_t;
+
+	static call_t pack(int f, const char * par_txt, int line, const char * file) {
+		call_t ret;
+		ret.f = f;
+		ret.line = line;
+		StrCpy(&ret.par_txt, par_txt);
+		StrCpy(&ret.file, file);
+		return ret;
+	}
+
+	static void print_call(const char * msg, call_t call) {
+		if(msg) fprintf(fperror, "%s", msg);
+		fprintf(fperror, "%s", pretty[call.f]);
+		fprintf(fperror, "%s", call.par_txt ? call.par_txt : "?");
+		if (call.f <= 3) fprintf(fperror, ")");
+		fprintf(fperror," @ %s:", call.file ? basename(call.file) : "?");
+		fprintf(fperror,"%d\n",call.line ? call.line : 0);
+	}
+
+	/* memoriateruletet dump */
+	static void dump_memory(void const *mem, size_t size, size_t can_len, FILE* fp) {
+		unsigned char const *m=(unsigned char const *) mem;
+		unsigned int s, o;
+
+        if (can_len > 0)
+            fprintf(fp, "Dump (addr: %p kanari hossz: %d):\n", m+can_len, (int)can_len);
+        else
+            fprintf(fp, "Dump: (addr: %p) \n", m);
+		size += 2*can_len;
+		for (s = 0; s < (size+15)/16; s++) {
+			fprintf(fp, "%04x:%c ", s*16, s*16 < can_len || s*16 >= size-can_len ? ' ' : '*');
+			for (o = 0; o < 16; o++) {
+				if (o == 8) fprintf(fp, " ");
+				if (s*16+o < size)
+					fprintf(fp, "%02x ", m[s*16+o]);
+				else
+					fprintf(fp, "   ");
+			}
+			fprintf(fp, " ");
+			for (o = 0; o < 16; o++) {
+				if (s*16+o < size)
+					fprintf(fp, "%c", isprint(m[s*16+o]) ? m[s*16+o] : '.');
+				else
+					fprintf(fp, " ");
+			}
+			fprintf(fp, "\n");
+		}
+	}
+
+	void mem_dump(void const *mem, size_t size, FILE* fp) {
+	    dump_memory(mem, size, 0, fp);
+    }
+
+	static BOOL dying;
+
+	static void die(const char * msg, void * p, size_t size, call_t * a, call_t * d) {
+		#ifdef MEMTRACE_ERRFILE
+            fperror = fopen(XSTR(MEMTRACE_ERRFILE), "w");
+        #endif
+		fprintf(fperror,"%s\n",msg);
+		if (p) {
+			fprintf(fperror, "\tPointer:\t%p", PU(p));
+			if (size) fprintf(fperror," (%u byte)", (unsigned)size);
+			fprintf(fperror,"\n");
+		}
+		if (a) print_call("\tFoglalas:\t", *a);
+		if (d) print_call("\tFelszabaditas:\t", *d);
+                if (p) dump_memory(p, size, CANARY_LEN, fperror);
+
+		dying = TRUE;
+		exit(120);
+	}
+
+	static void initialize();
+END_NAMESPACE
+
+/*******************************************************************/
+/* MEMTRACE_TO_MEMORY */
+/*******************************************************************/
+
+#ifdef MEMTRACE_TO_MEMORY
+START_NAMESPACE
+	typedef struct _registry_item {
+		void * p;    /* mem pointer*/
+		size_t size; /* size*/
+		call_t call;
+		struct _registry_item * next;
+	} registry_item;
+
+	static registry_item registry; /*sentinel*/
+
+	static void print_registry_item(registry_item * p) {
+		if (p) {
+			print_registry_item(p->next);
+			fprintf(fperror, "\t%p%5u byte ",p->p, (unsigned)p->size);
+			print_call(NULL, p->call);
+			if(p->call.par_txt) free(p->call.par_txt);
+			if(p->call.file) free(p->call.file);
+			free(p);
+		}
+	}
+
+	/* ha nincs hiba, akkor 0-val tr vissza */
+	int mem_check(void) {
+		initialize();
+		if(dying) return  2;    /* cmzsi hiba */
+
+		if(registry.next) {
+			/*szivarog*/
+		    #ifdef MEMTRACE_ERRFILE
+                fperror = fopen(XSTR(MEMTRACE_ERRFILE), "w");
+            #endif
+			fprintf(fperror, "Szivargas:\n");
+			print_registry_item(registry.next);
+			registry.next = NULL;
+			return 1;           /* memria fogys */
+		}
+        return 0;
+	}
+END_NAMESPACE
+#endif/*MEMTRACE_TO_MEMORY*/
+
+/*******************************************************************/
+/* MEMTRACE_TO_FILE */
+/*******************************************************************/
+
+#ifdef MEMTRACE_TO_FILE
+START_NAMESPACE
+	static FILE * trace_file;
+END_NAMESPACE
+#endif
+
+/*******************************************************************/
+/* register/unregister */
+/*******************************************************************/
+
+START_NAMESPACE
+	static int allocated_blks;
+
+    int allocated_blocks() { return allocated_blks; }
+
+	static BOOL register_memory(void * p, size_t size, call_t call) {
+		initialize();
+		allocated_blks++;
+		#ifdef MEMTRACE_TO_FILE
+			fprintf(trace_file, "%p\t%d\t%s%s", PU(p), size, pretty[call.f], call.par_txt ? call.par_txt : "?");
+			if (call.f <= 3) fprintf(trace_file, ")");
+			fprintf(trace_file, "\t%d\t%s\n", call.line, call.file ? call.file : "?");
+			fflush(trace_file);
+		#endif
+		#ifdef MEMTRACE_TO_MEMORY
+		{/*C-blokk*/
+			registry_item * n = (registry_item*)malloc(sizeof(registry_item));
+			if(n==NULL) return FALSE;
+			n->p = p;
+			n->size = size;
+			n->call = call;
+			n->next = registry.next;
+			registry.next = n;
+		}/*C-blokk*/
+		#endif
+
+		return TRUE;
+	}
+
+	#ifdef MEMTRACE_TO_MEMORY
+	static registry_item *find_registry_item(void * p) {
+            	registry_item *n = &registry;
+            	for(; n->next && n->next->p != p ; n=n->next);
+            	return n;
+    	}
+    	#endif
+
+	static void unregister_memory(void * p, call_t call) {
+		initialize();
+		#ifdef MEMTRACE_TO_FILE
+                        fprintf(trace_file, "%p\t%d\t%s%s", PU(p), -1, pretty[call.f], call.par_txt ? call.par_txt : "?");
+                        if (call.f <= 3) fprintf(trace_file, ")");
+			fprintf(trace_file,"\t%d\t%s\n",call.line, call.file ? call.file : "?");
+			fflush(trace_file);
+		#endif
+		#ifdef MEMTRACE_TO_MEMORY
+		{ /*C-blokk*/
+			registry_item * n = find_registry_item(p);
+			if(n->next) {
+                allocated_blks--;
+				registry_item * r = n->next;
+				n->next = r->next;
+				if(COMP(r->call.f,call.f)) {
+                    int chk = chk_canary(r->p, r->size);
+                    if (chk < 0)
+						die("Blokk elott serult a memoria:", r->p,r->size,&r->call,&call);
+                    if (chk > 0)
+                        die("Blokk utan serult a memoria", r->p,r->size,&r->call,&call);
+					/*rendben van minden*/
+					if(call.par_txt) free(call.par_txt);
+					if(r->call.par_txt) free(r->call.par_txt);
+					if(call.file) free(call.file);
+					if(r->call.file) free(r->call.file);
+					memset(PU(r->p), 'f', r->size);
+					PU(r->p)[r->size-1] = 0;
+					free(r);
+				} else {
+					/*hibas felszabaditas*/
+					die("Hibas felszabaditas:",r->p,r->size,&r->call,&call);
+				}
+			} else {
+				die("Nem letezo, vagy mar felszabaditott adat felszabaditasa:", p, 0,NULL,&call);
+			}
+		} /*C-blokk*/
+		#endif
+	}
+END_NAMESPACE
+
+/*******************************************************************/
+/* C-stlus memriakezels */
+/*******************************************************************/
+
+#ifdef MEMTRACE_C
+START_NAMESPACE
+	void * traced_malloc(size_t size, const char * par_txt, int line, const char * file) {
+		void * p;
+		initialize();
+		p = canary_malloc(size, random_byte);
+		if (p) {
+			if(!register_memory(p,size,pack(FMALLOC,par_txt,line,file))) {
+				free(p);
+				return NULL;
+			}
+		    return PU(p);
+		}
+        return NULL;
+	}
+
+	void * traced_calloc(size_t count, size_t size, const char * par_txt, int line, const char * file) {
+		void * p;
+		initialize();
+                size *= count;
+                p = canary_malloc(size, 0);
+		if(p) {
+			if(!register_memory(p,size,pack(FCALLOC,par_txt,line,file))) {
+				free(p);
+				return NULL;
+			}
+		    return PU(p);
+		}
+		return NULL;
+	}
+
+	void traced_free(void * pu, const char * par_txt, int line, const char * file) {
+		initialize();
+		if(pu) {
+			unregister_memory(P(pu), pack(FFREE,par_txt,line,file));
+			free(P(pu));
+		} else {
+			/*free(NULL) eset*/
+			#ifdef MEMTRACE_TO_FILE
+				fprintf(trace_file,"%s\t%d\t%10s\t","NULL",-1,pretty[FFREE]);
+				fprintf(trace_file,"%d\t%s\n",line,file ? file : "?");
+				fflush(trace_file);
+			#endif
+			#ifndef ALLOW_FREE_NULL
+			{/*C-blokk*/
+				call_t call;
+				call = pack(FFREE,par_txt,line,file);
+				die("free(NULL) hivasa:",NULL,0,NULL,&call);
+			}/*C-blokk*/
+			#endif
+		}
+	}
+
+	void * traced_realloc(void * old, size_t size, const char * par_txt, int line, const char * file) {
+		void * p;
+        size_t oldsize = 0;
+		registry_item * n;
+		initialize();
+
+		#ifdef MEMTRACE_TO_MEMORY
+        		n = find_registry_item(P(old));
+        		if (n) oldsize = n->next->size;
+			p = canary_malloc(size, random_byte);
+        	#else
+        		p = realloc(old, size);
+        	#endif
+		if (p) {
+			/*Ha sikerult a foglalas, regisztraljuk*/
+			register_memory(p,size,pack(FREALLOC, par_txt, line,file));
+            		if (old) {
+				#ifdef MEMTRACE_TO_MEMORY
+					int cpsize = 2*CANARY_LEN;
+                			if (oldsize < size) cpsize += oldsize;
+                			else cpsize += size;
+                			memcpy(p, P(old), cpsize);
+				#endif
+		    			unregister_memory(P(old), pack(FREALLOC, par_txt, line, file));
+				#ifdef MEMTRACE_TO_MEMORY
+                			free P(old);
+            			#endif
+            		}
+            		return PU(p);
+		} else {
+	    		return NULL;
+        	}
+	}
+
+END_NAMESPACE
+#endif/*MEMTRACE_C*/
+
+/*******************************************************************/
+/* C++-stlus memriakezels */
+/*******************************************************************/
+
+#ifdef MEMTRACE_CPP
+START_NAMESPACE
+	std::new_handler _new_handler;
+
+	void _set_new_handler(std::new_handler h) {
+		initialize();
+		_new_handler = h;
+	}
+
+	static call_t delete_call;
+	static BOOL delete_called;
+
+	void set_delete_call(int line, const char * file) {
+		initialize();
+		delete_call=pack(0,"",line,file); /*func rtke lnyegtelen, majd fellrjuk*/
+		delete_called = TRUE;
+	}
+
+	void * traced_new(size_t size, int line, const char * file, int func) {
+		initialize();
+		for (;;) {
+			void * p = canary_malloc(size, random_byte);
+			if(p) {
+				register_memory(p,size,pack(func,"",line,file));
+				return PU(p);
+			}
+
+			if (_new_handler == 0)
+				throw std::bad_alloc();
+
+			_new_handler();
+		}
+	}
+
+	void traced_delete(void * pu, int func) {
+		initialize();
+		if(pu) {
+			/*kiolvasom call-t, ha van*/
+			memtrace::call_t call = delete_called ? (delete_call.f=func, delete_call) : pack(func,NULL,0,NULL);
+			memtrace::unregister_memory(P(pu),call);
+			free(P(pu));
+		}
+		delete_called=FALSE;
+ 	}
+END_NAMESPACE
+
+void * operator new(size_t size, int line, const char * file) THROW_BADALLOC {
+	return memtrace::traced_new(size,line,file,FNEW);
+}
+
+void * operator new[](size_t size, int line, const char * file) THROW_BADALLOC {
+	return memtrace::traced_new(size,line,file,FNEWARR);
+}
+
+void * operator new(size_t size) THROW_BADALLOC {
+	return memtrace::traced_new(size,0,NULL,FNEW);
+}
+
+void * operator new[](size_t size) THROW_BADALLOC {
+	return memtrace::traced_new(size,0,NULL,FNEWARR);
+}
+
+void operator delete(void * p) THROW_NOTHING {
+	memtrace::traced_delete(p,FDELETE);
+}
+
+void operator delete[](void * p) THROW_NOTHING {
+	memtrace::traced_delete(p,FDELETEARR);
+}
+
+
+/* Visual C++ 2012 miatt kell, mert hklis, hogy nincs megfelel delete, br senki sem hasznlja */
+void operator delete(void * p, int, const char *) THROW_NOTHING {
+	memtrace::traced_delete(p,FDELETE);
+}
+
+void operator delete[](void * p, int, const char *) THROW_NOTHING {
+	memtrace::traced_delete(p,FDELETE);
+}
+
+#endif/*MEMTRACE_CPP*/
+
+/*******************************************************************/
+/* initialize */
+/*******************************************************************/
+
+START_NAMESPACE
+	static void initialize() {
+		static BOOL first = TRUE;
+		if(first) {
+            fperror = stderr;
+            random_byte = (unsigned char)time(NULL);
+			first = FALSE;
+			dying = FALSE;
+			#ifdef MEMTRACE_TO_MEMORY
+				registry.next = NULL;
+				#if !defined(USE_ATEXIT_OBJECT) && defined(MEMTRACE_AUTO)
+					atexit((void(*)())mem_check);
+				#endif
+			#endif
+			#ifdef MEMTRACE_TO_FILE
+				trace_file = fopen("memtrace.dump","w");
+			#endif
+			#ifdef MEMTRACE_CPP
+				_new_handler = NULL;
+				delete_called = FALSE;
+				delete_call = pack(0,NULL,0,NULL);
+			#endif
+		}
+	}
+
+#if defined(MEMTRACE_TO_MEMORY) && defined(USE_ATEXIT_OBJECT)
+    int atexit_class::counter = 0;
+    int atexit_class::err = 0;
+#endif
+END_NAMESPACE
+#endif

Kesz/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.
+include-ok:  2017, 2018.
+*********************************/
+
+#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
+
+/* A Visual Studio figyelmen kivul hagyja a "throw" deklaraciokat, a gcc -pedantic pedig igenyli.*/
+#ifdef _MSC_VER
+	/* Ha studio */
+	#define THROW_BADALLOC
+	#define THROW_NOTHING
+#else
+	/* Normalis forditok */
+	#define THROW_BADALLOC throw (std::bad_alloc)
+	#define THROW_NOTHING throw ()
+#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-szel összeakadó headereket, hogy elõbb legyenek */
+
+	#include <fstream>  // VS 2013 headerjében van deleted definició
+	#include <sstream>
+	#include <vector>
+	#include <algorithm>
+#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);
+
+
+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*/
+#endif /*MEMCHECK*/
+#endif /*MEMTRACE_H*/

Kesz/standard_input.txt

+4 // TXT fájl feldolgozását szemlélteti
+1 // int tömb tesztje
+10 // 10 adat (index érték) lesz
+0 1
+2 3
+25 4
+34 5
+1 2
+5 8
+9 10
+50 -1
+2 // double tömb tesztje
+6 // 6 adat (index érték) lesz. Lesz közte hibás index.
+3 7.1
+7 3.8
+99 99.3
+44 8.4
+4 99
+-1 3
+3 // sztringeket tartalmazó tömb tesztje
+6 // 6 index értek pár lesz. Az értek most egy string.
+3 stop soros C++
+1 stop konstruktor
+4 stop hazugság
+5 stop destruktor
+10 ez mar a vége
+11 ne tovább
+0

Kesz/valami_adat.dat

+Ez egy WinX textfile.
+Figyelje meg a sorvegeket LINUX alatt.