diff --git a/NHF/include/heap.h b/NHF/include/heap.h
index c32f238c60b00964e7a1a347b82c85756bef4409..0e2f87ea723d1c1a26f162ca2ce84d6962797afd 100644
--- a/NHF/include/heap.h
+++ b/NHF/include/heap.h
@@ -11,7 +11,7 @@
 class heap
 {
 	public:
-        /** \brief Létrehozza a memóriaegységet
+        /** \brief Létrehozza a kért méretű memóriaegységet.
          *
          * \param size const memnum A létrehozandó memóriaegység mérete
          *
@@ -19,14 +19,18 @@ class heap
 		heap(const memnum size);
 		~heap(){delete [] blocks;}
 
-        /** \brief Visszaadja a memória méretét
+        /** \brief Visszaadja a memória méretét.
          *
-         * \return const memnum A méret
+         * \return const memnum A memória mérete
          *
          */
 		const memnum get_size() const { return size; }
 
-        /** \brief Ha lehetséges, lefoglal egy megadott méretű memóriaterületet
+		//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.
+         * Alulhivatkozás, vagy túl nagy igényelt blokkméret esetén hibát dob.
+		 * Túl nagy igényelt blokkméretnek számít, ha a megadott érték nagyobb,
+		 * mint az egész memória, vagy csak a jelenlegi állapot alapján nem fér bele.
          *
          * \param block_size memnum A kívánt méret
          * \return memnum A pid, amivel később a process azonosítani tudja magát
@@ -34,21 +38,51 @@ class heap
          */
 		memnum allocate(const memnum block_size);
 
-        /** \brief Megszűnteti a kapott pid-val kezdődő memóriafoglalást
+		//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 nincs a memóriában, vagy érvénytelen (nem üres területre,
+         * vagy nem egy memória blokk elejére mutat), hibát dob.
          *
          * \param pid memnum A foglalt memória kezdőcíme
          * \return void
          *
          */
 		void free(const memnum pid);
-		friend std::ostream& operator<<(std::ostream& os,heap& mem);
+
+        /** \brief 10%-onként átlagolja a memória telítettségét,
+         * és kirajzolja egy diagrammon. Ha az adott 10% több mint fele
+         * telített, akkor az a 10% telítettnek tekinthető.
+         * Formátum:
+					#------#
+					|......|//telítetlen
+					|......|
+					|......|
+					|======|//telített
+					|======|
+					|======|
+					|......|
+					|......|
+					|......|
+					|======|
+					#------#
+
+         * \param os std::ostream&
+         * \param mem const heap& A kiírandó memória referenciája
+         * \return friend std::ostream& A sorbafűzhetőség miatt
+         *
+         */
+		friend std::ostream& operator<<(std::ostream& os,const heap& mem);
 	protected:
 	private:
 		const memnum size;/**< A memóriamodul mérete */
 		mem_block* blocks;/**< Pointer a foglalt tömbre */
 
+		//A hibakezelésre fonatkozó leírást ki kell egészíteni, ha elkészül a hibakezelés
         /** \brief A worst fit stratégiának megfelelően megkeresi a választott blokk kezdetét.
          * A stratégia szerint a legnagyobb egybefüggő memóriaterületet választja ki.
+         * Ha a meagadott méret nem fér a memóriába, akkor hibát dob vissza.
+         * Ezt a függvényt csak az allocate() hívja, így a hívó fél számára úgy tűnik,
+         * mintha a hibát az dobta volna.
          *
          * \param block_size memnum Az igényelt blokkméret
          * \return memnum A process leendő pid-ja
diff --git a/NHF/include/mem_block.h b/NHF/include/mem_block.h
index c09287dfcfb1095d00bbdc0b1b4ff4d4c76d71d7..6c5f384c06b798cd1cbcdeb93dfacabf89451405 100644
--- a/NHF/include/mem_block.h
+++ b/NHF/include/mem_block.h
@@ -36,7 +36,7 @@ struct mem_block
 
         /** \brief Meghívja set() függvényt paraméterek nélkül.
          * Más szóval alapértelmezett értékre állítja egy memóriablokk tagjait.
-         *
+         * Csak kényelmi funkciója van.
          * \return void
          *
          */
diff --git a/NHF/include/process.h b/NHF/include/process.h
index 4b855f0264321ef55cf0801f09251b59be3c9930..583de88dad0cd832b97ebb70cb10ad6afb752c85 100644
--- a/NHF/include/process.h
+++ b/NHF/include/process.h
@@ -8,7 +8,22 @@
 class process
 {
 	public:
+        /** \brief A paraméterként kapott méretű blokkot kérvényez a memórától
+         * a heap::allocate() függvényen keresztül.
+         *
+         * \param block_size A processznek szükséges memória.
+         * \param mem heap& A paraméterként kapott memória referenciája.
+         * Erre szükség van, különben a processz a későbbiekben nem fogja tuni, hogy
+         * melyik memóriában van, így nem tudja felszabadítási kérvényét jelezni.
+         *
+         */
 		process(memnum block_size, heap& mem):mem(mem){pid=mem.allocate(block_size);}
+
+        /** \brief Jelzi a memória felé, hogy nincs már szüksége a foglalt blokkra.
+         *
+         * \param false
+         *
+         */
 		~process(){mem.free(pid);}
 	protected:
 		memnum pid;/**< A process pid-ja */
diff --git a/NHF/main.cpp b/NHF/main.cpp
index efa44ac7cbb760c7e49a32c7af51b872d6d32d9e..3b542204aed871fee538d19c141c1ca324050d5a 100644
--- a/NHF/main.cpp
+++ b/NHF/main.cpp
@@ -7,7 +7,7 @@ using namespace std;
 
 int main()
 {
-	heap mem(20);
+	heap mem(23);
 	cout<<mem;
 	cout<<mem.allocate(5)<<endl;///0
 	cout<<mem.allocate(2)<<endl;///5
@@ -17,6 +17,7 @@ int main()
 	mem.free(5);
 	mem.free(10);
 	cout<<mem;
+	cout<<mem.allocate(1)<<endl;
 	mem.free(7);
 	cout<<mem;
 	return 0;
diff --git a/NHF/src/heap.cpp b/NHF/src/heap.cpp
index 283dfacd36527fc644d8cf9fcdd831953c0f2265..b5eabbfc17a4e60598371cc87be991b5209fdbba 100644
--- a/NHF/src/heap.cpp
+++ b/NHF/src/heap.cpp
@@ -2,7 +2,7 @@
 
 heap::heap(const memnum size):size(size)
 {
-	blocks=new mem_block[size];
+	blocks=new mem_block[size];//bad_alloc hibát adott esetben illik elkapni
 	blocks[0].block_size=size;//az egész memória egy nagy töltetlen blokk
 }
 
@@ -25,18 +25,10 @@ memnum heap::allocate(const memnum block_size)
 {
 	if(block_size<0)
 		throw "Kivétel";//hibakezelés jobban
-	memnum start;
-	try
-	{
-		start=findfit(block_size);
-	}
-	catch(const char*)
-	{
-
-	}
+	memnum start=findfit(block_size);//A kivételt majd lekezeljük kint.
 	memnum original_block_size=blocks[start].block_size;
 	blocks[start].set(true,block_size);
-	for(memnum i=start+1; i<start+block_size; i++)
+	for(memnum i=start+1; i<start+block_size; i++)//warning: ‘start’ may be used uninitialized in this function [-Wmaybe-uninitialized]|
 		blocks[i].set(true);
 	//Az eredeti blokk maradék részének felparaméterezése
 	memnum new_start=start+block_size;
@@ -51,11 +43,13 @@ void heap::free(const memnum pid)
 		throw "Kivétel";//hibakezelés jobban
 	if(!blocks[pid].filled)
 		throw "Érvénytelen pid.";//hibakezelés jobban
+	else if(blocks[pid].filled && blocks[pid].block_size==0)
+		throw "Érvénytelen pid.";//Az előzőtől különböző üzenetet lehet érdemes visszaadni.
 	memnum next_block_idx=pid+blocks[pid].block_size;
 	for(memnum i=pid+1; i<next_block_idx; i++)
 		blocks[i].reset();
 	/*
-	 * Az új üres blokk méreténél figyelembe kell venni,
+	 * Az új üres blokk létrehozásánál figyelembe kell venni,
 	 * hogy az utána következő blokk telített, illetve,
 	 * hogy az előtte lévő blokk telített-e.
 	 * Ezeket adott esetben össze kell vonni.
@@ -99,9 +93,8 @@ void heap::free(const memnum pid)
         blocks[pid].set(false,new_empty_block_size);
 	}
 }
-
-std::ostream& operator<<(std::ostream& os,heap& mem)
-//Még csak teszt jelleggel, a későbbiekben ez a függvény teljesen más funkcíiót fog ellátni.
+#ifdef DEBUG
+std::ostream& operator<<(std::ostream& os,const heap& mem)
 {
 	for(memnum i=0; i<mem.size;i++)
 	{
@@ -110,3 +103,34 @@ std::ostream& operator<<(std::ostream& os,heap& mem)
 	os<<"-------------------------------------------\n";
 	return os;
 }
+#else
+std::ostream& operator<<(std::ostream& os,const heap& mem)//nem biztos, hogy jó ötlet az, ha kaszkádosítható
+{
+	if(mem.size<10)
+		throw "A memória túl kicsit, nem kiírható.";
+	const char mem_end[]="#------#",
+				filled_unit[]="======",
+				empty_unit[]="......",
+				border='|';
+	os<<mem_end<<std::endl;
+	memnum unit_size=mem.size/10;
+	//A févég fennmaradó rész mindig legfeljebb 10 byte, így elhanyagolható.
+	//A ciklus második kilépési feltétele felelős az elhanyagolásért.
+	for(memnum i=0; i<mem.size && i+unit_size<=mem.size; i+=unit_size)//itt még van egy kis hiba!?
+	{
+		const char *content=NULL;
+		memnum filled=0;
+		for(memnum j=i; j<i+unit_size; j++)
+		{
+			filled+=mem.blocks[j].filled;
+		}
+        if(filled>unit_size/2)
+            content=filled_unit;
+		else
+			content=empty_unit;
+		os<<border<<content<<border<<std::endl;
+	}
+	os<<mem_end<<"\n---------------------------------------"<<std::endl;
+	return os;
+}
+#endif