undel

genArray3/gen_array_iter3.cbp

+<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
+<CodeBlocks_project_file>
+	<FileVersion major="1" minor="6" />
+	<Project>
+		<Option title="gen_array_iter3" />
+		<Option pch_mode="2" />
+		<Option compiler="gcc" />
+		<Build>
+			<Target title="Debug">
+				<Option output="bin/Debug/genarray3" prefix_auto="1" extension_auto="1" />
+				<Option object_output="obj/Debug/" />
+				<Option type="1" />
+				<Option compiler="gcc" />
+				<Compiler>
+					<Add option="-g" />
+				</Compiler>
+			</Target>
+			<Target title="Release">
+				<Option output="bin/Release/genarray3" 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" />
+		</Compiler>
+		<Unit filename="gen_array_iter3.hpp" />
+		<Unit filename="gen_array_iter3_test.cpp" />
+		<Unit filename="gtest_lite.h" />
+		<Unit filename="integer.h" />
+		<Unit filename="sablonok.hpp" />
+		<Extensions>
+			<code_completion />
+			<debugger />
+			<envvars />
+			<DoxyBlocks>
+				<comment_style block="0" line="0" />
+				<doxyfile_project />
+				<doxyfile_build />
+				<doxyfile_warnings />
+				<doxyfile_output />
+				<doxyfile_dot />
+				<general />
+			</DoxyBlocks>
+		</Extensions>
+	</Project>
+</CodeBlocks_project_file>

genArray3/gen_array_iter3.hpp

