Skip to content

Prog2 / labor_peldak / lab_03

Go to a project
Commit e7fed769 by Szeberényi Imre
Options

V0

parents
Showing with 799 additions and 0 deletions
Komplex/Makefile 0 → 100644
# 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/komplex.cbp 0 → 100644
<?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 0 → 100644
/**
* \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 0 → 100644
/**
* \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 0 → 100644
<?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 0 → 100644
<?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 0 → 100644
/**
* \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 0 → 100644
<?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 0 → 100644
/*
* \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;
}
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or sign in to comment