init

Makefile

+#
+# Makefile pelda a pstring feladat megoldasanak forditasara 
+# gnumake valtozat
+# 	Linuxokon es ural2-n is elerheto
+#
+PROG = tar_test   # a program neve (ezt allitjuk elo)
+PROG_O = tart_test.o # program object fajljai 
+PROG_H = tar.hpp gtest_lite.h testclass.h # program header fajljai
+PROG_L =              # program libjei
+
+MTRACE_O = memtrace.o # memtrace object fajl
+MTRACE_H = memtrace.h # memtrace es memcheck header fajlja
+
+CXX = g++   # a C fordito neve
+#CXX = clang++ # clang-ot (llvm) is erdemes kiprobalni
+CXXFLAGS = -pedantic -Wall -Werror -std=c++03 # kapcsolok: legyen bobeszedu es pedans
+CXXFLAGS += -ggdb -DMEMTRACE # es legyen debug info is
+LDFLAGS = -ggdb # debug a linkelesnel 
+
+# osszes object, osszes header osszes lib
+OBJS = $(PROG_O) $(MTRACE_O)
+HEADS = $(PROG_H) $(MTRACE_H)
+LIBS = $(PROG_L) 
+
+# alapertelmezett cel: program
+.PHONY: all
+all: $(PROG)
+
+$(PROG): $(OBJS)
+	$(CXX) $(LDFLAGS) $(OBJS) -o $@ $(LIBS)
+
+# feltetelezzuk, hogy az osszes obj fugg az osszes headertol
+$(OBJS): $(HEADS)
+
+# takaritas igeny szerint
+.PHONY: clean
+clean:
+	rm -f $(OBJS) $(PROG)
+

README.md