+/**
+ * \file gen_array_iter3.hpp
+ *
+ * Generikus tömb iterátorral v3.
+ *  Előadáson bemutatott kód módosított változata.
+ *  Interfész jobban hasonlít az std::vector-ra.
+ *  Van konstans iterarora is.
+ */
+#ifndef GEN_ARRAY_ITER3
+#define GEN_ARRAY_ITER3
+
+#include <stdexcept>
+
+/**
+ * Fix méretű generikus tömb.
+ * @param T - tárolt adattípus
+ * @param maxsiz - maximális méret
+ */
+template<class T, size_t maxsiz = 6>
+class Array {
+    size_t siz;				// adatok tényleges mennyisége
+	T t[maxsiz];            // elemek (adatok) tömbje
+public:
+    /// minden implicit tagfüggvény jó, nem kell átdefiniálni
+    class iterator;	        // elődeklaráció
+    class const_iterator;	// elődeklaráció
+
+	/// default és konstans értékkel feltöltő konstruktor
+	/// @param n - méret
+	/// @param value - érték, amivel feltölt
+	explicit Array(size_t n = 0, const T& value = T()) : siz(0) {
+        while (siz < n && siz < maxsiz)
+            t[siz++] = value;
+    }
+
+    /// konstruktor sorozatból
+    /// @param first - sorozat elejére mutat
+    /// @param last - utolsó elem után
+    template <class InputIterator>
+    Array(InputIterator first, InputIterator last) : siz(0) {
+		while (first != last && siz < maxsiz)	// átmásolunk, amíg lehet
+			t[siz++] = *first++;
+    }
+
+	/// létrehoz egy iterátort és az elejére állítja
+	/// @return - iterátor az adatsorozat elejére
+    iterator begin() {
+        return iterator(*this);		// ld. iterátor konstruktor
+    }
+
+	/// létrehoz egy iterátort és az utolsó elem után állítja
+	/// @return - iterátor az adatsorozat végére
+    iterator end() {
+        return iterator(*this, siz);// ld. iterátor konstruktor
+    }
+
+	/// létrehoz egy konstans objektumra alkalmazható iterátort és az elejére állítja
+	/// @return - iterátor az adatsorozat elejére
+    const_iterator begin() const {
+        return const_iterator(*this);		// ld. iterátor konstruktor
+    }
+
+	/// létrehoz egy iterátort és az utolsó elem után állítja
+	/// @return - iterátor az adatsorozat végére
+    const_iterator end() const {
+        return const_iterator(*this, siz);// ld. iterátor konstruktor
+    }
+
+	/// Elemek tényleges száma
+	/// @return - ténylegesen tárolt elemek száma
+	size_t size() const { return siz; }
+
+	/// Tömb allokált (maximális) kapacitása
+	/// @return - tömb allokált (maximális) kapacitása
+	size_t capacity() const { return maxsiz; }
+
+	/// Tömb allokált maximális kapacitása
+	/// Mivel a tömb fix méretű így a max_size és a capacity megegyezik.
+	/// @return - tömb maximális kapacitása
+	size_t max_size() const { return maxsiz; }
+
+	/// at
+	/// @param i - index
+	/// @return - i. elem referenciája, vagy out_of_range hiba
+	T& at(size_t i) {
+		if (i >= maxsiz) throw std::out_of_range("Array.at(): hibas index");
+		if (i >= siz) siz = i+1;    // növeljük a tényleges méretet
+		return t[i];
+	}
+	/// at konstans változata.
+	/// konstans esetén nem változhat a méret
+	/// @param i - index
+	/// @return i. elem referenciája, vagy out_of_range hiba
+	const T& at(size_t i) const {
+		if (i >= siz) throw std::out_of_range("Array.at(): hibas index");
+		return t[i];
+	}
+
+	/// iterator osztály
+	/// input/output (STL::ForwardIterator) iterátorként használható
+	class iterator {
+        Array *p;	// tároljuk, hogy melyik az objektumhoz tartozik az iterátor
+		size_t idx;	// tároljuk az aktuális index értéket
+    public:
+
+        /// default konstruktor
+        iterator() :p(0), idx(0) {}
+
+        /// konstruktor, egy konkrét objektum ix-edik elemére mutat
+        /// @param a - a konkrét objektum
+        /// @param ix - ide állítja az indexet
+        iterator(Array& a, size_t ix = 0)
+            : p(&a),                // az objektumra mutat
+            idx(ix) {}              // erre az elemre áll
+
+        /// pre-inkremens
+        /// csak hatékonyság miatt ref. visszatérésű,
+        /// értelmetlen lenne balértékként használni
+        iterator& operator++() {
+            if (idx != p->siz) ++idx;   // nem engedjük túllépni
+            return *this;
+        }
+
+        /// post-inkremens
+        iterator operator++(int);       // ezt kell elkészítenie
+
+        /// egyenlőtlenség vizsgálat
+        /// @param i - jobboldali operandus
+        bool operator!=(const iterator &i) {
+            return(idx != i.idx);
+        }
+
+        /// egyenlőség vizsgálat
+        /// @param i - jobboldali operandus
+		bool operator==(const iterator &i) {
+            return !operator!=(i);
+        }
+
+        /// indirekció
+        T& operator*() {
+            if (idx != p->siz) return p->t[idx];
+            else throw std::runtime_error("Hibas indirekcio");
+        }
+
+        /// Szelekció pointerrel (nyil). Címet kell, hogy adjon.
+        T* operator->() {
+            return &operator*();
+        }
+
+    };  // iterator osztály vége
+
+    /// const_iterator osztály
+    /// Visszavezetjük az iterator osztályra.
+    class const_iterator : public iterator  {
+    public:
+        /// default konstruktor
+        const_iterator() {}
+
+        /// konstruktor, egy konkrét objektum ix-edik elemére mutat
+        /// @param a - a konkrét objektum
+        /// @param ix - ide állítja az indexet
+        const_iterator(const Array& a, size_t ix = 0)
+            : iterator(const_cast<Array&>(a), ix) {}        /// Kis trükközés a kasztolással...
+
+        const T& operator*() const {
+            return iterator::operator*();
+        }
+
+        /// Szelekció pointerrel (nyil). Címet kell, hogy adjon.
+        const T* operator->() const {
+            return &operator*();
+        }
+
+	};
+
+	/// Virtuális destruktor.
+	/// Most nem használjuk, de egy generikus osztály későbbi
+	/// felhasználási módja kevésbé látszik.
+	virtual ~Array() {}
+}; // generikus tömb vége
+
+#endif

genArray3/gen_array_iter3_test.cpp

