Commit e7334fbc by Szeberényi Imre

V0

parent bc93a041
# 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
File added
#
# 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)
File added
File added
**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
#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
/**
* \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! ****"
/**
* \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! ****"
/**
* \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
}
/**
* \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;
}
<?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>
<?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>
/*********************************
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
/*********************************
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*/
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
Ez egy WinX textfile.
Figyelje meg a sorvegeket LINUX alatt.
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