+**IMSC feladat**
+
+A feladat a nagy zárthelyi 2. feladatának egy módosított változata.
+
+**Készítsen** adapter sablont (Tar), ami minden szabványos sorozattárolóra alkalmazható és segíti a 
+pointerekkel hivatkozott objektumok tárolását, ugyanakkor **képes nem pointer** típusú adatokat is tárolni. 
+Az adapter a sorozattárolók működését/tulajdonságait csupán a következőkben változtatja meg:
+
+1. Nem csak a tárolóba tett adatokat birtokolja, hanem amennyiben az adat pointer, akkor a 
+hivatkozott objektumokat is, így azokat megszünteti, ha a tároló megszűnik, vagy elemeit 
+törlik (clear(), erase(), pop_back()). (Feltételezzük, hogy a pointer a dinamikus területre mutat.) 
+2. Van egy traverse() tagfüggvénye is, ami a tároló minden adatával meghívja a paraméterként kapott 
+egyoperandusú függvényt, vagy funktort.
+
+A többi metódust, típust változatlanul elérhetővé teszi még akkor is, ha azok használatával a hivatkozott 
+objektumok "felügyelete" kikerülhető. Az adapter sablonparaméterként vegye át a tárolandó pointertípust és a tárolót. 
+Amennyiben ez utóbbi nincs megadva, akkor azt az *std::vector* sablonból hozza létre! 
+Az alábbi kódrészlet a sablon példányosítására és használatára mutat példát:
+
+    Tar<Ember*> t1; 
+    Tar<Ember*, std::deque<Ember*> > t2; 
+    t1.push_back(new Ember); // Létrehoztunk Ember objektumot, és "rábíztuk" a tárolóra.
+    t1.push_back(new Ember);
+    t1.traverse(func1);      // t1-ben tárolt minden adattal meghívjuk a func1 egyoperandusú függvényt, vagy funktort.
+    Tar<int> t3;  
+    t3.traverse(func3);     // t3-ben tárolt minden adattal meghívjuk a func3 egyoperandusú függvényt, vagy funktort.
+Ahol:
+
+- t1 - *Ember\** típusú pointereket tárol *std::vector* segítségével.
+- t2 - *Ember\** típusú pointereket tárol *std::deque* segítségével.
+- t3 - egészeket tárol *std::vector* segítségével. 
+   
+Amennyiben a tárolóban pointer van, úgy a *Tar* osztályból létrehozott példányok *másolásakor*, 
+vagy *értékadásakor* **dobjon** *std::domain:error* kivételt!
+
+
+**Feladatok:**
+
+1. Töltse le az előkészített projektet a tantárgy git tárolójából és elezze a kódot! 
+   [https://git.ik.bme.hu/Prog2/ell_feladat/CppTar](https://git.ik.bme.hu/Prog2/ell_feladat/CppTar)
+2. Készítse el a **Tar** osztályt a *tar.hpp* állományban, amiben definiálja az **ELKESZULT** makrót 
+a sablon készültségi fokának megfelelő értékkel (1-15)!
+4. Tesztelje a megadott tesztprogrammal a sablont! 
+5. Amennyiben a tesztek jól futnak, töltse fel a *JPorta* feladatbeadó rendszerbe a **Tar.hpp** fájlt!
+
+**Megjegyzés:**
+
+- Nem kell minden részfeladatot elkészítenie. Az **ELKESZULT** makró értékét arra a legmagasabb értékre állítsa, amivel még 
+hibamentesen fut a teszt.
+- **IMSC** pontot az **ELKESZULT** makró értekétől függően kap! A kódban megtalalálja, hogy milyen értékhez hány pont tartozik.
\ No newline at end of file

cpptar.cbp

+<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
+<CodeBlocks_project_file>
+	<FileVersion major="1" minor="6" />
+	<Project>
+		<Option title="CppTar" />
+		<Option pch_mode="2" />
+		<Option compiler="gcc" />
+		<Build>
+			<Target title="Debug">
+				<Option output="bin/Debug/CppTar" 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/CppTar" prefix_auto="1" extension_auto="1" />
+				<Option object_output="obj/Release/" />
+				<Option type="1" />
+				<Option compiler="gcc" />
+				<Compiler>
+					<Add option="-O2" />
+				</Compiler>
+				<Linker>
+					<Add option="-s" />
+				</Linker>
+			</Target>
+		</Build>
+		<Compiler>
+			<Add option="-pedantic" />
+			<Add option="-std=c++11" />
+			<Add option="-Wall" />
+			<Add option="-Werror" />
+		</Compiler>
+		<Unit filename="gtest_lite.h" />
+		<Unit filename="memtrace.cpp" />
+		<Unit filename="memtrace.h" />
+		<Unit filename="tar_test.cpp" />
+		<Unit filename="testclass.h" />
+		<Extensions>
+			<code_completion />
+			<envvars />
+			<debugger />
+		</Extensions>
+	</Project>
+</CodeBlocks_project_file>

memtrace.h

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

testclass.h

+/**
+ *  \file: bacterium.h
+ *
+ *  TestClass alaposztály és leszármazottjai
+ */
+
+#ifndef TESTCLASS_H
+#define TESTCLASS_H
+
+#include <string>
+
+/// TestClass osztály.
+class TestClass {
+    static int numobj;
+public:
+    TestClass() { numobj++; }
+    virtual void print(std::ostream& os) const {}
+    static int get() { return numobj; }
+    virtual ~TestClass() { numobj--; }
+};
+
+int TestClass::numobj = 0;
+
+/// TestClass1 osztály.
+class TestClass1 : public TestClass {
+    int adat;
+    int id;
+public:
+    TestClass1(int a = 0) : adat(a), id(get()) { }
+    int getId() const { return id; }
+    void print(std::ostream& os) const {
+        os << adat << ';';
+    }
+};
+
+/// TestClass2 osztály.
+class TestClass2 : public TestClass {
+    std::string str;
+public:
+    TestClass2(std::string s = "") : str(s) {}
+    void print(std::ostream& os) const {
+        os << str << ';';
+    }
+};
+
+/// Funktor a kiíráshoz
+/// Konstruktor paraméterben megadott adatfolyamra ír
+class TestClass2Print {
+    std::ostream& os;
+public:
+    TestClass2Print(std::ostream& os = std::cout) :os(os) {}
+    void operator()(TestClass2 p) {
+        p.print(os);
+    }
+};
+
+/// Funktor a kiíráshoz
+/// Konstruktor paraméterben megadott adatfolyamra ír
+class TestClassPrint {
+    std::ostream& os;
+public:
+    TestClassPrint(std::ostream& os = std::cout) :os(os) {}
+    void operator()(TestClass *p) {
+        p->print(os);
+    }
+};
+
+#endif // TESTCLASS_H