Teszt osztályok készülgetnek. Súlyos tervezési hibára bukkantam. Mivel a...

Teszt osztályok készülgetnek. Súlyos tervezési hibára bukkantam. Mivel a process osztálynak a destruktora hívja meg a mem::free() függvényt, így az össze sbiankó példánynál lefut, azaz egy érték szerinti paraméterátadáskor a memóriában a foglalás és a felszabadítás is végbemegy. A legnagyobb problémát akkor okozza, ha konstruktorral hozom létre a paramétert.

NHF/include/heap.h

@@ -37,7 +37,6 @@ class heap
          */
 		const memnum get_size() const { return size; }
 
-		//A hibakezelésre fonatkozó leírást ki kell egészíteni, ha elkészül a hibakezelés
         /** \brief Ha lehetséges, lefoglal egy megadott méretű memóriaterületet.
          * Túl nagy igényelt blokkméret esetén domain_error hibát dob.
          * Túl nagy igényelt blokkméretnek számít, ha a megadott érték nagyobb,
@@ -49,7 +48,6 @@ class heap
          */
 		memnum allocate(const memnum block_size);
 
-		//A hibakezelésre fonatkozó leírást ki kell egészíteni, ha elkészül a hibakezelés
         /** \brief Megszűnteti a kapott pid-val kezdődő memóriafoglalást.
          * Ha a pid ürest területre mutat vagy egy memóriablokk belsejébe,
          * akkor invalid_pid hibát dob.

NHF/include/proc_test.h

 #ifndef PROC_TEST_H
 #define PROC_TEST_H
 
-#include "process.h"
 #include <string>
 
+#include "process.h"
+
 
 /** \brief A teszteléshez használatos osztály.
- * A kiegészítés az emberi oldalról való kezelhetőség miatt szükséges
- * Egy láncolt lista adatszerkezetet valósít meg
+ * A kiegészítés az emberi oldalról való kezelhetőség miatt szükséges.
+ * Egy láncolt lista egy tagja.
 */
 class proc_test : public process
 {
 	public:
+
+        /** \brief
+         *
+         * \param name const std::string A process neve
+         * \param proc process A process, amit tárolni szeretnénk.
+         *
+         */
 		proc_test(const std::string name, process proc):process(proc),name(name),next(NULL){}
 		std::string get_name() const { return name; }
-		proc_test* get_next() const { return next; }
+		proc_test* const get_next() const { return next; }
 	private:
 		std::string name;/**< A process neve */
-		proc_test* next;
-		proc_test(const proc_test& other);
+		proc_test* next;/**< A következő listaelemre mutató pointer */
+		//proc_test(const proc_test& other);
+		//ez a szerencsétlen osztály nem is tárol dinamikius adattagot...
+		friend class test_container;
 };
 
 #endif // PROC_TEST_H

NHF/include/process.h

@@ -19,6 +19,8 @@ class process
          */
 		process(memnum block_size, heap& mem):mem(mem){pid=mem.allocate(block_size);}
 
+		//process(process& other):mem(this->mem){pid=this->pid;}
+
         /** \brief A heap::free() függvényen keresztül jelzi a memória felé,
          *  hogy nincs már szüksége a foglalt blokkra.
          *
@@ -30,6 +32,7 @@ class process
 		memnum pid;/**< A process pid-ja */
 		heap& mem;/**< A memóriamodul, amelyben a process a memóriát megkapta */
 	private:
+
 };
 
 #endif // PROCESS_H

NHF/include/test_container.h

@@ -3,16 +3,33 @@
 
 #include "proc_test.h"
 
+
+/** \brief Egy láncolt listában eltárolja a kapott processeket (proc_test)
+ */
 class test_container
 {
 	public:
 		test_container():list_head(NULL){}
 		~test_container();
-		void add(proc_test proc);
+
+        /** \brief Beszúrja a kapott process-t a láncolt lista végére
+         *
+         * \param proc proc_test A beszúrni kívánt process
+         * \return void
+         *
+         */
+		void add(proc_test* proc);
+		//hibát lehet kezelni, amikor a név nincs benne, vagy üres az egész, ilyesmi
+        /** \brief Kitörli a megadott nevű process-t a listából.
+         *
+         * \param name const std::string A kiirtandó process neve
+         * \return void
+         *
+         */
 		void kill(const std::string name);
 	protected:
 	private:
-		proc_test* list_head;
+		proc_test* list_head;/**< A lista első elemére mutató pointer */
 		test_container(const test_container& other);
 };
 

NHF/main.cpp

@@ -7,18 +7,9 @@ using namespace std;
 
 int main()
 {
-	heap mem(23);
-	cout<<mem;
-	cout<<mem.allocate(5)<<endl;///0
-	cout<<mem.allocate(2)<<endl;///5
-	cout<<mem.allocate(3)<<endl;///7
-	cout<<mem.allocate(5)<<endl;///10
-	cout<<mem;
-	mem.free(5);
-	mem.free(10);
-	cout<<mem;
-	cout<<mem.allocate(1)<<endl;
-	mem.free(7);
-	cout<<mem;
+	heap mem(200);
+	test_container c;
+	c.add(new proc_test("pidgin",process(50,mem)));
+	c.add(new proc_test("libpurple",process(20,mem)));
 	return 0;
 }

NHF/src/test_container.cpp

 #include "test_container.h"
 
+void test_container::kill(const std::string name)
+{
+	if(list_head==NULL) return;
+	proc_test *k, *i;
+	if(list_head->get_name()==name)
+	{
+		k=list_head;
+		list_head=list_head->next;
+		delete k;
+		return;
+	}
+	for(i=list_head; i->next->get_name()!=name; i=i->next){}
+	//i a törlendő elem előtt áll
+	k=i->next;
+	i->next=k->next;
+	delete k;
+}
 
 test_container::~test_container()
 {
+	while(list_head!=NULL)
+	{
+		kill(list_head->get_name());
+	}
+/*
 	//az iterálást a végén még tesztelni kell
 	for(proc_test *i=list_head, *j=i->get_next();
 			i!=NULL;
@@ -10,4 +32,19 @@ test_container::~test_container()
 	{
 		delete i;
 	}
+*/
+}
+
+void test_container::add(proc_test* proc)
+{
+	if(list_head==NULL);
+	{
+		list_head=proc;//remélhetőleg az implicit másoló konstruktor hívódik
+								//mivel a proc_test konstruktora NULL-ra éllítja a next-et, itt az implicit másoló pont megfelel
+		return;
+	}
+	proc_test *i;
+	for(i=list_head; i->get_next()!=NULL; i=i->get_next()){}
+	//i most pont az utolsó elemen áll
+	i->next=proc;
 }