V0

Komplex/Makefile

+# Pelda Makefile a 3. labor megoldasanak forditasara es tesztelesere
+# Solaris (ural2) es Linux ala.
+
+GTEST = ./gtest
+                                # gtest katalogus helye
+ARCH = `uname`-`uname -m`       # architekturahoz tartozo kat. neve
+objs = komplex_teszt.o komplex.o # forditando obj. fajlok
+CXX = g++                       # a C++ fordito neve
+#CXX = clang++                  # clang-ot (llvm) is erdemes kiprobalni
+CXXFLAGS = -pedantic -Wall      # C++ kapcsolok: legyen bobeszedu, 
+CXXFLAGS += -Wno-long-long -Wno-variadic-macros
+                                # ... de gtest headerekre ne gerjedjen
+
+# alapertelmezett cel: tesztek futtatasa
+.PHONY:
+do_test: test
+	./test
+
+# tesztprogram linkelese
+test: $(objs)
+	$(CXX) -L$(GTEST)/$(ARCH) -lgtest_main -lgtest $(objs) -o $@
+
+# tesztprogram forditasahoz kell a gtest include katalogus
+komplex_teszt.o: komplex_teszt.cpp
+	$(CXX) ${LDFLAGS} -I${GTEST}/include $(CPPFLAGS) $(CXXFLAGS) -c komplex_teszt.cpp 
+
+# ujraforditas, ha valtozik az osztaly felepitese
+komplex.o komplex_teszt.o: komplex.h
+
+fapados: fapados_komplex_teszt.o komplex.o komplex.h
+	$(CXX) fapados_komplex_teszt.o komplex.o -o $@
+
+# takaritas igeny szerint
+.PHONY:
+clean:
+	rm -f *.o test fapados *~
+
+# tar igeny szerint
+.PHONY:
+tar:
+	tar -czvf komplex.tgz *.h *.cpp 
+

Komplex/gtest_lite.h

