Extra szűrések:

 - explicit destruktorhívás
 - poligon megvalósítás check
 - clone check

Alakzatlab3/alakzat.cbp

@@ -38,6 +38,7 @@
 		<Unit filename="alakzat.h" />
 		<Unit filename="alakzat3_main.cpp" />
 		<Unit filename="gen_array2.hpp" />
+		<Unit filename="gtest_lite.h" />
 		<Unit filename="kor.cpp" />
 		<Unit filename="kor.h" />
 		<Unit filename="memtrace.cpp" />

Alakzatlab3/alakzat.cpp

@@ -19,3 +19,5 @@ void Alakzat::mozgat(const Pont& d) {
 std::ostream& operator<<(std::ostream& os, const Alakzat& a) {
     return os << "p0=" << a.getp0() << ",szin=" << a.getsz();
 }
+
+const char* Alakzat::juj = "\n\n *** Juj, ez hogy tortenhetett? Explicit destruktor hivas? ***\n\n";

Alakzatlab3/alakzat.h

 /**
  *  \file alakzat.h
  *  Alakzat alaposztály deklarációja
+ *
+ * *** Extra teszt az explicit destruktorhívás megcsípéséhez. ***
+ * *** Tilos a destruktort explicit meghívni, főleg saját tagfüggvényből! ***
+ *
  */
 #ifndef ALAKZAT_H
 #define ALAKZAT_H
 
 #include <iostream>         // ostream miatt kell
-#include "memtrace.h"
+#include "memtrace.h"       // nagy valószínűséggel minden használt headert behúz
 #include "pont.h"
 #include "szin.h"
 
@@ -15,11 +19,39 @@ class Alakzat {
      Pont p0;                   /// Alakzat origója, vagy bázis pontja.
      /// Minden további adatot ehhez relatívan tárolunk. Geometriai értelemben nem feltétlenül origó.
      Szin sz;                   /// alakzat színe
+     char *dummy;               /// Explicit destrutorhívás teszteléséhez
+     static const char* juj;    /// Nagyon fájdalmas üzenet
 public:
     /// Konstruktor
     /// @param p0 - kezdőpont
     /// @param sz - szín és átlátszóság
-    Alakzat(const Pont& p0, const Szin& sz) :p0(p0), sz(sz) {}
+    Alakzat(const Pont& p0, const Szin& sz) :p0(p0), sz(sz), dummy(new char[100]) {}
+
+	/// Másoló konstruktor,
+	/// mert van dinamikus adattag, amit kezel
+    Alakzat(const Alakzat& rhs) {
+        dummy = NULL;
+        *this = rhs;
+    }
+
+	/// Értékadó operator,
+	/// mert van dinamikus adattag, amit kezel
+    Alakzat& operator=(const Alakzat& rhs) {
+        if (this != &rhs) {
+#ifdef MEMTRACE
+		/// Explicit destrutorhívást próbálja felderíteni.
+		/// Elhangzott előadáson, hogy tilos, de mégis van aki megpróbálja.
+            if (!memtrace::poi_check(dummy))
+                std::cerr << juj;
+#endif
+            delete[] dummy;
+            dummy = new char [100];
+            p0 = rhs.p0;
+            sz = rhs.sz;
+        }
+        return *this;
+    }
+
 
     /// Pozíció lekérdezése
     /// @return alakzat origója
@@ -38,7 +70,15 @@ public:
 
     /// Destruktor virtuális, hogy lehessen dinamikus adattagja
     /// a származtatottnak
-    virtual ~Alakzat() {}
+    virtual ~Alakzat() {
+#ifdef MEMTRACE
+		/// Explicit destrutorhívást próbálja felderíteni.
+		/// Elhangzott előadáson, hogy tilos, de mégis van aki megpróbálja.
+        if (!memtrace::poi_check(dummy))
+            std::cerr << juj;
+#endif
+        delete[] dummy;
+    }
 };
 
 /// Globális << operátor az Alakzat adatainak kiírásához

Alakzatlab3/alakzat3_main.cpp

@@ -4,7 +4,7 @@
  *  Bővítjük poligonnal, majd sablont is használunk.
  *
  *  ELKESZULT makró értékei:
- *  == 1 - Van Poligon osztály, amit önmagában kipróbálunk, copy és assign még nincs használva.
+ *  >= 1 - Van Poligon osztály, amit önmagában kipróbálunk, copy és assign még nincs használva.
  *  >= 2 - Poligon assign is tesztelve van.
  *  >= 3 - Poligon assing és copy is tesztelve van
  *  == 4 - Átemelésre került az előző heti Rajztabla osztály a projektbe, poligon nélküli teszt
@@ -33,11 +33,13 @@
 using std::cout;
 using std::endl;
 
+CREATE_Has_fn_(clone, const)    /// clone teszteléséhez kell
+
 int main(int argc, char** argv) {
     GTINIT(std::cin);     // Csak C(J)PORTA működéséhez kell
 
-#if ELKESZULT == 1
-    TEST(Poligon, size) {
+#if ELKESZULT >= 1
+    TEST(Poligon, base) {
         Poligon poli1(Pont(120,140), GREEN);
         EXPECT_EQ(1u, poli1.size()) << "*** Nem jo a kezdo merete ***" << endl;
         poli1.add(Pont(120,200));
@@ -49,6 +51,9 @@ int main(int argc, char** argv) {
         EXPECT_EQ(Pont(120,140), poli1[0]);
         EXPECT_EQ(Pont(120,200), poli1[1]);
         EXPECT_EQ(Pont(250,200), poli1[2]);
+        Alakzat *p = &poli1;
+        p->mozgat(Pont(10,10));
+        EXPECT_EQ(Pont(130,150), poli1[0]) << "*** Biztos, hogy jol tarolja a poligon pontjait? ***\n";
     } ENDM
 #endif // ELKESZULT
 
@@ -137,6 +142,8 @@ int main(int argc, char** argv) {
 
 #if ELKESZULT >= 6
     TEST(Szakasz, clone) {
+        if (!_Has_fn_clone_const<Szakasz*, Szakasz>::fn)
+            FAIL() << "*** Nem konstans clone, vagy nem Szakasz* ***\n";
         Szakasz* psz1 = new Szakasz(Pont(20,40), 100, 0, WHITE);
         cout << *psz1 << endl;
         Szakasz* psz2 = psz1->clone();
@@ -147,6 +154,11 @@ int main(int argc, char** argv) {
         delete psz1;
         EXPECT_EQ(Pont(120,40), psz2->getpv());
         delete psz2;
+        /// clone alapból
+        Alakzat* ap1 = new Szakasz(Pont(20,40), Pont(100,100), GREEN);
+        Alakzat* ap2 = ap1->clone();
+        delete ap1;
+        delete ap2;
     } ENDM
 #endif // ELKESZULT
 
@@ -170,6 +182,24 @@ int main(int argc, char** argv) {
         tabla.rajzol();
         EXPECT_EQ(1u, tabla.size());
     } ENDM
+
+    TEST(Rajztabla, copy) {
+        Rajztabla tabla;
+        tabla.felrak(new Szakasz(Pont(20,40), 100, 0, WHITE));
+        cout << "tabla rajzol::\n";
+        tabla.rajzol();
+        EXPECT_EQ(1u, tabla.size());
+        { // uj blokk, ebben jön létre az új tabla
+            Rajztabla ujtabla = tabla;
+            ujtabla.felrak(new Szakasz(Pont(40,40), 100, 0, WHITE));
+            cout << "\nujtabla rajzol:\n";
+            ujtabla.rajzol();
+            EXPECT_EQ(2u, ujtabla.size());
+        }
+        cout << "\ntabla rajzol:\n";
+        tabla.rajzol();
+        EXPECT_EQ(1u, tabla.size());
+    } ENDM
 #endif // ELKESZULT
 
 #if ELKESZULT >= 8
@@ -198,7 +228,6 @@ int main(int argc, char** argv) {
     } ENDM
 #endif // ELKESZULT
 
-
 /// Itt a vége
     if (ELKESZULT < 5 && !gtest_lite::test.fail())
       ADD_FAILURE() << "\nLegalabb ELEKSZULT == 5-ig oldja meg a feladatokat!\n";

Alakzatlab3/gtest_lite.h

@@ -10,6 +10,7 @@
  * Sz.I. 2019 singleton
  * Sz.I. 2021 ASSERT.., STRCASE...
  * Sz.I. 2021 EXPEXT_REGEXP
+ * Sz.I. 2021 CREATE_Has_fn_
  *
  * A tesztelés legalapvetőbb funkcióit támogató függvények és makrók.
  * Nem szálbiztos megvalósítás.
@@ -187,7 +188,7 @@
 /// https://cpptalk.wordpress.com/2009/09/12/substitution-failure-is-not-an-error-2
 /// Használat:
 /// CREATE_Has_(size)
-/// ... if (Has_size<std::string>::member)...
+/// ... if (_Has_size<std::string>::member)...
 #define CREATE_Has_(X) \
 template<typename T> struct _Has_##X {  \
     struct Fallback { int X; };         \
@@ -198,6 +199,14 @@ template<typename T> struct _Has_##X {  \
     static bool const member = sizeof(f<Derived>(0)) == 2; \
 };
 
+#define CREATE_Has_fn_(X, S) \
+template<typename R, typename T> struct _Has_fn_##X##_##S {  \
+    template<typename C, R (C::*f)() S> struct ChT; \
+    template<typename D> static char (&f(ChT<D, &D::X>*))[1]; \
+    template<typename D> static char (&f(...))[2]; \
+    static bool const fn = sizeof(f<T>(0)) == 1; \
+};
+
 /// Segédfüggvény egy publikus adattag, vagy tagfüggvény létezésének tesztelésére
 /// fordítási időben
 inline void hasMember(...) {}
@@ -273,6 +282,8 @@ public:
 #endif
 #ifndef CPORTA
         std::cerr << "\n---> " << name << std::endl;
+#else
+        std::cout << "\n---> " << name << std::endl;
 #endif // CPORTA
         ++sum;
     }

Alakzatlab3/memtrace.cpp

@@ -5,8 +5,9 @@ Keszitette: Peregi Tamas, BME IIT, 2011
 Kanari:     Szeberenyi Imre, 2013.
 VS 2012:    Szeberényi Imre, 2015.,
 mem_dump:   2016.
-meset felszabaditaskor: 2018.
+memset felszabaditaskor: 2018.
 typo:       2019.
+poi_check:  2021.
 *********************************/
 
 /*definialni kell, ha nem paracssorbol allitjuk be (-DMEMTRACE) */
@@ -178,7 +179,6 @@ START_NAMESPACE
 		dying = TRUE;
 		exit(120);
 	}
-
 	static void initialize();
 END_NAMESPACE
 
@@ -188,6 +188,7 @@ END_NAMESPACE
 
 #ifdef MEMTRACE_TO_MEMORY
 START_NAMESPACE
+
 	typedef struct _registry_item {
 		void * p;    /* mem pointer*/
 		size_t size; /* size*/
@@ -197,6 +198,12 @@ START_NAMESPACE
 
 	static registry_item registry; /*sentinel*/
 
+	static registry_item *find_registry_item(void * p) {
+        registry_item *n = &registry;
+        for(; n->next && n->next->p != p ; n=n->next);
+        return n;
+    }
+
 	static void print_registry_item(registry_item * p) {
 		if (p) {
 			print_registry_item(p->next);
@@ -225,6 +232,13 @@ START_NAMESPACE
 		}
         return 0;
 	}
+
+	/* Ellenorzi, hogy a pointer regisztralt-e. Ha nem, akkor 0-val tér vissza */
+	int poi_check(void *pu) {
+	    if (pu == NULL) return 1;
+		initialize();
+        return find_registry_item(P(pu))->next != NULL;
+	}
 END_NAMESPACE
 #endif/*MEMTRACE_TO_MEMORY*/
 
@@ -271,14 +285,6 @@ START_NAMESPACE
 		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

Alakzatlab3/memtrace.h

@@ -101,7 +101,8 @@ END_NAMESPACE
 
 #if defined(MEMTRACE_TO_MEMORY)
 START_NAMESPACE
-        int mem_check(void);
+    int mem_check(void);
+    int poi_check(void*);
 END_NAMESPACE
 #endif
 
@@ -191,7 +192,6 @@ START_NAMESPACE
 
 	void mem_dump(void const *mem, size_t size, FILE* fp = stdout);
 
-
 END_NAMESPACE
 #endif/*MEMTRACE_C*/