CPPswap

Makefile

+#
+# Makefile a CPPswap eloallitasahoz
+#
+
+PROG = swap_test
+SRCS = swap_test.cpp swap.cpp memtrace.cpp 
+HDRS = swap.h memtrace.h gtest_lite.h
+OBJS = $(SRCS:.cpp=.o)
+
+CXXFLAGS = -g -Wall -Werror -DMEMTRACE
+
+$(PROG): $(OBJS) 
+	$(CXX) -o $(PROG) $(OBJS)
+
+.PHONY:
+clean:
+	rm -f $(OBJS) $(PROG)
+
+# Egyszerusites: Minden .o fugg minden header-tol, es meg a Makefile-tol is 
+$(OBJS): $(HDRS) Makefile
+
+

README.md

+Valósítsa meg a [swap.h](https://git.ik.bme.hu/Prog2/ell_feladat/CPPswap/blob/master/swap.h) állományban deklarált 
+függvényeket a **swap.cpp** fájlban úgy, hogy a 
+[swap\_test.cpp](https://git.ik.bme.hu/Prog2/ell_feladat/CPPswap/blob/master/swap_test.cpp) program hiba nélkül leforduljon,
+és helyesen működjön! A megvalósítandó függvények specifikációját a **swap.h** fájlban megjegyzésként találja.
+Csak az elkészített **swap.cpp** fájlt kell feltöltenie a portálra.
+
+**Javaslat:**
+
+A megoldást célszerű először saját környezetben tesztelni, majd ezután feltölteni. 
+Segítségül előkészítettük a projektfájlokat mind a Visual Studio, mind CodeBlocks környezethez. 
+Töltse le a teljes projektet Git kliens használatával egyben, vagy akár fájlonként más eszközzel 
+a [https://git.ik.bme.hu/Prog2/ell\_feladat/CPPswap](https://git.ik.bme.hu/Prog2/ell_feladat/CPPswap) tárolóból!
+A memtrace.h, memtrace.cpp, valamint a gtest_lite.h fájlok a teszteléséhez szükségesek. 
+Nem kell megértenie ezek működést, csupán a használatukat érdemes megismerni, amit a swap\_test.cpp fájlban 
+levő kommentek segítenek. Ezen eszközök használatához nyújt segítséget a 
+[Tesztelés madártávlatból](https://infocpp.iit.bme.hu/teszteles) című prezentáció is.
+

gtest_lite.h

+#ifndef GTEST_LITE_H
+#define GTEST_LITE_H
+
+/**
+ * \file gtest_lite.h
+ *
+ * Google gtest keretrendszerhez hasonló rendszer.
+ * Sz.I. 2015., 2016., 2017. (_Has_X)
+ *
+ * A tesztelés legalapvetőbb funkcióit támogató függvények és makrók.
+ * Nem szálbiztos megvalósítás.
+ * 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(); }
+
+// 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.tstatus(true, __FILE__, __LINE__)
+
+/// Sikertelen teszt makrója
+#define FAIL() gtest_lite::test.tstatus(false, __FILE__, __LINE__)
+
+/// Azonosságot elváró makró
+#define EXPECT_EQ(expected, actual) EXPECTCMP((expected) == (actual), expected, actual)
+
+/// Eltérést elváró makró
+#define EXPECT_NE(expected, actual) EXPECTNE((expected) != (actual), expected, actual)
+
+/// Igaz értéket elváró makró
+#define EXPECT_TRUE(actual) EXPECTCMP(actual, "true", actual)
+
+/// Hamis értéket elváró makró
+#define EXPECT_FALSE(actual) EXPECTCMP(!(actual), "false", actual)
+
+/// Valós számok azonosságát elváró makró
+#define EXPECT_DOUBLE_EQ(expected, actual) EXPECTCMP(gtest_lite::almostEQ(expected, actual), expected, actual)
+
+/// C stringek (const char *) azonosságát tesztelő makró
+#define EXPECT_STREQ(expected, actual) ((actual != NULL) ? \
+    EXPECTCMP(strcmp(expected, actual) == 0, expected, actual) : \
+    EXPECT(false, "STR_EQ NULL pointert kapott!"))
+
+/// C stringek (const char *) eltéréset tesztelő makró
+#define EXPECT_STRNE(expected, actual) ((actual != NULL) ? \
+    EXPECTNE(strcmp(expected, actual) != 0, expected, actual) : \
+    EXPECT(false, "STR_EQ NULL pointert kapott!"))
+
+/// 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 é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.")
+
+/// 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.")
+
+/// 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
+#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édfüggvény egy publikus adattag, vagy tagfüggvény létezésének tesztelésére fordítási időben
+void hasMember(...) {}
+
+
+/// -----------------------------------
+/// Belső megvalósításhoz tartozó makrók, és osztályok.
+/// Nem célszerű közvetlenül használni, vagy módosítani
+/// -----------------------------------
+
+/// EXPECT: makró, hogy könnyen lecserélhető legyen
+#define EXPECT(expr, msg) gtest_lite::test.expect(expr, __FILE__, __LINE__, #msg)
+
+/// EXPECTEXP: általános kifejezés kiértékelése
+#define EXPECTEXP(expr, exp, act) gtest_lite::test.expect(expr, __FILE__, __LINE__, #expr) \
+    << "**A(z) '"#act << "'kifejezes\n**   erteke: " << std::boolalpha << (act) \
+    << "\n**   elvart: " << (exp) << std::endl
+
+/// EXPECTCMP: összehasonlítás
+#define EXPECTCMP(expr, exp, act) gtest_lite::test.expect(expr, __FILE__, __LINE__, #act) \
+    << "**A(z) '"#act << "'kifejezes\n**   erteke: " << std::boolalpha << (act) \
+    << "\n**   elvart: " << (exp) << std::endl
+
+/// EXPECTNE: összehasonlítás
+#define EXPECTNE(expr, exp, act) gtest_lite::test.expect(expr, __FILE__, __LINE__, #act) \
+    << "**A(z) '"#act << "'kifejezes\n**   erteke: " << std::boolalpha << (act) \
+    << "\n**   elvart, hogy nem: " << (exp) << std::endl
+
+/// 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
+    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;
+#ifndef CPORTA
+        std::cerr << "\n---> " << name << std::endl;
+#endif // CPORTA
+        ++sum;
+    }
+    /// Teszt vége
+    void end() {
+#ifdef CPORTA
+        if (!status)
+#endif // CPORTA
+        std::cerr << (status ? "     SIKERES" : "** HIBAS ****") << "\t" << name << " <---" << std::endl;
+    }
+
+    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) {
+        if (!st) {
+            ++failed;
+            status = false;
+            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**** HIBA: " << &file[i] << "(" << line << "): " << expr << " ****" << std::endl;
+        }
+        return null;
+    }
+
+    /// Eredményt adminisztráló tagfüggvény True a jó eset, mindig ír
+    std::ostream& tstatus(bool st, const char *file, int line) {
+        if (!st) {
+            ++failed;
+            status = false;
+        }
+        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 << (status ? "** SIKERES" : "** HIBAS") << " TESZT "<< &file[i] << "(" << line << ") **" << std::endl;
+     }
+
+    /// Destruktor
+    ~Test() {
+#ifdef CPORTA
+        if (failed)
+#endif // CPORTA
+            std::cerr << "\n==== TESZT VEGE ==== HIBAS/OSSZES: " << failed << "/" << sum << std::endl;
+    }
+};
+
+/// Egytelen statikus példány
+static Test test;
+
+/// Segédfüggvény 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
+inline bool almostEQ(double a, double  b) {
+    // eps: ha a relatív, vagy abszolút hiba ettől kisebb, akkor elfogadjuk
+    double eps = 10 * std::numeric_limits<double>::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

memtrace.h

+/*********************************
+Memoriaszivrgs-detektor
+Ksztette: Peregi Tams, BME IIT, 2011
+            petamas@iit.bme.hu
+Mdostsok:
+Szebernyi Imre:
+	kanri, 2013.
+	VS 2012, 2015.,
+	mem_dump, 2016.
+	memset felszabadtskor, 2018.
+*********************************/
+
+#ifndef MEMTRACE_H
+#define MEMTRACE_H
+
+#if defined(MEMTRACE)
+
+/*ha definilva van, akkor a hibkat ebbe a fjlba rja, egybknt stderr-re*/
+/*#define MEMTRACE_ERRFILE MEMTRACE.ERR*/
+
+/*ha definilva van, akkor futs kzben lncolt listt pt. Javasolt a hasznlata*/
+#define MEMTRACE_TO_MEMORY
+
+/*ha definilva van, akkor futs kzben fjlba rja a foglalsokat*/
+/*ekkor nincs ellenorzes, csak naplozas*/
+/*#define MEMTRACE_TO_FILE*/
+
+/*ha definilva van, akkor a megllskor automatikus riport kszl */
+#define MEMTRACE_AUTO
+
+/*ha definilva van, akkor malloc()/calloc()/realloc()/free() kvetve lesz*/
+#define MEMTRACE_C
+
+#ifdef MEMTRACE_C
+	/*ha definilva van, akkor free(NULL) nem okoz hibt*/
+	#define ALLOW_FREE_NULL
+#endif
+
+#ifdef __cplusplus
+	/*ha definilva van, akkor new/delete/new[]/delete[] kvetve lesz*/
+	#define MEMTRACE_CPP
+#endif
+
+#if defined(__cplusplus) && defined(MEMTRACE_TO_MEMORY)
+	/*ha definilva van, akkor atexit helyett objektumot hasznl*/
+	/*ajanlott bekapcsolni*/
+	#define USE_ATEXIT_OBJECT
+#endif
+
+/******************************************/
+/* INNEN NE MODOSITSD                     */
+/******************************************/
+#ifdef NO_MEMTRACE_TO_FILE
+	#undef MEMTRACE_TO_FILE
+#endif
+
+#ifdef NO_MEMTRACE_TO_MEMORY
+	#undef MEMTRACE_TO_MEMORY
+#endif
+
+#ifndef MEMTRACE_AUTO
+    #undef USE_ATEXIT_OBJECT
+#endif
+
+#ifdef __cplusplus
+	#define START_NAMESPACE namespace memtrace {
+	#define END_NAMESPACE } /*namespace*/
+	#define TRACEC(func) memtrace::func
+	#include <new>
+#else
+	#define START_NAMESPACE
+	#define END_NAMESPACE
+	#define TRACEC(func) func
+#endif
+
+// THROW deklarci vltozatai
+#if defined(_MSC_VER)
+  // VS rosszul kezeli az __cplusplus makrot
+  #if _MSC_VER < 1900
+    // * nem biztos, hogy j gy *
+	#define THROW_BADALLOC
+	#define THROW_NOTHING
+  #else
+    // C++11 vagy jabb
+	#define THROW_BADALLOC noxcept(false)
+	#define THROW_NOTHING noexcept
+  #endif
+#else
+  #if __cplusplus < 201103L
+	// C++2003 vagy rgebbi
+	#define THROW_BADALLOC throw (std::bad_alloc)
+	#define THROW_NOTHING throw ()
+  #else
+    // C++11 vagy jabb
+	#define THROW_BADALLOC noexcept(false)
+	#define THROW_NOTHING noexcept
+  #endif
+#endif
+
+START_NAMESPACE
+	int allocated_blocks();
+END_NAMESPACE
+
+#if defined(MEMTRACE_TO_MEMORY)
+START_NAMESPACE
+        int mem_check(void);
+END_NAMESPACE
+#endif
+
+#if defined(MEMTRACE_TO_MEMORY) && defined(USE_ATEXIT_OBJECT)
+#include <cstdio>
+START_NAMESPACE
+	class atexit_class {
+		private:
+			static int counter;
+			static int err;
+		public:
+			atexit_class() {
+#if defined(CPORTA) && !defined(CPORTA_NOSETBUF)
+			    if (counter == 0) {
+                        setbuf(stdout, 0);
+                        setbuf(stderr, 0);
+			    }
+#endif
+			counter++;
+			}
+
+			int check() {
+				if(--counter == 0)
+					err = mem_check();
+                return err;
+			}
+
+			~atexit_class() {
+			    check();
+            }
+	};
+
+static atexit_class atexit_obj;
+
+END_NAMESPACE
+#endif/*MEMTRACE_TO_MEMORY && USE_ATEXIT_OBJECT*/
+
+/*Innentl csak a "norml" include esetn kell */
+#ifndef FROM_MEMTRACE_CPP
+#include <stdlib.h>
+#ifdef __cplusplus
+	#include <iostream>
+/* ide gyjtjk a nemtrace-szel sszeakad headereket, hogy elbb legyenek */
+
+	#include <fstream>  // VS 2013 headerjben van deleted definci
+	#include <sstream>
+	#include <vector>
+	#include <algorithm>
+#endif
+#ifdef MEMTRACE_CPP
+	namespace std {
+		typedef void (*new_handler)();
+}
+#endif
+
+#ifdef MEMTRACE_C
+START_NAMESPACE
+	#undef malloc
+	#define malloc(size) TRACEC(traced_malloc)(size,#size,__LINE__,__FILE__)
+	void * traced_malloc(size_t size, const char *size_txt, int line, const char * file);
+
+	#undef calloc
+	#define calloc(count,size) TRACEC(traced_calloc)(count, size, #count","#size,__LINE__,__FILE__)
+	void * traced_calloc(size_t count, size_t size, const char *size_txt, int line, const char * file);
+
+	#undef free
+	#define free(p) TRACEC(traced_free)(p, #p,__LINE__,__FILE__)
+	void traced_free(void * p, const char *size_txt, int line, const char * file);
+
+	#undef realloc
+	#define realloc(old,size) TRACEC(traced_realloc)(old,size,#size,__LINE__,__FILE__)
+	void * traced_realloc(void * old, size_t size, const char *size_txt, int line, const char * file);
+
+	void mem_dump(void const *mem, size_t size, FILE* fp);
+
+
+END_NAMESPACE
+#endif/*MEMTRACE_C*/
+
+#ifdef MEMTRACE_CPP
+START_NAMESPACE
+	#undef set_new_handler
+	#define set_new_handler(f) TRACEC(_set_new_handler)(f)
+	void _set_new_handler(std::new_handler h);
+
+	void set_delete_call(int line, const char * file);
+END_NAMESPACE
+
+void * operator new(size_t size, int line, const char * file) THROW_BADALLOC;
+void * operator new[](size_t size, int line, const char * file) THROW_BADALLOC;
+void * operator new(size_t size) THROW_BADALLOC;
+void * operator new[](size_t size) THROW_BADALLOC;
+void operator delete(void * p)  THROW_NOTHING;
+void operator delete[](void * p) THROW_NOTHING;
+
+/* Visual C++ 2012 miatt kell, mert hklis, hogy nincs megfelel delete, br senki sem hasznlja */
+void operator delete(void *p, int, const char *) THROW_NOTHING;
+void operator delete[](void *p, int, const char *) THROW_NOTHING;
+
+
+#define new new(__LINE__, __FILE__)
+#define delete memtrace::set_delete_call(__LINE__, __FILE__),delete
+
+#ifdef CPORTA
+//#define system(...)  // system(__VA_ARGS__)
+#endif
+
+#endif /*MEMTRACE_CPP*/
+
+#endif /*FROM_MEMTRACE_CPP*/
+#endif /*MEMCHECK*/
+#endif /*MEMTRACE_H*/

swap.cbp

+<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
+<CodeBlocks_project_file>
+	<FileVersion major="1" minor="6" />
+	<Project>
+		<Option title="swap" />
+		<Option pch_mode="2" />
+		<Option compiler="gcc" />
+		<Build>
+			<Target title="Debug">
+				<Option output="bin/Debug/swap" prefix_auto="1" extension_auto="1" />
+				<Option object_output="obj/Debug/" />
+				<Option type="1" />
+				<Option compiler="gcc" />
+				<Compiler>
+					<Add option="-g" />
+					<Add option="-DMEMTRACE" />
+				</Compiler>
+			</Target>
+			<Target title="Release">
+				<Option output="bin/Release/swap" 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="-Werror" />
+		</Compiler>
+		<Unit filename="gtest_lite.h" />
+		<Unit filename="memtrace.cpp" />
+		<Unit filename="memtrace.h" />
+		<Unit filename="swap.cpp" />
+		<Unit filename="swap.h" />
+		<Unit filename="swap_test.cpp" />
+		<Extensions>
+			<code_completion />
+			<envvars />
+			<debugger />
+			<lib_finder disable_auto="1" />
+		</Extensions>
+	</Project>
+</CodeBlocks_project_file>

swap.cpp

+/**
+ * \file swap.cpp
+ */
+#include "swap.h"
+
+#error "itt valsitsa meg a fggvnyeket"
+
+void swap(bool& a, bool& b);

swap.depend

+# depslib dependency file v1.0
+1549102100 source:c:\users\szebi\desktop\eloadas_eloadas\proga\git\ell_feladat\cppswap\memtrace.cpp
+	<stdio.h>
+	<stdlib.h>
+	<string.h>
+	<time.h>
+	<ctype.h>
+	"memtrace.h"
+
+1549102513 c:\users\szebi\desktop\eloadas_eloadas\proga\git\ell_feladat\cppswap\memtrace.h
+	<new>
+	<cstdio>
+	<stdlib.h>
+	<iostream>
+	<fstream>
+	<sstream>
+	<vector>
+	<algorithm>
+

swap.h

+#ifndef _SWAP_H
+#define _SWAP_H
+/**
+ * Feladat:
+ * Valósítsa meg az alább deklarált függvényeket a swap.cpp fájlban úgy,
+ * hogy a swap_teszt.cpp program hiba nélkül leforduljon, és helyesen mûködjön!
+ *
+ */
+
+/**
+ * A swap megvalósításához aligha kell dinamikus memóriakezelés.
+ * Ezért ellenőrizni sem lenne szükséges.
+ */
+#include "memtrace.h"
+
+/**
+ * swap
+ * Két bool adat felcserélése
+ * @param a - egyik adat
+ * @param b - másik adat
+ */
+void swap(bool& a, bool& b);
+
+/**
+ * swap
+ * Két int adat felcserélése
+ * @param a - egyik adat
+ * @param b - másik adat
+ */
+void swap(int& a, int& b);
+
+/**
+ * swap
+ * Két char adat felcserélése
+ * @param a - egyik adat
+ * @param b - másik adat
+ */
+void swap(char& a, char& b);
+
+/**
+ * swap
+ * Két double adat felcserélése
+ * @param a - egyik adat
+ * @param b - másik adat
+ */
+void swap(double& a, double& b);
+
+/**
+ * swap
+ * Két const char* adat (pointer) felcserélése
+ * @param a - egyik pointer
+ * @param b - másik pointer
+ */
+void swap(const char*& a, const char*& b);  /// Figyelje meg a ref. típus jelölését!
+
+#endif  // _SWAP_H

swap.layout

+<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
+<CodeBlocks_layout_file>
+	<ActiveTarget name="Debug" />
+	<File name="gtest_lite.h" open="1" top="0" tabpos="1" split="0" active="1" splitpos="0" zoom_1="0" zoom_2="0">
+		<Cursor>
+			<Cursor1 position="0" topLine="0" />
+		</Cursor>
+	</File>
+	<File name="swap.cpp" open="1" top="1" tabpos="5" split="0" active="1" splitpos="0" zoom_1="0" zoom_2="0">
+		<Cursor>
+			<Cursor1 position="50" topLine="0" />
+		</Cursor>
+	</File>
+	<File name="memtrace.h" open="1" top="0" tabpos="2" split="0" active="1" splitpos="0" zoom_1="0" zoom_2="0">
+		<Cursor>
+			<Cursor1 position="0" topLine="0" />
+		</Cursor>
+	</File>
+	<File name="swap_test.cpp" open="1" top="0" tabpos="6" split="0" active="1" splitpos="0" zoom_1="0" zoom_2="0">
+		<Cursor>
+			<Cursor1 position="0" topLine="0" />
+		</Cursor>
+	</File>
+	<File name="swap.h" open="1" top="0" tabpos="3" split="0" active="1" splitpos="0" zoom_1="0" zoom_2="0">
+		<Cursor>
+			<Cursor1 position="944" topLine="38" />
+		</Cursor>
+	</File>
+	<File name="memtrace.cpp" open="1" top="0" tabpos="4" split="0" active="1" splitpos="0" zoom_1="0" zoom_2="0">
+		<Cursor>
+			<Cursor1 position="0" topLine="0" />
+		</Cursor>
+	</File>
+</CodeBlocks_layout_file>

swap_test.cpp

+/**
+ * \file swap.h
+ *
+ * Feladat:
+ * Valósítsa meg a swap.h fájlban deklarált függvényeket a swap.cpp fájlban úgy,
+ * hogy ez a program hiba nélkül leforduljon, és helyesen működjön!
+ *
+ * A program bemutatja a gtest_lite makróinak használatát.
+ * A makrók működését nem kell megértenie, mivel számos még nem tanult megoldást
+ * tartalmaznak.
+ *
+ */
+
+#include <iostream>
+#include "gtest_lite.h"
+#include "swap.h"
+
+int main() {
+
+    GTINIT(std::cin);       // Csak C(J)PORTA működéséhez kell
+
+    TEST(Swap, int) {       // Teszt eset kezdete. A paraméterekből csak kiírás lesz
+        int a = 1, b = 100;
+        int a0 = a, b0 = b;
+        swap(a, b);
+        EXPECT_EQ(b0, a);   // a két paraméter azonosságát várjuk
+        EXPECT_EQ(a0, b);   // a két paraméter azonosságát várjuk
+    } END
+
+    TEST(Swap, char) {      // Teszt eset kezdete.
+        char a = 'A', b = 'Z';
+        char a0 = a, b0 = b;
+        swap(a, b);
+        EXPECT_EQ(b0, a);   // két paraméter azonosságát várjuk
+        EXPECT_EQ(a0, b);
+    } END
+
+    TEST(Swap, bool) {      // Teszt eset kezdete.
+        bool a = true, b = false;
+        bool a0 = a, b0 = b;
+        swap(a, b);
+        EXPECT_EQ(b0, a);   // két paraméter azonosságát várjuk
+        EXPECT_EQ(a0, b);
+    } END
+
+    TEST(Swap, double) {    // Teszt eset kezdete
+        double a = 123.56, b = 8.954;
+        double a0 = a, b0 = b;
+        swap(a, b);
+        EXPECT_EQ(b0, a);   // a swap nem számított eredmény, ezért lehet EQ
+        EXPECT_EQ(a0, b);   // egyébként EXPECT_DOUBLE_EQ kellene
+    } END
+
+    TEST(Swap, char*) {     // Teszt eset kezdete
+        const char *a = "Hello", *b = "C++";
+        const char *a0 = a, *b0 = b;
+        swap(a, b);
+        EXPECT_EQ(b0, a); // két paraméter azonosságát várja
+        EXPECT_EQ(a0, b);
+    } END
+
+    GTEND(std::cerr);   // Csak C(J)PORTA működéséhez kell
+
+    return 0;
+}