+/**
+ * Egyszerű program az iterátoros generikus tömb kipróbálásához.
+ */
+
+#include <iostream>
+#include <stdexcept>
+#include <sstream>
+
+#include "integer.h"
+#include "sablonok.hpp"
+#include "gen_array_iter3.hpp"
+#include "gtest_lite.h"
+
+/// Ellenőrizzük, hogy a sablonok.hpp-ben definiálta-e az ELKESZULT makrót
+#ifndef ELKESZULT
+#define ELKESZULT 0     /// ha mégse definiálta
+#endif
+
+#if ELKESZULT < 0       /// ha hibásan definiálta
+#undef ELKESZULT
+#define ELKESZULT 0
+#endif
+/// ------- Ellenőrző rész vége ----------
+
+using std::cout;
+using std::endl;
+
+/// Összegző funktor (6. részfeladathoz)
+/// ELKESZULT == 16-hoz
+struct Sum {
+    int sum;
+    Sum(int s=0) :sum(s) {}
+    void operator()(int i) { sum += i;}
+};
+
+/// Egyszerű C tömbök, amiből majd az adatokat vesszük
+int itomb[] = { -5, 11, 13, -2, -1, 0, 1, -82, 3, 4 };
+double dtomb[] = { .0,  .1,  .2,  .3,  4.4, -12.4, 8.7  };
+const char* txtomb[] = { "C#" , "C", "C++", "Java", "C++11" };
+
+int main() {
+    printEach(itomb, itomb+4, std::cout);
+
+    try {
+		/// az int tömbből létrehozuk az intarr0-át
+		Array<int> intarr0(itomb, itomb+10);
+		/// a double tömbből létrehozzuk a dblarr0-át
+		Array<double, 20> dblarr0(dtomb, dtomb+7);
+        /// const char* tömbből pedig létrehozzuk a txarray-t
+        Array<const char*> txarray(txtomb, txtomb+5);
+
+#if ELKESZULT <= 11  // csak az elején, hogy máskor ne zavarjon a kivétel
+		/// szándékosan rosszul indexelünk
+        cout << intarr0.at(112);
+#endif // ELKESZULT <= 11
+
+#if ELKESZULT >= 12
+        /// Kiírjuk a tömböket.
+        PrintArray("intarr0", intarr0);
+        PrintArray("dblarr0", dblarr0);
+        PrintArray("txarray", txarray);
+
+        /// Adatokat is kiírja?
+        TEST(PrintArray, adat) {
+            char cpp[] = "C++";
+            Array<char, 10> carr(cpp, cpp+3);               /// létrehozzuk
+
+            std::stringstream out;                          /// ide ír, az out adatfolyamba
+            PrintArray("cpp", carr, out);
+            // out-nak a sztring "arcát" összehasonlítjuk az elvárt sztringgel
+            EXPECT_EQ(std::string("cpp size=3 capacity=10\n\t data=C,+,+\n"), out.str()) << "== Nem jo a kiiras formatuma!\n";
+        END }
+#endif // ELKESZULT >= 12
+
+#if ELKESZULT >= 13
+		/// Ellenőrizzük az Array post-inkremens iterátorát:
+        Array<int>::iterator i1, i2;
+        i1 = i2 = intarr0.begin();
+        if (i1 != i2++) { cout << "** HIBAS az iterator post-inkremens operatora **\n"; }
+#endif // ELKESZULT >= 13
+
+#if ELKESZULT >=14
+        /// intarr0-ból létrehozzuk az intarr1-et
+		Array<int, 100> intarr1(intarr0.begin(), intarr0.end());
+        /// Kiírjuk az elemeket.
+        PrintArray("\bintarr1", intarr1);
+#endif // ELKESZULT >= 14
+
+#if ELKESZULT >= 15
+        int db = szamol_ha(intarr1.begin(), intarr1.end(), nagyobb_mint<int>(5));
+        cout << "\nintarr1-ben 5-nel nagyobb: ";
+        cout << db << " db" << endl;
+#endif // ELKESZULT >= 15
+
+#if ELKESZULT >= 16
+        Sum s = forEach(intarr1.begin(), intarr1.end(), Sum());
+        cout << "\nintarr0 osszegzes forEach segitsegevel: " << s.sum << endl;
+#endif // ELKESZULT >= 16
+
+#if ELKESZULT >= 17
+        cout << "intarr0 kiiras forEach segtisegevel: ";
+        ostreamFunctor<int> out(cout, ",");
+        forEach(intarr1.begin(), intarr1.end(), out);
+        cout << endl;
+#endif // ELKESZULT >= 17
+
+#if ELKESZULT >= 18
+        /// Itt valamilyen memóriaszemét lesz
+		cout << "\nMemoriaszemet: " << intarr1.at(12) << endl;
+
+		/// Itt meg nincs memóriaszemét. Miért?
+        Array<Integer,100> Ia;
+        cout << "Ez meg nulla: "<< Ia.at(12) << endl;
+#endif // ELKESZULT >= 18
+
+    } catch (std::exception& e) { // az out_of_range, és a runtime_error is az exception
+                                  // osztályból származik. Így azok kompatibilisek
+								  // az alaposztállyal
+        cout << e.what() << endl;
+    }
+}
+