v0

CppHetero.cbp

+<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
+<CodeBlocks_project_file>
+	<FileVersion major="1" minor="6" />
+	<Project>
+		<Option title="CppHetero" />
+		<Option pch_mode="2" />
+		<Option compiler="gcc" />
+		<Build>
+			<Target title="Debug">
+				<Option output="bin/Debug/Cpp Hetero" 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/Cpp Hetero" 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="bacterium.h" />
+		<Unit filename="gtest_lite.h" />
+		<Unit filename="hetero_store.hpp" />
+		<Unit filename="hetero_test.cpp" />
+		<Unit filename="memtrace.cpp" />
+		<Unit filename="memtrace.h" />
+		<Unit filename="testclass.h" />
+		<Extensions>
+			<code_completion />
+			<envvars />
+			<debugger />
+		</Extensions>
+	</Project>
+</CodeBlocks_project_file>

Makefile

+#
+# Makefile pelda a pstring feladat megoldasanak forditasara 
+# gnumake valtozat
+# 	Linuxokon es ural2-n is elerheto
+#
+PROG = hetero_test   # a program neve (ezt allitjuk elo)
+PROG_O = hetero_test.o # program object fajljai 
+PROG_H = hetero_store.hpp bacterium.h 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

+**Készítsen** heterogén kollekciók tárolásához sablon osztályt (**HeteroStore**)! 
+Az osztály fix méretű belső tömbben tárolja a heterogén gyűjteményhez tartozó objektumok pointereit! 
+Sablonparaméterként vegye át az alaposztály típusát, a belső tároló méretét, 
+valamint egy kivétel osztályt, amit hiba esetén eldob (ld. később)! 
+Amennyiben ez nincs megadva, akkor az *std::out_of_range* kivételt dobja! 
+Ha a méretet sem adják meg, akkor azt 100 értékűnek vegye! 
+Az alábbi kódrészlet a sablon példányosítására mutat néhány példát:
+
+    HeteroStore<Ember>  t1;  
+    HeteroStore<Ember, 3>  t2;
+    HeteroStore<Valami, 4, MyClass>  t3;
+
+Ahol:
+
+- t1 - 100 elemű tároló, ami *Ember\** típusú pointert tárol. Ha betelik, *std::out_of_range* kivételt dob.
+- t2 - 3 elemű tároló, ami *Ember\** típusú pointert tárol. Ha betelik, std::out_of_range kivételt dob.
+- t3 - 4 elemű tároló, ami  *Valami\** típusú pointert tárol. Ha betelik, *MyClass* kivételt dob.
+   
+**Valósítsa** meg a *HeteroStore* osztályban az alábbi metódusokat:
+
+- **size_t size()** - megadja a tárolt pointerek számát
+- **size_t capacity()** - megadja a tároló maximális méretét.
+- **void add(p)** - beteszi a tárolóba a paraméterként kapott pointert. 
+  Amennyiben a tárolóba már nem tudja betenni a pointert, dobjon kivételt! 
+- **void traverse(func)** - a tároló minden elemével (pointerrel) meghívja a paraméterként 
+  kapott funktort (func).
+- **void clear()** - törli (felszabadítja) a tárolóban tárolt objektumokat.
+   
+Ne legyenek a **HeteroStore** osztályból létrehozott példányok másolhatók és értékadás műveletük 
+se legyen elérhető!
+
+**Feladatok:**
+
+1. Töltse le az előkészített projektet a tantárgy git tárolójából! 
+   [https://git.ik.bme.hu/Prog2/ell_feladat/CppHetero](https://git.ik.bme.hu/Prog2/ell_feladat/CppHetero)
+2. Készítse el a **HeteroStore** osztályt a *hetero_store.hpp* állományban! 
+3. Tesztelje a megadott tesztprogrammal az új osztályt! 
+4. Amennyiben a tesztek jól futnak, töltse fel a *JPorta* feladatbeadó rendszerbe a **hetero\_store.hpp** fájlt!
+
+**Megjegyzések:**
+
+- Dinamikusan keletkező objektumok esetében fontos kérdés, hogy ki hozza létre és ki szünteti meg az objektumot, 
+  azaz mikor ki felel az objektumért. Ügyeljen arra, hogy a tárolónak átadott **"objektumért" a tároló felel**. 
+  Még akkor is, ha nem tudta elhelyezni azt a  tárolóban.
+- A **traverse** tagfüggvény maga is egy sablon az osztályon belül. Megvalósítása formailag hasonlít az 
+  iterátoros konstruktorok megvalósításához. 

bacterium.h

+/**
+ *  \file: bacterium.h
+ *
+ *  Bacterium alaposztály és leszármazottjai
+ */
+
+#ifndef BACTERIUM_H
+#define BACTERIUM_H
+
+#include <string>
+
+/// Bacterium osztály.
+class Bacterium {
+    std::string name;
+public:
+    /// @param n - baktérium neve
+    Bacterium(const char *n = "") : name(n) {}
+
+    /// show
+    /// @param os - adatfolyam amire kiírja a nevét
+    virtual void show(std::ostream& os) const {
+        os << "Bakterium " << name;
+    };
+    virtual ~Bacterium() {}
+};
+
+/// Salmonella osztály.
+class Salmonella : public Bacterium {
+    std::string species;     // faj neve
+public:
+    /// @param n - salmonella fajtája
+    Salmonella(const char *sp) :Bacterium("Salmonella"), species(sp) {}
+
+    /// show
+    /// @param os - adatfolyam amire kiírja a nevét és fajtáját
+    void show(std::ostream& os) const {
+        Bacterium::show(os);
+        os << " Fajta: " << species;
+    }
+};
+
+/// Streptococcus osztály.
+class  Streptococcus : public Bacterium {
+    char group;     // csoport neve
+public:
+    /// @param n - Streptococus baci csoportja
+    Streptococcus(char grp) :Bacterium("Streptococcus"), group(grp) {}
+
+    /// show
+    /// @param os - adatfolyam amire kiírja a nevét és csoportját
+    void show(std::ostream& os) const {
+        Bacterium::show(os);
+        os << " Csoport: " << group;
+    }
+};
+
+/// Funktor a kiíráshoz
+/// Konstruktor paraméterben megadott adatfolyamra ír
+class BacteriumShow {
+    std::ostream& os;
+public:
+    BacteriumShow(std::ostream& os = std::cout) :os(os) {}
+    void operator()(Bacterium *p) {
+        p->show(os);
+        os << std::endl;
+    }
+};
+#endif // BACTERIUM_H

hetero_store.hpp

+/**
+ * \file: hetero_store.hpp
+ *
+ */
+
+#ifndef HETEROSTORE_HPP
+#define HETEROSTORE_HPP
+
+#include <iostream>
+#include <stdexcept>
+
+
+#error "Itt készítse el a HeteroStore sablont!"
+
+
+#endif // HETEROSTORE_HPP

hetero_test.cpp

+#include <iostream>
+#include <sstream>
+
+#include "gtest_lite.h"
+#include "memtrace.h"
+#include "hetero_store.hpp"
+#include "testclass.h"
+#include "bacterium.h"
+
+/// Csak az ellenőrzéshez
+struct MyException : std::exception {
+    MyException(...) {}
+};
+
+int main() {
+    GTINIT(std::cin);       // Csak C(J)PORTA működéséhez kell
+
+    /// Csak a méreteket ellenőrizzük
+    TEST(Test1, sanity) {
+        HeteroStore<TestClass, 2> t1;
+        EXPECT_EQ((size_t)0, t1.size()) << "Nem ures?" << std::endl;
+        EXPECT_EQ((size_t)2, t1.capacity()) <<  "Nem jo kapacitas erteke!" << std::endl;
+        EXPECT_NO_THROW(t1.add(NULL)) << "Nem jo a meret!" << std::endl;
+        EXPECT_EQ((size_t)1, t1.size());
+        EXPECT_EQ((size_t)2, t1.capacity()) << "Megvaltozott a kapacitas?" << std::endl;
+        EXPECT_NO_THROW(t1.add(NULL));
+        EXPECT_EQ((size_t)2, t1.size())  << "Nem jo a meret!" << std::endl;
+        EXPECT_EQ((size_t)2, t1.capacity()) << "Megvaltozott a kapacitas?" << std::endl;
+        EXPECT_THROW(t1.add(NULL), std::out_of_range);
+
+        t1.clear();
+        EXPECT_EQ((size_t)0, t1.size()) << "Nem torlodott?" << std::endl;
+        EXPECT_EQ((size_t)2, t1.capacity()) << "Megvaltozott a kapacitas?" << std::endl;
+    } ENDM
+
+   /// Méreteket ellenőrizzük és azt, hogy törli-e az objektumokat
+   TEST(Test2, obj) {
+        HeteroStore<TestClass, 1, MyException> t1;
+        EXPECT_EQ((size_t)0, t1.size());
+        EXPECT_EQ((size_t)1, t1.capacity());
+        EXPECT_NO_THROW(t1.add(new TestClass2));
+        EXPECT_EQ((size_t)1, t1.size());
+        EXPECT_EQ((size_t)1, t1.capacity());
+    } ENDMsg("Megszuneskor felszabaditotta a tarolora bizott objektumokat?")
+
+    /// Ellenőrizzuk a kivételt valós objekummal
+    TEST(Test3, exception) {
+        HeteroStore<TestClass, 1, MyException> t1;
+        EXPECT_EQ((size_t)0, t1.size());
+        EXPECT_EQ((size_t)1, t1.capacity());
+        EXPECT_NO_THROW(t1.add(new TestClass2));
+        EXPECT_EQ((size_t)1, t1.size());
+        EXPECT_EQ((size_t)1, t1.capacity());
+        EXPECT_THROW(t1.add(new TestClass2), MyException);
+    } ENDMsg("Torolte azt az objektumot, ami mar nem fert bele?")
+
+    /// Traverse tesztelése és megnézzük, hogy van-e esetleg szeletelődés
+    TEST(Test4, heterogen) {
+        HeteroStore<TestClass> t1;
+        EXPECT_EQ((size_t)100, t1.capacity()) <<  "Nem jo default kapacitas erteke!" << std::endl;
+        t1.add(new TestClass1(1));
+        t1.add(new TestClass1(2));
+        t1.add(new TestClass2("Hello"));
+        t1.add(new TestClass2("World"));
+        t1.add(new TestClass1(3));
+        t1.add(new TestClass2("Bye"));
+        std::stringstream ss;
+
+        TestClassPrint print(ss);
+        t1.traverse(print);
+        EXPECT_TRUE(0 != ss.str().size()) << "Nem irt ki semmit! Traverse mukodik?" << std::endl;
+        if (ss.str().size() != 0)
+            EXPECT_STREQ("1;2;Hello;World;3;Bye;", ss.str().c_str()) <<
+                                                    "Valami baj van! Szeletelodes?" << std::endl;
+    } ENDM
+
+    /// Itt egy másik alaposztályból származóaknak hozunk létre tárolót
+    TEST(Test5, bacterium) {
+        HeteroStore<Bacterium> petri;
+        petri.add(new Salmonella("bongori"));
+        petri.add(new Salmonella("enterica"));
+        petri.add(new Streptococcus('A'));
+        petri.add(new Streptococcus('B'));
+
+        EXPECT_EQ((size_t)4, petri.size());
+        BacteriumShow show;
+        petri.traverse(show);
+    } ENDM
+
+    GTEND(std::cerr);       // Csak C(J)PORTA működéséhez kell
+    return 0;
+}

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.
+struct TestClass {
+    virtual void print(std::ostream& os) const {} ;
+    virtual ~TestClass() {}
+};
+
+/// TestClass1 osztály.
+class TestClass1 : public TestClass {
+    int adat;
+public:
+    TestClass1(int a = 0) : adat(a) { }
+    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 TestClassPrint {
+    std::ostream& os;
+public:
+    TestClassPrint(std::ostream& os = std::cout) :os(os) {}
+    void operator()(TestClass *p) {
+        p->print(os);
+    }
+};
+
+#endif // TESTCLASS_H