+#ifndef GTEST_LITE_H
+#define GTEST_LITE_H
+
+/**
+ * \file gtest_lite.h  (v2)
+ *
+ * Google gtest keretrendszerhez hasonló rendszer.
+ * Sz.I. 2015., 2016., 2017. (_Has_X)
+ * Sz.I. 2018 (template), ENDM, ENDMsg
+ *
+ * A tesztelés legalapvetőbb funkcióit támogató függvények és makrók.
+ * Nem szálbiztos megvalósítás.
+ *
+ * Egyetlen fájlban kell megvalósítani minden tesztesetet!
+ * Csak ebből include-olható a gtest_lite.h
+ * Ezen korlátozás kiküszöböléséhez sigletonnal kellene rednesen megvalósítani.
+  a test osztályt!
+ *
+ * Szabadon felhasználható, bővíthető.
+ *
+ * Használati példa:
+ *   Teszteljük az f(x)=2*x függvényt:
+ * int f(int x) { return 2*x; }
+ *
+ * int main() {
+ *   TEST(TeszEsetNeve, TesztNeve)
+ *     EXPECT_EQ(0, f(0));
+ *     EXPECT_EQ(4, f(2)) << "A függvény hibás eredményt adott" << std::endl;
+ *     ...
+ *   END
+ * ...
+ *
+ * A működés részleteinek megértése szorgalmi feladat.
+ */
+
+#include <iostream>
+#include <cassert>
+#include <cmath>
+#include <cstring>
+#include <limits>
+#include <string>
+#include <fstream>
+#ifdef MEMTRACE
+#include "memtrace.h"
+#endif
+
+// Két makró az egyes tesztek elé és mögé:
+// A két makró a kapcsos zárójelekkel egy új blokkot hoz létre, amiben
+// a nevek lokálisak, így elkerülhető a névütközés.
+
+/// Teszt kezdete. A makró paraméterezése hasonlít a gtest
+/// paraméterezéséhez. Így az itt elkészített testek könnyen átemelhetők
+/// a gtest keretrendszerbe.
+/// @param C - teszteset neve (csak a gtest kompatibilitás miatt van külön neve az eseteknek)
+/// @param N - teszt neve
+#define TEST(C, N) { gtest_lite::test.begin(#C"."#N);
+
+/// Teszteset vége.
+#define END gtest_lite::test.end(); }
+
+/// Teszteset vége allokált blokkok számának összehasonlításával
+/// Ez az ellenőrzés nem bomba biztos.
+#define ENDM gtest_lite::test.end(true); }
+
+/// Teszteset vége allokált blokkok számának összehasonlításával
+/// Ez az ellenőrzés nem bomba biztos.
+/// Ha hiba van kiírja az üzenetet.
+#define ENDMsg(t) gtest_lite::test.end(true) << t << std::endl; }
+
+// Eredmények vizsgálatát segítő makrók.
+// A paraméterek és a funkciók a gtest keretrendszerrel megegyeznek.
+
+/// Sikeres teszt makrója
+#define SUCCEED() gtest_lite::test.expect(true, __FILE__, __LINE__, "SUCCEED()", true)
+
+/// Sikertelen teszt makrója
+#define FAIL() gtest_lite::test.expect(false, __FILE__, __LINE__, "FAIL()", true)
+
+/// Azonosságot elváró makró
+
+#define EXPECT_EQ(expected, actual) gtest_lite::EXPECT_(expected, actual, gtest_lite::eq, __FILE__, __LINE__, "EXPECT_EQ(" #expected ", " #actual ")" )
+
+/// Eltérést elváró makró
+#define EXPECT_NE(expected, actual) gtest_lite::EXPECT_(expected, actual, gtest_lite::ne, __FILE__, __LINE__, "EXPECT_NE(" #expected ", " #actual ")", "etalon" )
+
+/// Kisebb, vagy egyenlő relációt elváró makró
+#define EXPECT_LE(expected, actual) gtest_lite::EXPECT_(expected, actual, gtest_lite::le, __FILE__, __LINE__, "EXPECT_LE(" #expected ", " #actual ")", "etalon" )
+
+/// Kisebb, mint relációt elváró makró
+#define EXPECT_LT(expected, actual) gtest_lite::EXPECT_(expected, actual, gtest_lite::lt, __FILE__, __LINE__, "EXPECT_LT(" #expected ", " #actual ")", "etalon" )
+
+/// Nagyobb, vagy egyenlő relációt elváró makró
+#define EXPECT_GE(expected, actual) gtest_lite::EXPECT_(expected, actual, gtest_lite::ge, __FILE__, __LINE__, "EXPECT_GE(" #expected ", " #actual ")", "etalon" )
+
+/// Nagyobb, mint relációt elváró makró
+#define EXPECT_GT(expected, actual) gtest_lite::EXPECT_(expected, actual, gtest_lite::gt, __FILE__, __LINE__, "EXPECT_GT(" #expected ", " #actual ")", "etalon" )
+
+/// Igaz értéket elváró makró
+#define EXPECT_TRUE(actual)  gtest_lite::EXPECT_(true, actual,  gtest_lite::eq, __FILE__, __LINE__, "EXPECT_TRUE(" #actual ")" )
+
+/// Hamis értéket elváró makró
+#define EXPECT_FALSE(actual) gtest_lite::EXPECT_(false, actual, gtest_lite::eq, __FILE__, __LINE__, "EXPECT_FALSE(" #actual ")" )
+
+/// Valós számok azonosságát elváró makró
+#define EXPECT_FLOAT_EQ(expected, actual)  gtest_lite::EXPECT_(expected, actual, gtest_lite::almostEQ, __FILE__, __LINE__, "EXPECT_FLOAT_EQ(" #expected ", " #actual ")" )
+
+/// Valós számok azonosságát elváró makró
+#define EXPECT_DOUBLE_EQ(expected, actual) gtest_lite::EXPECT_(expected, actual, gtest_lite::almostEQ, __FILE__, __LINE__, "EXPECT_DOUBLE_EQ(" #expected ", " #actual ")" )
+
+/// C stringek (const char *) azonosságát tesztelő makró
+#define EXPECT_STREQ(expected, actual) gtest_lite::EXPECTSTR(expected, actual, gtest_lite::eqstr, __FILE__, __LINE__, "EXPECT_STREQ(" #expected ", " #actual ")" )
+
+/// C stringek (const char *) eltéréset tesztelő makró
+#define EXPECT_STRNE(expected, actual) gtest_lite::EXPECTSTR(expected, actual, gtest_lite::nestr, __FILE__, __LINE__, "EXPECT_STRNE(" #expected ", " #actual ")", "etalon" )
+
+/// Kivételt várunk
+#define EXPECT_THROW(statement, exception_type) try { gtest_lite::test.tmp = false; statement; } \
+    catch (exception_type) { gtest_lite::test.tmp = true; } \
+    catch (...) { } \
+    EXPECTTHROW(statement, "kivetelt dob.", "nem dobott '"#exception_type"' kivetelt.")
+
+/// Kivételt várunk
+#define EXPECT_ANY_THROW(statement) try { gtest_lite::test.tmp = false; statement; } \
+    catch (...) { gtest_lite::test.tmp = true; } \
+    EXPECTTHROW(statement, "kivetelt dob.", "nem dobott kivetelt.")
+
+/// Nem várunk kivételt
+#define EXPECT_NO_THROW(statement) try { gtest_lite::test.tmp = true; statement; } \
+    catch (...) { gtest_lite::test.tmp = false; }\
+    EXPECTTHROW(statement, "nem dob kivetelt.", "kivetelt dobott.")
+
+/// Kivételt várunk és továbbdobjuk -- ilyen nincs a gtest-ben
+#define EXPECT_THROW_THROW(statement, exception_type) try { gtest_lite::test.tmp = false; statement; } \
+    catch (exception_type) { gtest_lite::test.tmp = true; throw; } \
+    EXPECTTHROW(statement, "kivetelt dob.", "nem dobott '"#exception_type"' kivetelt.")
+
+/// Segédmakró egy adattag, vagy tagfüggvény létezésének tesztelésére futási időben
+/// Ötlet:
+/// 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)...
+#define CREATE_Has_(X) \
+template<typename T> struct _Has_##X {  \
+    struct Fallback { int X; };         \
+    struct Derived : T, Fallback {};    \
+    template<typename C, C> struct ChT; \
+    template<typename D> static char (&f(ChT<int Fallback::*, &D::X>*))[1]; \
+    template<typename D> static char (&f(...))[2]; \
+    static bool const member = sizeof(f<Derived>(0)) == 2; \
+};
+
+/// Segédsablon típuskonverzió futás közbeni ellenőrzésere
+template <typename F, typename T>
+struct _Is_Types {
+    template<typename D> static char (&f(D))[1];
+    template<typename D> static char (&f(...))[2];
+    static bool const convertable = sizeof(f<T>(F())) == 1;
+};
+
+/// -----------------------------------
+/// Belső megvalósításhoz tartozó makrók, és osztályok.
+/// Nem célszerű közvetlenül használni, vagy módosítani
+/// -----------------------------------
+
+/// EXPECTTHROW: kivételkezelés
+#define EXPECTTHROW(statement, exp, act) gtest_lite::test.expect(gtest_lite::test.tmp, __FILE__, __LINE__, #statement) \
+    << "** Az utasitas " << (act) \
+    << "\n** Azt vartuk, hogy " << (exp) << std::endl
+
+#ifdef CPORTA
+#define GTINIT(is)  \
+    int magic;      \
+    is >> magic;
+#else
+#define GTINIT(IS)
+#endif // CPORTA
+
+#ifdef CPORTA
+#define GTEND(os)  \
+    os << magic << (gtest_lite::test.fail() ? " NO" : " OK?") << std::endl;
+#else
+#define GTEND(os)
+#endif // CPORTA
+
+/// gtest_lite: a keretrendszer függvényinek és objektumainak névtere
+namespace gtest_lite {
+
+/// Tesztek állapotát tároló osztály.
+/// Egyetlen egy statikus példány keletkezik, aminek a
+/// destruktora a futás végén hívódik meg.
+struct Test {
+    int sum;            ///< tesztek számlálója
+    int failed;         ///< hibás tesztek
+    int ablocks;        ///< allokált blokkok száma
+    bool status;        ///< éppen futó teszt státusza
+    bool tmp;           ///< temp a kivételkezeléshez;
+    std::string name;   ///< éppen futó teszt neve
+    std::fstream null;  ///< nyelő, ha nem kell kiírni semmit
+
+    Test() :sum(0), failed(0), status(false), null("/dev/null") {}
+    /// Teszt kezdete
+    void begin(const char *n) {
+        name = n; status = true;
+#ifdef MEMTRACE
+        ablocks = memtrace::allocated_blocks();
+#endif
+#ifndef CPORTA
+        std::cerr << "\n---> " << name << std::endl;
+#endif // CPORTA
+        ++sum;
+    }
+    /// Teszt vége
+    std::ostream& end(bool memchk = false) {
+#ifdef MEMTRACE
+        if (memchk && ablocks != memtrace::allocated_blocks()) {
+            status = false;
+            return std::cerr << "** Lehet, hogy nem szabaditott fel minden memoriat! **" << std::endl;
+        }
+#endif
+#ifdef CPORTA
+        if (!status)
+#endif // CPORTA
+            std::cerr << (status ? "     SIKERES" : "** HIBAS ****") << "\t" << name << " <---" << std::endl;
+        if (!status)
+            return std::cerr;
+        else
+            return null;
+    }
+
+    bool fail() { return failed; }
+
+    /// Eredményt adminisztráló tagfüggvény True a jó eset.
+    std::ostream& expect(bool st, const char *file, int line, const char *expr, bool pr = false) {
+        if (!st) {
+            ++failed;
+            status = false;
+        }
+        if (!st || pr) {
+            std::string str(file);
+            size_t i = str.rfind("\\");
+            if (i == std::string::npos) i = str.rfind("/");
+            if (i == std::string::npos) i = 0; else i++;
+            return std::cerr << "\n**** " << &file[i] << "(" << line << "): " << expr << " ****" << std::endl;
+        }
+        return null;
+    }
+
+    /// Destruktor
+    ~Test() {
+#ifdef CPORTA
+        if (failed)
+#endif // CPORTA
+            std::cerr << "\n==== TESZT VEGE ==== HIBAS/OSSZES: " << failed << "/" << sum << std::endl;
+    }
+};
+
+/// Egyetlen statikus példány. (singletonnal szebb lenne)
+static Test test;
+
+/// általános sablon a várt értékhez.
+template <typename T>
+std::ostream& EXPECT_(T exp, T act, bool (*pred)(T, T), const char *file, int line,
+                      const char *expr, const char *lhs = "elvart", const char *rhs = "aktual") {
+    return test.expect(pred(exp, act), file, line, expr)
+        << "** " << lhs << ": " << std::boolalpha << exp
+        << "\n** " << rhs << ": " << std::boolalpha << act << std::endl;
+}
+
+/// pointerre specializált sablon a várt értékhez.
+template <typename T>
+std::ostream& EXPECT_(T* exp, T* act, bool (*pred)(T*, T*), const char *file, int line,
+                      const char *expr, const char *lhs = "elvart", const char *rhs = "aktual") {
+    return test.expect(pred(exp, act), file, line, expr)
+        << "** " << lhs << ": " << (void*) exp
+        << "\n** " << rhs << ": " << (void*) act << std::endl;
+}
+
+/// stringek összehasonlításához.
+/// azért nem spec. mert a sima EQ-ra másként kell működnie.
+inline
+std::ostream& EXPECTSTR(const char *exp, const char *act, bool (*pred)(const char*, const char*), const char *file, int line,
+                      const char *expr, const char *lhs = "elvart", const char *rhs = "aktual") {
+    return test.expect(pred(exp, act), file, line, expr)
+        << "** " << lhs << ": " << (exp == NULL ? "NULL pointer" : std::string("\"") + exp + std::string("\""))
+        << "\n** " << rhs << ": " << (act == NULL ? "NULL pointer" : std::string("\"") + act + std::string("\"")) << std::endl;
+}
+
+/// segéd sablonok a relációkhoz.
+/// azért nem STL (algorithm), mert csak a függvény lehet, hogy menjen a deduckció
+template <typename T>
+bool eq(T a, T b) { return a == b; }
+
+inline
+bool eqstr(const char *a, const char *b) {
+    if (a != NULL && b != NULL)
+        return strcmp(a, b) == 0;
+    return false;
+}
+
+template <typename T>
+bool ne(T a, T b) { return a != b; }
+
+inline
+bool nestr(const char *a, const char *b) {
+    if (a != NULL && b != NULL)
+        return strcmp(a, b) != 0;
+    return false;
+}
+
+template <typename T>
+bool le(T a, T b) { return a <= b; }
+
+template <typename T>
+bool lt(T a, T b) { return a < b; }
+
+template <typename T>
+bool ge(T a, T b) { return a >= b; }
+
+template <typename T>
+bool gt(T a, T b) { return a > b; }
+
+/// Segédsablon valós számok összehasonlításához
+/// Nem bombabiztos, de nekünk most jó lesz
+/// Elméleti hátér:
+/// http://www.cygnus-software.com/papers/comparingfloats/comparingfloats.htm
+template <typename T>
+bool almostEQ(T a, T  b) {
+    // eps: ha a relatív, vagy abszolút hiba ettől kisebb, akkor elfogadjuk
+    T eps = 10 * std::numeric_limits<T>::epsilon(); // 10-szer a legkisebb érték
+    if (a == b) return true;
+    if (fabs(a - b) < eps)
+       return true;
+    double aa = fabs(a);
+    double ba = fabs(b);
+    if (aa < ba) {
+        aa = ba;
+        ba = fabs(a);
+    }
+    return (aa - ba) < aa * eps;
+}
+
+} // namespace gtest_lite
+
+#endif // GTEST_LITE_H

Komplex/komplex.cbp

+<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
+<CodeBlocks_project_file>
+	<FileVersion major="1" minor="6" />
+	<Project>
+		<Option title="Komplex" />
+		<Option pch_mode="0" />
+		<Option compiler="gcc" />
+		<Build>
+			<Target title="Debug">
+				<Option output="bin/Debug/Komplex" 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/Komplex" prefix_auto="1" extension_auto="1" />
+				<Option object_output="obj/Release/" />
+				<Option type="1" />
+				<Option compiler="gcc" />
+				<Compiler>
+					<Add option="-O2" />
+				</Compiler>
+			</Target>
+		</Build>
+		<Compiler>
+			<Add option="-pedantic-errors" />
+			<Add option="-std=c++11" />
+			<Add option="-Wfatal-errors" />
+			<Add option="-Wall" />
+			<Add directory="gtest/include" />
+		</Compiler>
+		<Unit filename="gtest_lite.h" />
+		<Unit filename="komplex.cpp" />
+		<Unit filename="komplex.h" />
+		<Unit filename="komplex_teszt.cpp" />
+		<Extensions>
+			<code_completion />
+			<debugger />
+			<envvars />
+		</Extensions>
+	</Project>
+</CodeBlocks_project_file>

Komplex/komplex.cpp

+/**
+ * \file komplex.cpp
+ *
+ * Komplex osztályt megvalósító függvények definíciója.
+ *
+ * Folytassa a megvalósítást sorrendben a komplex.h fájlban levő feladatoknak megfelelően!
+ *
+ */
+
+
+#include <iostream>         // Valószínű, hogy a kiíráshoz majd kell
+#include <iomanip>          // ... és ez is.
+#include <cmath>            // az sqrt miatt kell.
+
+#include "komplex.h"        // Ebben van a Komplex osztály, és néhány globális függvény deklarációja
+
+///using namespace std;  // ha nagyon kell, akkor csak itt nyissuk ki a névteret, a headerben soha!
+
+/// Előre elkészített tagfüggvények
+
+/// 0, 1 és 2 paraméteres konstruktor
+/// Figyelje meg, hogy a default argumentumokat CSAK a deklarációnál
+/// adtuk meg!
+Komplex::Komplex(double r, double im) {
+    re = r; // ha nincs névütközés, nem kell kiírni a this-t
+    this->im = im;
+}
+
+///---- Egy példa a konstans tagfüggvényre, ehhez hasonlóan kell
+///     elkészíteni a gettereket az 1. feladatban (ELKESZULT=1)
+/// Abszolút érték lekérdezése
+/// @return - abszolút érték
+double Komplex::abs() const { return sqrt(re*re + im*im); }
+
+#if ELKESZULT >= 3
+// 3. feladathoz (ELKESZULT 3)
+// összehasonlítás
+/// Egyenlőtlenség vizsgálat
+/// @param rhs_k - jobb oldali operandus (Komplex)
+/// @return hamis - ha a képzetes és a valós rész is azonos, egyébként false
+bool Komplex::operator!=(const Komplex& rhs_k) const {  // visszavezetjük az egyenlőség vizsgálatra
+    return !(*this == rhs_k);
+}
+#endif
+
+#if ELKESZULT >= 6
+// 6. feladathoz (ELKESZULT 6)
+// a += művelet viszont módosítja önmagát!
+/// Komplex + double
+/// @param rhs_d - jobb oldali operandus (double)
+/// @return eredeti (bal oldali) objektum ref., amihez hozzáadtuk rhd_d-t
+Komplex& Komplex::operator+=(double rhs_d) {
+    re += rhs_d;
+    return *this;
+}
+#endif
+
+// ------------------------ Eddig elkészítettük -------------------------
+// TODO: A hiányzó tag- és globális függvények itt következnek
+

Komplex/komplex.h

+/**
+ * \file komplex.h
+ * (UTF-8 kodolasu fajl. Allitsa at a kodolast,
+ *  ha a tovabbi kommentek nem olvashatok helyesen!)
+ *
+ *
+ * Az előadáson látott Komplex osztályhoz hasonló osztály és a
+ * hozzá kapcsolódó globális függvények deklarációja.
+ */
+#ifndef KOMPLEX_H
+#define KOMPLEX_H
+/**
+ * Az Ön feladata a komplex.cpp fájlban megvalósítani (definiálni) az egyes
+ * függvényeket. Ahogyan halad a megvalósítással egyre több tesztesetet kell
+ * lefuttatni, ezért az ELKESZULT makró értéket folyamatosan növelje a
+ * feladatsorszámoknak megfelelően!
+ * Ebben a fájlban mást nem szükséges módosítania.
+ */
+#define ELKESZULT 0
+/**
+ *ELKESZULT értéke - feladatok:
+ * 0. Csak az előre elkészített tagfüggvények (konstruktorok, getRe, abs) működnek.
+ * 1. Készítsen lekérdező függvényeket a valós és képzetes rész lekérdezésére:
+ *    getRe(), getIm()! Ügyeljen arra, hogy konstans objektumra is működjön!
+ *    (Konstans objektumra csak olyan tagfüggvény alkalmazható, ami nem
+ *    változtatja az objektum állapotát.)
+ *    A példában a getRe() függvénynek van const és nem const változata is.
+ *    Esetünkben ez értelmetlen, de azt kívánja demonstrálni, hogy ez két külön
+ *    tagfüggvény.
+ * 2. Készítsen beállító függvényeket a valós és képzetes rész beállítására!
+ *    setRe(double), setIm(double)
+ * 3. Készítsen egyenlőségvizsgáló (==) operátort!
+ *    A != operátort már elkészítettük, ami az == -re vezeti vissza a feladatot.
+ * 4. Készítsen + operátort (összeadás)! Működjön valóssal is (először csak jobbról)!
+ * 5. Készítsen olyan összeadó operatort, ami alkalmas valós + komplex összeadására!
+ *    (A double + Komplex esetben a bal oldali operandus nem objektum, így globális
+ *     operátorfüggvénnyel kell megvalósítani a feladatot.)
+ * 6. Készítsen += operátort!
+ *    Megj: A += valós változatot már elkészítettük!
+ *
+ * Szorgalmi feladatok:
+ * 7. Legyen kiírható a komplex adat egy ostream típusú objektumra a << operátorral
+ *    1+34j ill. 1-34j alakban!
+ *    Be lehessen olvasni egy istream típusú objektumból a >> operátorral
+ *    ugyanilyen (1+34j) alakban!
+ *    Megj: A kért kiírási formátumban a képzetes rész előtt ki kell írni a képzetes rész
+ *    előjelét (a pozitívat is), de a valós rész előtt csak a negatív előjel
+ *    jelenjen meg! (tipp: showpos, noshowpos, ignore)
+ * 8. Valósítsa meg a ~ operátort, amely a komplex szám konjugáltját képzi.
+ * 9. Készítsen * operátort (szorzás)! Működjön valóssal balról és jobbról is!
+ *    Készítsen *= operátort! Működjön valóssal (double) is!
+ */
+
+/// Komplex osztály deklarációja
+/// Lesz olyan feladat, amelynél ezt is bővítenie kell!
+class Komplex {
+    double re, im;
+public:
+    /// 0, 1 és 2 paraméteres konstruktor
+    /// @param re - valós rész
+    /// @param im - képzetes rész
+    Komplex(double re = 0, double im = 0);
+
+    /// Valós rész lekérdezése
+    /// @return - valós rész
+    double getRe() { return re; }   /// tipikusan konstans tagfüggvény itt csak demó
+
+///---- Egy példa a konstans tagfüggvényre, logikusan nem itt a helye -----///
+    /// Abszolút érték lekérdezése
+    /// @return - abszolút érték
+    double abs() const;
+
+#if ELKESZULT >= 1
+    // konstansra is alkalmazható lekérdező függvények
+    /// Valós rész lekérdezése
+    /// @return - valós rész
+    double getRe() const;
+
+    /// Képzetes rész lekérdezése
+    /// @return - képzetes rész
+    double getIm() const;
+#endif
+
+#if ELKESZULT >= 2
+    // beállító függvények
+    /// Valós részt beállító függvény
+    /// @param r - valós rész
+    void setRe(double re);
+
+    /// Képzetes részt beállító függvény
+    /// @param im - képzetes rész
+    void setIm(double im);
+#endif
+
+#if ELKESZULT >= 3
+    // összehasonlítás
+    /// Egyenlőség vizsgálat
+    /// @param rhs_k - jobb oldali operandus (Komplex)
+    /// @return true - ha a képzetes és a valós rész is azonos, egyébként false
+    bool operator==(const Komplex& rhs_k) const;
+
+    /// Egyenlőtlenség vizsgálat
+    /// @param rhs_k - jobb oldali operandus (Komplex)
+    /// @return hamis - ha a képzetes és a valós rész is azonos, egyébként false
+    bool operator!=(const Komplex& rhs_k) const;
+#endif
+
+#if ELKESZULT >= 4
+    // összeadás, a + nem módosítja önmagát ezért konstans fv.
+    /// Komplex + Komplex
+    /// @param rhs_k - jobb oldali operandus (Komplex)
+    /// @return egy új komplex adat - a két komplex adat összege
+    Komplex operator+(const Komplex& rhs_k) const;
+
+    /// Komplex + double
+    /// @param rhs_d - jobb oldali operandus (double)
+    /// @return egy új komplex adat - a két adat összege
+    Komplex operator+(double rhs_d) const;
+#endif
+
+#if ELKESZULT >= 5
+    /// double + Komplex csak globális függvénnyel valósítható meg,
+    /// mivel a bal oldal nem osztály.
+    /// Ld. az osztály deklarációja után!
+#endif
+
+#if ELKESZULT >= 6
+    // a += művelet viszont módosítja önmagát!
+    /// Komplex + Komplex
+    /// @param rhs_k - jobb oldali operandus (Komplex)
+    /// @return eredeti (bal oldali) objektum ref., amihez hozzáadtuk rhd_k-t
+    Komplex& operator+=(const Komplex& rhs_k);
+
+    /// Komplex + double
+    /// @param rhs_d - jobb oldali operandus (double)
+    /// @return eredeti (bal oldali) objektum ref., amihez hozzáadtuk rhd_d-t
+    Komplex& operator+=(double rhs_d);
+#endif
+
+#if ELKESZULT >= 7
+    /// Kiírás egy ostream-re.
+    /// Ez is csak globális függvénnyel valósítható meg.
+    /// A bal oldal osztály ugyan, de nincs a kezünkben, nem módosítható.
+    /// Ld. az osztály deklarációja után!
+#endif
+
+#if ELKESZULT >= 8
+    /// komplex konjugált
+    /// ~Komplex
+    /// @return egy új adat, amiben a konjugált érték van
+    Komplex operator~() const;
+#endif
+
+#if ELKESZULT >= 9
+    // szorzás, a * nem módosítja önmagát ezért konstans fv.
+    /// Komplex * Komplex
+    /// @param rhs_k - jobb oldali operandus (Komplex)
+    /// @return egy új komplex adat - a két komplex adat szorzata
+    Komplex operator*(const Komplex& rhs_k) const;
+
+    /// Komplex * double
+    /// @param rhs_d - jobb oldali operandus (double)
+    /// @return egy új komplex adat - a két adat szorzata
+    Komplex operator*(double rhs_d) const;
+
+    /// double * Komplex csak globális függvénnyel valósítható meg,
+    /// mivel a bal oldal nem osztály
+    /// Ld. az osztály deklarációja után!
+
+    // a *= művelet viszont módosítja önmagát!
+    /// Komplex * Komplex
+    /// @param rhs_k - jobb oldali operandus (Komplex)
+    /// @return eredeti (bal oldali) objektum ref., amit megszorosztunk
+    Komplex& operator*=(const Komplex& rhs_k);
+
+    /// Komplex + double
+    /// @param rhs_d - jobb oldali operandus (double)
+    /// @return eredeti (bal oldali) objektum ref., amit megszoroztunk
+    Komplex& operator*=(double rhs_d);
+#endif
+};
+
+///////////////////// Globális függvények /////////////////////////////////
+/// Fontos!
+/// Ezek nem az osztály tagfüggvényei, habár az osztály adatával dolgoznak
+///
+
+#if ELKESZULT >= 5
+// double + Komplex csak globális függvénnyel valósítható meg,
+// mivel a bal oldal nem osztály
+/// double + Komplex
+/// @param lhs_d - bal oldali operandus (double)
+/// @param rhs_k - jobb oldali operandus (Komplex)
+/// @return egy új komplex adat - a két adat összege
+Komplex operator+(double lhs_d, const Komplex& rhs_k);
+#endif
+
+#if ELKESZULT >= 7
+// cout << Komplex is csak globális függvénnyel valósítható meg, mivel
+// az baloldali osztály (ostream) nincs a kezünkben, nem módosítható
+/// Kiírás egy ostream-re
+/// @param os - bal oldali operandus (ostream)
+/// @param rhs_k - jobb oldali operandus (Komplex)
+/// @return ostream&, hogy fűzhető legyen
+std::ostream& operator<<(std::ostream& os, const Komplex& rhs_k);
+
+/// Beolvasás egy istream-ről
+/// @param is - bal oldali operandus (istream)
+/// @param rhs_k - jobb oldali operandus (Komplex)
+/// @return istream&, hogy fűzhető legyen
+std::istream& operator>>(std::istream& is, Komplex& rhs_k);
+#endif
+
+#if ELKESZULT >= 9
+// double * Komplex csak globális függvénnyel valósítható meg,
+// mivel a bal oldal nem osztály
+/// double * Komplex
+/// @param lhs_d - bal oldali operandus (double)
+/// @param rhs_k - jobb oldali operandus (Komplex)
+/// @return egy új komplex adat - a két adat szorzata
+Komplex operator*(double lhs_d, const Komplex& rhs_k);
+#endif
+
+#endif  // KOMPLEX_H

Komplex/komplex.vcxproj

+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|Win32">
+      <Configuration>Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{28B1FB08-2F8B-4C4E-9E0D-E1F849BE79B2}</ProjectGuid>
+    <Keyword>Win32Proj</Keyword>
+    <RootNamespace>komplex</RootNamespace>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v110</PlatformToolset>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <PlatformToolset>v110</PlatformToolset>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <LinkIncremental>true</LinkIncremental>
+    <IncludePath>gtest\include;$(IncludePath)</IncludePath>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <LinkIncremental>false</LinkIncremental>
+  </PropertyGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <ClCompile>
+      <PrecompiledHeader>
+      </PrecompiledHeader>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>Disabled</Optimization>
+      <PreprocessorDefinitions>WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <PrecompiledHeader>
+      </PrecompiledHeader>
+      <Optimization>MaxSpeed</Optimization>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <PreprocessorDefinitions>WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <OptimizeReferences>true</OptimizeReferences>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ClInclude Include="gtest_lite.h" />
+    <ClInclude Include="komplex.h" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="komplex.cpp" />
+    <ClCompile Include="komplex_teszt.cpp" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+  </ImportGroup>
+</Project>
\ No newline at end of file

Komplex/komplex.vcxproj.filters

+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup>
+    <Filter Include="Source Files">
+      <UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>
+      <Extensions>cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx</Extensions>
+    </Filter>
+    <Filter Include="Header Files">
+      <UniqueIdentifier>{93995380-89BD-4b04-88EB-625FBE52EBFB}</UniqueIdentifier>
+      <Extensions>h;hpp;hxx;hm;inl;inc;xsd</Extensions>
+    </Filter>
+    <Filter Include="Resource Files">
+      <UniqueIdentifier>{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}</UniqueIdentifier>
+      <Extensions>rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms</Extensions>
+    </Filter>
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="komplex.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="gtest_lite.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="komplex.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="komplex_teszt.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+  </ItemGroup>
+</Project>
\ No newline at end of file

Komplex/komplex_teszt.cpp

+/**
+ * \file Komplex_teszt.cpp
+ *
+ * Komplex osztály tesztesetei gtest_lite/gtest eszközkészletével megvalósítva.
+ *
+ * A laborfeladat megoldásához ebben az állományban nem kell módosítani.
+ *
+ * A komplex.h-ban definiált ELKESZULT makró vezérli az egyes tesztesetek
+ * fordítását. A legutolsó teszteset az ELKESZULT értékét vizsgálja.
+ *
+ */
+#include <iostream>
+#include <sstream>
+
+#include "gtest_lite.h"
+
+#include "komplex.h"
+
+int main() {
+    GTINIT(std::cin);       // Csak C(J)PORTA működéséhez kell
+
+/// Konstruktorok létezésének tesztje
+TEST(KomplexTest0, Proba) {
+    Komplex k, k1(1), k2(1,2);
+    EXPECT_EQ(1., k1.getRe());  // ez már az elkészített getRe()-t is meghívja
+} END
+
+#if ELKESZULT >= 1
+/// Már van getRe() és getIm(), így tesztelhetők a konstruktorok
+TEST(KomplexTest1, Ctor0) {		// 0 paraméteres konstruktor
+    const Komplex k;
+    EXPECT_EQ(0., k.getRe());
+    EXPECT_EQ(0., k.getIm());
+} END
+TEST(KomplexTest1, Ctor1) {		// 1 paraméteres konstruktor
+    const Komplex k(3.14);
+    EXPECT_EQ(3.14, k.getRe()); // valósra az egyenlóség vizsg. itt még jó, mert ez nem számított eredmény
+    EXPECT_EQ(0., k.getIm());
+} END
+TEST(KomplexTest1, Ctor2) {		// 2 paraméteres konstruktor
+    const Komplex k(3.14, -2.71);
+    EXPECT_EQ(3.14, k.getRe()); // valósra az egyenlóség vizsg. itt még jó, mert ez nem számított eredmény
+    EXPECT_EQ(-2.71, k.getIm());
+} END
+#endif
+
+#if ELKESZULT >= 2
+/// További get-Set tesztek
+TEST(KomplexTest2, GetSetRe) {	// valós rész
+    Komplex k;
+    EXPECT_EQ(0., k.getRe());
+    k.setRe(3.14);
+    EXPECT_EQ(3.14, k.getRe()); // valósra az egyenlóség vizsg. itt még jó, mert ez nem számított eredmény
+    k.setIm(55);			    // azt nézzük, hogy elrontja-e a setIm a valós részt
+    EXPECT_EQ(3.14, k.getRe());
+} END
+TEST(KomplexTest2, GetSetIm) {	// képzetes rész
+    Komplex k, k1;
+    EXPECT_EQ(0., k.getIm());
+    k.setIm(3.14);
+    EXPECT_EQ(3.14, k.getIm());
+    k.setRe(55);			    // azt nézzük, hogy elrontja-e setRe a képzetes részt
+    EXPECT_EQ(3.14, k.getIm());
+    k1.setIm(3);			    // ha static lenne az adattag, akkor elromolna ez a teszt
+    EXPECT_EQ(3.14, k.getIm());
+} END
+#endif
+
+#if ELKESZULT >= 3
+/// == és != operátorok tesztje
+TEST(KomplexTest3, Equals) {
+    const Komplex k1(1,2), k2(2,3), k3(1,2);
+    EXPECT_FALSE(k1 == k2);
+    EXPECT_TRUE(k1 == k3);
+    EXPECT_TRUE(k1 == k1);
+} END
+TEST(KomplexTest3, NotEquals) {
+    const Komplex k1(1,2), k2(2,3), k3(1,2);
+    EXPECT_TRUE(k1 != k2);
+    EXPECT_FALSE(k1 != k3);
+    EXPECT_FALSE(k1 != k1);
+} END
+#endif
+
+#if ELKESZULT >= 4
+/// + operátorok tesztje
+TEST(KomplexTest4, Add) {    // komplex + komplex
+    const Komplex sum = Komplex(3.14,2.71) + Komplex(1,2);
+    EXPECT_DOUBLE_EQ(4.14, sum.getRe());   // itt már nem pontos egyenlõséget vizsgálunk
+    EXPECT_DOUBLE_EQ(4.71, sum.getIm());
+} END
+TEST(KomplexTest4, AddDbl) { // komplex + double
+    const Komplex sum = Komplex(3.14,2.71) + 1.0;
+    EXPECT_DOUBLE_EQ(4.14, sum.getRe());
+    EXPECT_DOUBLE_EQ(2.71, sum.getIm());
+} END
+#endif
+
+#if ELKESZULT >= 5
+TEST(KomplexTest5, DblAdd) { // double + komplex
+    const Komplex sum = 1.0 + Komplex(3.14,2.71);
+    EXPECT_DOUBLE_EQ(4.14, sum.getRe());
+    EXPECT_DOUBLE_EQ(2.71, sum.getIm());
+} END
+#endif
+
+#if ELKESZULT >= 6
+/// += operatorok tesztje
+TEST(KomplexTest6, AssignmentPlus) {    // komplex += komplex
+    Komplex sum(3.14,2.71);
+    sum += Komplex(1,2);
+    EXPECT_DOUBLE_EQ(4.14, sum.getRe());
+    EXPECT_DOUBLE_EQ(4.71, sum.getIm());
+} END
+TEST(KomplexTest6, AssignmentPlusDbl) { // komplex + double
+    Komplex sum(3.14,2.71);
+    sum += 1.0;
+    EXPECT_DOUBLE_EQ(4.14, sum.getRe());
+    EXPECT_DOUBLE_EQ(2.71, sum.getIm());
+} END
+#endif
+
+#if ELKESZULT >= 7
+/// beolvasás és kiírás tesztje
+TEST(KomplexTest7, Write) {
+    std::ostringstream oss;     // stringstream-be írunk, és szövegesen hasonlítunk !
+    oss << Komplex(-3.14, 2.71) << '\t' << Komplex(3.14, -2.71);
+    EXPECT_STREQ("-3.14+2.71j\t3.14-2.71j", oss.str().c_str());
+} END
+TEST(KomplexTest7, Read) {
+    Komplex k1, k2;
+    std::istringstream iss("3.14-2.71j 0+2j");
+    iss >> k1 >> k2;
+    EXPECT_EQ(Komplex(3.14, -2.71), k1);
+    EXPECT_EQ(Komplex(0, 2), k2);
+} END
+#endif
+
+#if ELKESZULT >= 8
+/// konjugált műveletének tesztje
+TEST(KomplexTest8, Conj) {
+    EXPECT_EQ(Komplex( 3,-4), ~Komplex( 3, 4));
+    EXPECT_EQ(Komplex( 3, 4), ~Komplex( 3,-4));
+    EXPECT_EQ(Komplex(-3, 4), ~Komplex(-3,-4));
+    EXPECT_EQ(Komplex(-3,-4), ~Komplex(-3, 4));
+} END
+#endif
+
+#if ELKESZULT >= 9
+/// szorzások tesztje
+TEST(KomplexTest9, Mul) {
+    const Komplex prod = Komplex(3.14,2.71) * Komplex(1,2);
+    EXPECT_DOUBLE_EQ(-2.28, prod.getRe());
+    EXPECT_DOUBLE_EQ(8.99, prod.getIm());
+} END
+TEST(KomplexTest9, AssignmentMul) {
+    Komplex prod(3.14,2.71);
+    prod *= Komplex(1,2);
+    EXPECT_DOUBLE_EQ(-2.28, prod.getRe());
+    EXPECT_DOUBLE_EQ(8.99, prod.getIm());
+} END
+#endif
+
+/// Itt a vége
+  if (ELKESZULT < 4)
+    FAIL() << "\nLegalabb az elso negy feladatot oldja meg!" << std::endl;
+
+  if (ELKESZULT == 9 && !gtest_lite::test.fail())
+    std::cout << "Szuper! Mind kesz" << std::endl;
+  else
+    std::cout << "EKESZULT = " << ELKESZULT << std::endl;
+
+  GTEND(std::cerr);       // Csak C(J)PORTA működéséhez kell
+  return 0;
+}

Teglalap/teglalap.cbp

+<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
+<CodeBlocks_project_file>
+	<FileVersion major="1" minor="6" />
+	<Project>
+		<Option title="teglalap" />
+		<Option pch_mode="2" />
+		<Option compiler="gcc" />
+		<Build>
+			<Target title="Debug">
+				<Option output="bin/Debug/teglalap" 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/teglalap" 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="-Wall" />
+			<Add option="-fexceptions" />
+		</Compiler>
+		<Unit filename="teglalap.cpp" />
+		<Extensions>
+			<code_completion />
+			<envvars />
+			<debugger />
+			<lib_finder disable_auto="1" />
+		</Extensions>
+	</Project>
+</CodeBlocks_project_file>

Teglalap/teglalap.cpp

+/*
+ * \file teglalap.cpp
+ * (Latin-2 kodolasu fajl. Allitsa at a kodolast,
+ *  ha a tovabbi kommentek nem olvashatok helyesen!)
+ *
+ * Egyszer osztly ltrehozsa
+ */
+#include <iostream>
+using std::cout;
+using std::endl;
+
+/**
+ * Az n feladata megvalstani az egyes tagfggvnyeket.
+ * Ahogyan halad a megvalstssal egyre tbb tesztesetet kell
+ * lefuttatni, ezrt az ELKESZULT makr rtket folyamatosan nvelje a
+ * feladatsorszmoknak megfelelen!
+ */
+#define ELKESZULT 0
+
+/**
+ * Feladatok:
+ * 1. ELKESZULT=1
+ *    Valstsa meg (definilja) a hinyz tagfggvnyeket! (kerulet(), terulet())
+ *
+ * 2. ELKESZULT=2
+ *    Egsztse ki az osztlyt gy, hogy tmb is ltrehozhat legyen belle
+ *    (Tipp: tmb csak olyan osztlybl pldnyosthat, aminek van paramter
+ *    nlkl hvhat konstruktora)
+ *
+ */
+
+class Teglalap {
+    double a, b;        // oldalak hossza
+public:
+    Teglalap(double, double);   // konstruktor
+    void kiir() const;          // kirja az oldalakat
+    double kerulet() const;     // kerlet kiszmtsa
+    double terulet() const;     // terlet kiszmtsa
+};
+
+Teglalap::Teglalap(double a, double b) {
+    this->a = a;
+    this->b = b;
+}
+
+void Teglalap::kiir() const {
+    cout << "a:" << a << " b:" << b << endl;
+}
+
+// ELKESZULT 1
+// 1. feladat
+double Teglalap::terulet() const {
+// Ezt nnek kell kiegsztenie
+
+}
+
+// Itt pedig a kerlet szmtst kell megvalstania
+
+
+
+
+int main() {
+    Teglalap ta(1,4);
+    cout << "ta: ";
+    ta.kiir();
+    Teglalap tb(3,8);
+    cout << "tb: ";
+    tb.kiir();
+#if ELKESZULT >= 1
+    cout << "ta kerlete:" << ta.kerulet() << endl;
+    cout << "tb kerlete:" << tb.kerulet() << endl;
+    cout << "ta terlete:" << ta.terulet() << endl;
+    cout << "tb terlete:" << tb.terulet() << endl;
+#endif
+
+#if ELKESZULT >= 2
+    const int N = 5;
+    Teglalap teglak[N];
+    for (int i = 0; i < N; i++) {
+        cout << "teglak[" << i << "]: ";
+        teglak[i].kiir();
+    }
+#endif
+    return 0;
+}