Skip to content

Prog2 / labor_peldak / lab_07.5

Go to a project
Commit 35bc3ab8 by Szeberényi Imre
Options

v0

parents
Showing with 1435 additions and 0 deletions
Alakzatlab3/Makefile 0 → 100644
#
# Makefile az alakzatlab (7. labor) megoldasanak forditasara
# gnumake valtozat
# Linuxokon es ural2-n is elerheto
#
# A program neve (ezt allitjuk elo)
PROG = alakzat_main
# Rajzatablas valtozathoz torolje a kommentet a kovetkezo sorbol
#PROG = alakzat2_main
PROG_O = $(PROG).o alakzat.o kor.o szakasz.o szin.o pont.o # program object fajljai
# Rajzatablas valtozathoz torolje a kommentet a kovetkezo sorbol
#PROG_O += rajztabla.o
PROG_H = alakzat.h kor.h szakasz.h ellipszis.h szin.h pont.h # program header fajljai
# Rajzatablas valtozathoz torolje a kommentet a kovetkezo sorbol
#PROG_H += rajztabla.h
PROG_L = # program libjei
MTRACE_O = memtrace.o # memtrace object fajl
MTRACE_H = memtrace.h # memtrace header fajlja
CXX = g++ # a C fordito neve
#fordítasi opciok
CXXFLAGS = -pedantic -Wall -DMEMTRACE
CXXFLAGS += -g # es legyeb debug info is
LDFLAGS = -g # debug a linkelesnel is kell
# osszes object, osszes header osszes lib egyutt
OBJS = $(PROG_O) $(MTRACE_O)
HEADS = $(PROG_H) $(MTRACE_H)
LIBS = $(PROG_L) $(MEMCHK_L)
# Alapertelmezett cel
.PHONY: all
all: $(PROG)
# Eloallitjuk az objektekbol a PROG-ot
$(PROG): $(OBJS)
$(CXX) $(LDFLAGS) $(OBJS) -o $@ $(LIBS)
# Feltetelezzuk, hogy az osszes obj fugg az osszes headertol, ami nem feltetlenul igaz
$(OBJS): $(HEADS)
# Futtatas
.PHONY: run
run: $(PROG)
./$(PROG)
# takaritas igeny szerint
.PHONY: clean
clean:
rm -f $(OBJS) $(PROG)
Alakzatlab3/alakzat.cbp 0 → 100644
<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
<CodeBlocks_project_file>
<FileVersion major="1" minor="6" />
<Project>
<Option title="alakzat" />
<Option pch_mode="2" />
<Option compiler="gcc" />
<Build>
<Target title="Debug">
<Option output="bin/Debug/alakzat" 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/alakzat" 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="-Wall" />
<Add option="-Werror" />
</Compiler>
<Unit filename="alakzat.cpp" />
<Unit filename="alakzat.h" />
<Unit filename="alakzat3_main.cpp" />
<Unit filename="gen_array2.hpp" />
<Unit filename="kor.cpp" />
<Unit filename="kor.h" />
<Unit filename="memtrace.cpp" />
<Unit filename="memtrace.h" />
<Unit filename="poligon.cpp" />
<Unit filename="poligon.h" />
<Unit filename="pont.cpp" />
<Unit filename="pont.h" />
<Unit filename="rajztabla.cpp" />
<Unit filename="rajztabla.h" />
<Unit filename="szakasz.cpp" />
<Unit filename="szakasz.h" />
<Unit filename="szin.cpp" />
<Unit filename="szin.h" />
<Extensions>
<code_completion />
<debugger />
<DoxyBlocks>
<comment_style block="0" line="0" />
<doxyfile_project />
<doxyfile_build />
<doxyfile_warnings />
<doxyfile_output />
<doxyfile_dot />
<general />
</DoxyBlocks>
<envvars />
</Extensions>
</Project>
</CodeBlocks_project_file>
Alakzatlab3/alakzat.cpp 0 → 100644
/**
* \file kor.cpp
* Alakzat osztály tagfüggvényeinek megvalósítása
*/
#include "alakzat.h"
/// mozgat - eltolja az alakzat origóját
/// @param d - eltolás
void Alakzat::mozgat(const Pont& d) {
Szin tsz = sz; /// tényleges rajzolási szín elmentése
sz = BACKGND; /// rajzolási szín legyen a háttér színe
rajzol(); /// letörlés az eredeti helyről (rajzolás háttér színnel)
p0 += d; /// mozgatás: a pozíció változik
sz = tsz; /// rajzolási szín a tényleges szín
rajzol(); /// felrajzolása az új pozícióra
}
/// Globális << operátor az Alakzat adatainak kiírásához
std::ostream& operator<<(std::ostream& os, const Alakzat& a) {
return os << "p0=" << a.getp0() << ",szin=" << a.getsz();
}
Alakzatlab3/alakzat.h 0 → 100644
/**
* \file alakzat.h
* Alakzat alaposztály deklarációja
*/
#ifndef ALAKZAT_H
#define ALAKZAT_H
#include <iostream> // ostream miatt kell
#include "memtrace.h"
#include "pont.h"
#include "szin.h"
/// Alakzat abszrakt osztály
class Alakzat {
Pont p0; /// Alakzat origója, vagy bázis pontja.
/// Minden további adatot ehhez relatívan tárolunk. Geometriai értelemben nem feltétlenül origó.
Szin sz; /// alakzat színe
public:
/// Konstruktor
/// @param p0 - kezdőpont
/// @param sz - szín és átlátszóság
Alakzat(const Pont& p0, const Szin& sz) :p0(p0), sz(sz) {}
/// Pozíció lekérdezése
/// @return alakzat origója
const Pont& getp0() const { return p0; }
/// Szin lekérdezése
/// @return alakzat színe
const Szin& getsz() const { return sz; }
/// mozgat: origóját eltolja
/// @param d - eltolás vektora
void mozgat(const Pont& d);
/// rajzol
virtual void rajzol() const = 0;
/// Destruktor virtuális, hogy lehessen dinamikus adattagja
/// a származtatottnak
virtual ~Alakzat() {}
};
/// Globális << operátor az Alakzat adatainak kiírásához
/// @param os - ostream
/// @param a - alakzat
/// @return os - ostream
std::ostream& operator<<(std::ostream& os, const Alakzat& a);
#endif // ALAKZAT_H
Alakzatlab3/alakzat.vcproj 0 → 100644
<?xml version="1.0" encoding="windows-1250"?>
<VisualStudioProject
ProjectType="Visual C++"
Version="9,00"
Name="alakzat"
ProjectGUID="{30ABAD03-BC11-488A-B71E-C9347DA9B929}"
RootNamespace="alakzat"
Keyword="Win32Proj"
TargetFrameworkVersion="196613"
>
<Platforms>
<Platform
Name="Win32"
/>
</Platforms>
<ToolFiles>
</ToolFiles>
<Configurations>
<Configuration
Name="Debug|Win32"
OutputDirectory="$(SolutionDir)$(ConfigurationName)"
IntermediateDirectory="$(ConfigurationName)"
ConfigurationType="1"
CharacterSet="1"
>
<Tool
Name="VCPreBuildEventTool"
/>
<Tool
Name="VCCustomBuildTool"
/>
<Tool
Name="VCXMLDataGeneratorTool"
/>
<Tool
Name="VCWebServiceProxyGeneratorTool"
/>
<Tool
Name="VCMIDLTool"
/>
<Tool
Name="VCCLCompilerTool"
Optimization="0"
PreprocessorDefinitions="WIN32;_DEBUG;_CONSOLE;MEMTRACE"
MinimalRebuild="true"
BasicRuntimeChecks="3"
RuntimeLibrary="3"
UsePrecompiledHeader="0"
WarningLevel="3"
DebugInformationFormat="4"
/>
<Tool
Name="VCManagedResourceCompilerTool"
/>
<Tool
Name="VCResourceCompilerTool"
/>
<Tool
Name="VCPreLinkEventTool"
/>
<Tool
Name="VCLinkerTool"
LinkIncremental="2"
GenerateDebugInformation="true"
SubSystem="1"
TargetMachine="1"
/>
<Tool
Name="VCALinkTool"
/>
<Tool
Name="VCManifestTool"
/>
<Tool
Name="VCXDCMakeTool"
/>
<Tool
Name="VCBscMakeTool"
/>
<Tool
Name="VCFxCopTool"
/>
<Tool
Name="VCAppVerifierTool"
/>
<Tool
Name="VCPostBuildEventTool"
/>
</Configuration>
<Configuration
Name="Release|Win32"
OutputDirectory="$(SolutionDir)$(ConfigurationName)"
IntermediateDirectory="$(ConfigurationName)"
ConfigurationType="1"
CharacterSet="1"
WholeProgramOptimization="1"
>
<Tool
Name="VCPreBuildEventTool"
/>
<Tool
Name="VCCustomBuildTool"
/>
<Tool
Name="VCXMLDataGeneratorTool"
/>
<Tool
Name="VCWebServiceProxyGeneratorTool"
/>
<Tool
Name="VCMIDLTool"
/>
<Tool
Name="VCCLCompilerTool"
Optimization="2"
EnableIntrinsicFunctions="true"
PreprocessorDefinitions="WIN32;NDEBUG;_CONSOLE"
RuntimeLibrary="2"
EnableFunctionLevelLinking="true"
UsePrecompiledHeader="0"
WarningLevel="3"
DebugInformationFormat="3"
/>
<Tool
Name="VCManagedResourceCompilerTool"
/>
<Tool
Name="VCResourceCompilerTool"
/>
<Tool
Name="VCPreLinkEventTool"
/>
<Tool
Name="VCLinkerTool"
LinkIncremental="1"
GenerateDebugInformation="true"
SubSystem="1"
OptimizeReferences="2"
EnableCOMDATFolding="2"
TargetMachine="1"
/>
<Tool
Name="VCALinkTool"
/>
<Tool
Name="VCManifestTool"
/>
<Tool
Name="VCXDCMakeTool"
/>
<Tool
Name="VCBscMakeTool"
/>
<Tool
Name="VCFxCopTool"
/>
<Tool
Name="VCAppVerifierTool"
/>
<Tool
Name="VCPostBuildEventTool"
/>
</Configuration>
</Configurations>
<References>
</References>
<Files>
<Filter
Name="Source Files"
Filter="cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx"
UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}"
>
<File
RelativePath=".\alakzat.cpp"
>
</File>
<File
RelativePath=".\kor.cpp"
>
</File>
<File
RelativePath=".\main.cpp"
>
</File>
<File
RelativePath=".\pont.cpp"
>
</File>
<File
RelativePath=".\szakasz.cpp"
>
</File>
<File
RelativePath=".\szin.cpp"
>
</File>
<File
RelativePath=".\memtrace.cpp"
>
</File>
</Filter>
<Filter
Name="Header Files"
Filter="h;hpp;hxx;hm;inl;inc;xsd"
UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}"
>
<File
RelativePath=".\alakzat.h"
>
</File>
<File
RelativePath=".\kor.h"
>
</File>
<File
RelativePath=".\pont.h"
>
</File>
<File
RelativePath=".\szakasz.h"
>
</File>
<File
RelativePath=".\szin.h"
>
</File>
<File
RelativePath=".\memtrace.h"
>
</File>
</Filter>
</Files>
<Globals>
</Globals>
</VisualStudioProject>
Alakzatlab3/alakzat3_main.cpp 0 → 100644
/**
* \file alakzat3_main.cpp
* Alakzatlab2 deladat továbbfejlesztése:
* Bővítjük poligonnal, majd sablont is használunk.
*
* ELKESZULT makró értékei:
* == 1 - Van Poligon osztály, amit önmagában kipróbálunk, copy és assign még nincs használva.
* >= 2 - Poligon assign is tesztelve van.
* >= 3 - Poligon assing és copy is tesztelve van
* == 4 - Átemelésre került az előző heti Rajztabla osztály a projektbe, poligon nélküli teszt
* >= 5 - Rajztabla osztállyal együtt mindent kipróbálunk
* >= 6 - Szakasz klónozható
* >= 7 - Rajztabla is másolható, de csak szakaszt teszünk bele.
* >= 8 - Szorgalmi: Rajztabla is másolható. Poligon is klónozható.
* >= 9 - Rajztabla fixArray sablont használ
*/
#define ELKESZULT 1
#include <iostream>
#include <fstream>
#include "gtest_lite.h"
#include "szakasz.h"
#include "kor.h"
#if !defined(ELKESZULT) || ELKESZULT >= 1
# include "poligon.h"
#endif // ELKESZULT
#if ELKESZULT >= 3
#include "rajztabla.h"
#endif // ELKESZULT
using std::cout;
using std::endl;
int main(int argc, char** argv) {
GTINIT(std::cin); // Csak C(J)PORTA működéséhez kell
#if ELKESZULT == 1
TEST(Poligon, size) {
Poligon poli1(Pont(120,140), GREEN);
EXPECT_EQ(1u, poli1.size()) << "*** Nem jo a kezdo merete ***" << endl;
poli1.add(Pont(120,200));
cout << "add pont: " << poli1 << endl;
poli1.add(Pont(250,200));
cout << "add pont: " << poli1 << endl;
EXPECT_EQ(3u, poli1.size()) << "*** Nem jo a poligon merete ***" << endl;
/// Megnézzük a pontokat, hogy jók-e a koordináták
EXPECT_EQ(Pont(120,140), poli1[0]);
EXPECT_EQ(Pont(120,200), poli1[1]);
EXPECT_EQ(Pont(250,200), poli1[2]);
} ENDM
#endif // ELKESZULT
#if ELKESZULT >= 2 && ELKESZULT != 6 && ELKESZULT != 7 && ELKESZULT != 8
TEST(Poligon, assign) {
Poligon* poli1 = new Poligon(Pont(120,140), GREEN);
poli1->add(Pont(120,200));
poli1->add(Pont(250,200));
cout << "poli1: " << *poli1 << endl;
Poligon poli2(Pont(), BLACK);
/// Készitünk egy másolatot értékadással:
poli2 = *poli1;
cout << "poli2: " << poli2 << endl;
EXPECT_EQ(GREEN, poli2.getsz()) << "*** Nem kapott erteket az alaposztaly!\n";
EXPECT_EQ(3u, poli2.size()) << "*** Nem jo a poligon merete ***" << endl;
/// Megnézzük a pontokat, hogy jók-e a koordináták
EXPECT_EQ(Pont(120,140), poli2[0]);
EXPECT_EQ(Pont(120,200), poli2[1]);
EXPECT_EQ(Pont(250,200), poli2[2]);
cout << "Most toroljk az eredeti poligont\n";
delete poli1;
EXPECT_EQ(Pont(120,200), poli2[1]) << "*** Memoriaszemet? Biztos, hogy jol mukodik az assign? ***\n";
} ENDM
#endif // ELKESZULT
#if ELKESZULT >= 3 && ELKESZULT != 6 && ELKESZULT != 7
TEST(Poligon, copy) {
Poligon* poli3 = new Poligon(Pont(120,140), GREEN);
poli3->add(Pont(120,200));
poli3->add(Pont(250,200));
cout << "poli3: " << *poli3 << endl;
/// Készitünk egy másolatot copy kontruktorral.
Poligon poli4 = *poli3;
cout << "poli4: " << poli4 << endl;
EXPECT_EQ(GREEN, poli4.getsz()) << "*** Rosszul inicializálódott alaposztaly!\n";
EXPECT_EQ(Pont(120,140), poli4[0]);
EXPECT_EQ(Pont(120,200), poli4[1]);
EXPECT_EQ(Pont(250,200), poli4[2]);
/// Töröljük az eredeti poligont
delete poli3;
EXPECT_EQ(Pont(120,200), poli4[1]) << "*** Memoriaszemet? Biztos, hogy jol mukodik a copy ctor? ***\n";
} ENDM
#endif // ELKESZULT
#if ELKESZULT == 4
TEST(Rajztabla, Szakasz.es.kor) {
Rajztabla tabla;
cout << "tabla.size: " << tabla.size() << endl;
EXPECT_EQ(0u, tabla.size()) << "*** Nem jo a kezdo meret ***" << endl;
tabla.felrak(new Szakasz(Pont(20,40), 100, 0, WHITE));
tabla.felrak(new Kor(Pont(120,140), 50, BLUE));
cout << "tabla.size: " << tabla.size() << endl;
EXPECT_EQ(2u, tabla.size()) << "*** Nem jo a meret ***" << endl;
cout << "\nRajztabla rajzol:\n";
tabla.rajzol();
Pont delta(100, -10);
cout << "\nRajztabla mozgat delta=" << delta << ":" << endl;
tabla.mozgat(delta);
cout << "\nRajztabla torol:\n";
tabla.torol();
EXPECT_EQ(0u, tabla.size()) << "*** Torles utan nem jo meret ***" << endl;
cout << "tabla.size: " << tabla.size() << endl;
tabla.felrak(new Kor(Pont(10,20), 50, RED));
cout << "\nRajztabla rajzol:\n";
tabla.rajzol();
} ENDM
#endif
#if ELKESZULT == 5
TEST(Rajztabla, Poligonal) {
Rajztabla tabla;
tabla.felrak(new Szakasz(Pont(20,40), 100, 0, WHITE));
tabla.felrak(new Kor(Pont(120,140), 50, BLUE));
Poligon* poli = new Poligon(Pont(120,140), GREEN);
poli->add(Pont(120,200));
poli->add(Pont(250,200));
tabla.felrak(poli);
tabla.rajzol();
} ENDM
#endif // ELKESZULT
#if ELKESZULT == 6
TEST(Szakasz, clone) {
Szakasz* psz1 = new Szakasz(Pont(20,40), 100, 0, WHITE);
cout << *psz1 << endl;
Szakasz* psz2 = psz1->clone();
cout << *psz2 << endl;
EXPECT_EQ(psz1->getsz(), psz2->getsz());
EXPECT_EQ(psz1->getp0(), psz2->getp0());
EXPECT_EQ(psz1->getpv(), psz2->getpv());
delete psz1;
EXPECT_EQ(Pont(120,40), psz2->getpv());
delete psz2;
} ENDM
#endif // ELKESZULT
#if ELKESZULT == 7
TEST(Rajztabla, assign) {
Rajztabla tabla;
tabla.felrak(new Szakasz(Pont(20,40), 100, 0, WHITE));
cout << "tabla rajzol::\n";
tabla.rajzol();
EXPECT_EQ(1u, tabla.size());
{ // uj blokk, ebben jön létre az új tabla
Rajztabla ujtabla;
ujtabla = tabla;
ujtabla.felrak(new Szakasz(Pont(40,40), 100, 0, WHITE));
cout << "\nujtabla rajzol:\n";
ujtabla.rajzol();
EXPECT_EQ(2u, ujtabla.size());
}
cout << "\ntabla rajzol:\n";
tabla.rajzol();
EXPECT_EQ(1u, tabla.size());
} ENDM
#endif // ELKESZULT
#if ELKESZULT == 8
TEST(Rajztabla, assign.full) {
Rajztabla tabla;
tabla.felrak(new Szakasz(Pont(20,40), 100, 0, WHITE));
Poligon* poli = new Poligon(Pont(120,140), GREEN);
poli->add(Pont(120,200));
poli->add(Pont(250,200));
tabla.felrak(poli);
tabla.rajzol();
cout << "tabla rajzol::\n";
tabla.rajzol();
EXPECT_EQ(2u, tabla.size());
{ // uj blokk, ebben jön létre az új tabla
Rajztabla ujtabla;
ujtabla = tabla;
ujtabla.felrak(new Szakasz(Pont(40,40), 100, 0, WHITE));
cout << "\nujtabla rajzol:\n";
ujtabla.rajzol();
EXPECT_EQ(3u, ujtabla.size());
}
cout << "\ntabla rajzol:\n";
tabla.rajzol();
EXPECT_EQ(2u, tabla.size());
} ENDM
#endif // ELKESZULT
/// Itt a vége
if (ELKESZULT < 5 && !gtest_lite::test.fail())
ADD_FAILURE() << "\nLegalabb ELEKSZULT == 5-ig oldja meg a feladatokat!\n";
if (ELKESZULT >= 10 && !gtest_lite::test.fail())
std::cout << "\nSzuper! Mind kesz" << std::endl;
else
std::cout << "\nEKESZULT = " << ELKESZULT << std::endl;
GTEND(std::cerr); // Csak C(J)PORTA működéséhez kell
return 0;
}
Alakzatlab3/alakzatlab.uxf 0 → 100644
<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<diagram program="umlet" version="14.2">
<help_text>// Uncomment the following line to change the fontsize and font:
fontsize=14
// fontfamily=SansSerif //possible: SansSerif,Serif,Monospaced
//////////////////////////////////////////////////////////////////////////////////////////////
// Welcome to UMLet!
//
// Double-click on elements to add them to the diagram, or to copy them
// Edit elements by modifying the text in this panel
// Hold Ctrl to select multiple elements
// Use Ctrl+mouse to select via lasso
//
// Use +/- or Ctrl+mouse wheel to zoom
// Drag a whole relation at its central square icon
//
// Press Ctrl+C to copy the whole diagram to the system clipboard (then just paste it to, eg, Word)
// Edit the files in the "palettes" directory to create your own element palettes
//
// Select "Custom Elements &gt; New..." to create new element types
//////////////////////////////////////////////////////////////////////////////////////////////
// This text will be stored with each diagram; use it for notes.</help_text>
<zoom_level>10</zoom_level>
<element>
<type>com.baselet.element.old.element.Class</type>
<coordinates>
<x>150</x>
<y>40</y>
<w>240</w>
<h>170</h>
</coordinates>
<panel_attributes>/Alakzat/
--
-p0: Pont
-sz: Szin
--
+Alakzat(Pont&amp;, Szin&amp;)
+getp0(): Pont;
+getsz(): Szin;
+mozgat(): void
/+rajzol(): virtual void/
+~Alakzat(): virtual</panel_attributes>
<additional_attributes/>
</element>
<element>
<type>com.baselet.element.old.element.Class</type>
<coordinates>
<x>290</x>
<y>280</y>
<w>230</w>
<h>120</h>
</coordinates>
<panel_attributes>Szakasz
--
-pv: Pont
--
+Szakasz(Pont&amp;, Pont&amp;, Szin&amp;)
+Szakasz(Pont&amp;, int, int, Szin&amp;)
+getpv(): Pont;
+Rajzol(): void
</panel_attributes>
<additional_attributes/>
</element>
<element>
<type>com.baselet.element.old.element.Class</type>
<coordinates>
<x>40</x>
<y>280</y>
<w>230</w>
<h>120</h>
</coordinates>
<panel_attributes>Kor
--
- r: int
--
+ Kor(Pont&amp;, int, Szin&amp;)
+ getr(): int;
+ Rajzol(): void
</panel_attributes>
<additional_attributes/>
</element>
<element>
<type>com.baselet.element.old.element.Relation</type>
<coordinates>
<x>120</x>
<y>180</y>
<w>150</w>
<h>120</h>
</coordinates>
<panel_attributes>lt=&lt;&lt;-</panel_attributes>
<additional_attributes>130;30;30;100</additional_attributes>
</element>
<element>
<type>com.baselet.element.old.element.Relation</type>
<coordinates>
<x>260</x>
<y>180</y>
<w>160</w>
<h>120</h>
</coordinates>
<panel_attributes>lt=&lt;&lt;-</panel_attributes>
<additional_attributes>30;30;140;100</additional_attributes>
</element>
<element>
<type>com.baselet.element.old.element.Class</type>
<coordinates>
<x>540</x>
<y>40</y>
<w>230</w>
<h>120</h>
</coordinates>
<panel_attributes>Pont
--
+x: int
+y: int
--
+Pont(int, int)
+operator+=(Pont): Pont&amp;
+operator-(Pont): Pont</panel_attributes>
<additional_attributes/>
</element>
<element>
<type>com.baselet.element.old.element.Relation</type>
<coordinates>
<x>360</x>
<y>50</y>
<w>200</w>
<h>50</h>
</coordinates>
<panel_attributes>lt=&lt;&lt;&lt;&lt;-
m1=1
m2=1
</panel_attributes>
<additional_attributes>30;30;180;30</additional_attributes>
</element>
<element>
<type>com.baselet.element.old.element.Relation</type>
<coordinates>
<x>490</x>
<y>130</y>
<w>180</w>
<h>200</h>
</coordinates>
<panel_attributes>lt=&lt;&lt;&lt;&lt;-
m1=1
m2=1</panel_attributes>
<additional_attributes>30;180;160;180;160;30</additional_attributes>
</element>
</diagram>
Alakzatlab3/gen_array2.hpp 0 → 100644
#ifndef GEN_ARRAY2_HPP
#define GEN_ARRAY2_HPP
/**
* \file gen_array2.hpp
*
* Generikus tömb.
* Előadáson bemutatott 2. változat (sablon paraméterként kapott fix méretű).
* Az osztály definíciója és a tagfüggvények deklarációit
* nem tesszük külön fájlba, mivel a sablonok fordításánál
* mindkettőnek elérhetőnek kell lennie!
* Ezt jelezzük a .hpp kiterjesztéssel.
*/
/// Generikus tömb sablon
/// @param T - adattípus
/// @param s - méret
template <class T, unsigned int s> // sablon kezdõdik
class Array { // osztálysablon
T t[s]; // elemek tömbje. s teplate parameter
public:
/// Indexelés.
/// @param i - index
/// @return - referencia az adott indexű elemre
/// @return - hiba esetén kivételt dob
T& operator[](unsigned int i) {
if (i >= s) throw "Indexelesi hiba";
return t[i];
}
/// Indexelés konstans függvénye.
/// @param i - index
/// @return - referencia az adott indexű elemre
/// @return - hiba esetén kivételt dob
const T& operator[](unsigned int i) const {
if (i >= s) throw "Indexelesi hiba (const)";
return t[i];
}
};
#endif
Alakzatlab3/kor.cpp 0 → 100644
/**
* \file kor.cpp
* Kor osztly tagfggvnyeinek megvalstsa
*/
#include "kor.h"
/// Krt rajzol rajzol fv.
void Kor::rajzol() const {
std::cout << "Rajzol: " << *this << std::endl;
}
/// Globlis << opertor a Kor adatainak kirshoz
std::ostream& operator<<(std::ostream& os, const Kor& k) {
return os << "Kor " << (Alakzat&)k << ",r=" << k.getr();
}
Alakzatlab3/kor.h 0 → 100644
/**
* \file kor.h
* Kor osztály deklarációja
*/
#ifndef KOR_H
#define KOR_H
#include "alakzat.h"
/// Kor osztály.
/// Az alaposztály adatait sugárral bővítjük
class Kor : public Alakzat {
int r; /// sugár
public:
/// Konstruktor
/// @param p0 - kezdőpont
/// @param r - sugár
/// @param sz - szín és átlátszóság
Kor(const Pont& p0, int r, Szin sz)
:Alakzat(p0, sz), r(r) /// ős osztály inic.
{}
/// Sugár lekérdezése
/// @return kör sugara
int getr() const { return r; }
/// kört rajzol
void rajzol() const;
};
/// Globális << operátor a Kor adatainak kiírásához
/// @param os - ostream
/// @param k - kor
/// @return os - ostream
std::ostream& operator<<(std::ostream& os, const Kor& k);
#endif // KOR_H
Alakzatlab3/memtrace.h 0 → 100644
/*********************************
Memoriaszivargas-detektor
Keszitette: Peregi Tamas, BME IIT, 2011
petamas@iit.bme.hu
Kanari: Szeberenyi Imre, 2013.,
VS 2012: Szeberényi Imre, 2015.,
mem_dump: 2016.
inclue-ok: 2017., 2018., 2019., 2021.
*********************************/
#ifndef MEMTRACE_H
#define MEMTRACE_H
#if defined(MEMTRACE)
/*ha definiálva van, akkor a hibakat ebbe a fajlba írja, egyébkent stderr-re*/
/*#define MEMTRACE_ERRFILE MEMTRACE.ERR*/
/*ha definialva van, akkor futas kozben lancolt listat epit. Javasolt a hasznalata*/
#define MEMTRACE_TO_MEMORY
/*ha definialva van, akkor futas kozben fajlba irja a foglalasokat*/
/*ekkor nincs ellenorzes, csak naplozas*/
/*#define MEMTRACE_TO_FILE*/
/*ha definialva van, akkor a megallaskor automatikus riport keszul */
#define MEMTRACE_AUTO
/*ha definialva van, akkor malloc()/calloc()/realloc()/free() kovetve lesz*/
#define MEMTRACE_C
#ifdef MEMTRACE_C
/*ha definialva van, akkor free(NULL) nem okoz hibat*/
#define ALLOW_FREE_NULL
#endif
#ifdef __cplusplus
/*ha definialva van, akkor new/delete/new[]/delete[] kovetve lesz*/
#define MEMTRACE_CPP
#endif
#if defined(__cplusplus) && defined(MEMTRACE_TO_MEMORY)
/*ha definialva van, akkor atexit helyett objektumot hasznal*/
/*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 deklaráció változatai
#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 noexcept(false)
#define THROW_NOTHING noexcept
#endif
#else
#if __cplusplus < 201103L
// C++2003 vagy régebbi
#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*/
/*Innentol csak a "normal" include eseten kell, kulonben osszezavarja a mukodest*/
#ifndef FROM_MEMTRACE_CPP
#include <stdlib.h>
#ifdef __cplusplus
#include <iostream>
/* ide gyűjtjük a nemtrace-vel összeakadó headereket, hogy előbb legyenek */
#include <fstream> // VS 2013 headerjében van deleted definició
#include <sstream>
#include <vector>
#include <list>
#include <map>
#include <algorithm>
#include <functional>
#include <memory>
#include <iomanip>
#include <locale>
#include <typeinfo>
#include <ostream>
#include <stdexcept>
#include <ctime>
#if __cplusplus >= 201103L
#include <iterator>
#include <regex>
#endif
#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 = stdout);
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;
#if __cplusplus >= 201402L
// sized delete miatt: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3536.html
void operator delete(void * p, size_t) THROW_NOTHING;
void operator delete[](void * p, size_t) THROW_NOTHING;
#endif
/* Visual C++ 2012 miatt kell, mert háklis, hogy nincs megfelelő delete, bár senki sem használja */
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*/
#else
#pragma message ( "MEMTRACE NOT DEFINED" )
#endif /*MEMTRACE*/
#endif /*MEMTRACE_H*/
Alakzatlab3/poligon.cpp 0 → 100644
/**
* \file poligon.cpp
* Poligon osztály tagfüggvényinek megvalósítása
*/
#include "poligon.h"
/// Itt valósytsa meg a poligon kívül definiált tagfüggvényeit
/// és az insertert!
Alakzatlab3/poligon.h 0 → 100644
/**
* \file poligon.h
* Poligon osztály deklarációja.
*
* Deklaráltuk a legfontosabb tagfüggvényeket. Néhányat meg is valósítottunk.
* Valósítsa meg a hiányzókat itt inline-ként, illetve a bonyolultabb
* függvényeket kivül definiált tagvügvényként a poligon.cpp fájlban!
*
* Szükség estén bővítse az osztályt további tagfügvényekkel.
*/
#ifndef POLIGON_H
#define POLIGON_H
#include "alakzat.h"
/// Poligon osztály
/// dinamikusan tárolja a csúcspontokat
class Poligon : public Alakzat {
Pont *pontok; ///< csúcspontok tárolója, p0 az alaposztályban van
size_t np; ///< ennyi csúcsból áll
public:
/// Konstruktor
/// @param p0 - kezdőpont
/// @param sz - szín és átlátszóság
Poligon(const Pont& p0, const Szin sz);
/// Copy konstruktor
/// @param rhs - ezt másoljuk le
Poligon(const Poligon& rhs);
/// Értekadó operátor
/// @param rhs - ezt másoljuk le
/// @return önmaga
Poligon& operator=(const Poligon& rhs);
/// Csúcspontok darabszámának lekérdezése
/// @return darab
size_t size() const { return np; }
/// Adott csúcspont koordinátájának lekérdezése
/// Nem létező csp. esetén kivételt dob
/// @param i - i. csúcspont lekérdezése
/// @return adott csúcspont koordinátai
Pont operator[](size_t i) const;
/// Új csúcspont felvétele
/// @param p - új csúcspont koordinátai
void add(const Pont& p);
/// Poligont rajzol
void rajzol() const;
~Poligon() { delete[] pontok; }
};
/// Globális << operátor a Poligin adatainak kiírásához
/// @param os - ostream
/// @param p - poligon
/// @return os - ostream
std::ostream& operator<<(std::ostream& os, const Poligon& p);
#endif // POLIGON_H
Alakzatlab3/pont.cpp 0 → 100644
/**
* \file pont.cpp
* Pont osztály tagfüggvényeinek megvalósítása
*/
#include "pont.h"
/// += operator
Pont& Pont::operator+=(const Pont& rhs_p) {
x += rhs_p.x;
y += rhs_p.y;
return *this;
}
/// + operator
Pont Pont::operator+(const Pont& rhs_p) const {
return Pont(rhs_p.x+x, rhs_p.y+y);
}
/// - operator
Pont Pont::operator-(const Pont& rhs_p) const {
return Pont(x-rhs_p.x, y-rhs_p.y);
}
/// == operator
bool Pont::operator==(const Pont& rhs_p) const {
return x == rhs_p.x && y == rhs_p.y;
}
/// Globális << operátor a Pont adatainak kiírásához
std::ostream& operator<<(std::ostream& os, const Pont& p) {
return os << "(" << p.x <<"," << p.y << ")";
}
Alakzatlab3/pont.h 0 → 100644
/**
* \file pont.h
* Pont osztály deklarációja
*/
#ifndef PONT_H
#define PONT_H
#include <iostream> // ostream miatt kell
/// Pont osztály
/// Az egyszerűség kedvéért minden tagja publikus.
/// Így nem kell getter/setter.
/// Csak azok az operatorok lettek megvalósítva, melyeket használ a demo
struct Pont {
int x;
int y;
Pont(int x = 0, int y = 0) :x(x), y(y) {}
/// += operator
/// @param rhs_p - jobb oldali operandus (Pont)
/// @return saját maga megnövelve
Pont& operator+=(const Pont& rhs_p);
/// + operator
/// @param rhs_p - jobb oldali operandus (Pont)
/// @return új objektum (Pont) a két pont összege
Pont operator+(const Pont& rhs_p) const;
/// - operator
/// @param rhs_p - jobb oldali operandus (Pont)
/// @return új objektum (Pont) a két pont különbsége
Pont operator-(const Pont& rhs_p) const;
/// == operator
/// @param rhs_p - jobb oldali operandus (Pont)
/// @return true, ha két pont koordinátai azonosak
bool operator==(const Pont& rhs_p) const;
/// != operator
/// @param rhs_p - jobb oldali operandus (Pont)
/// @return true, ha két pont különbözik
bool operator!=(const Pont& rhs_p) const { return !(*this == rhs_p); }
};
/// Globális << operátor a Pont adatainak kiírásához
/// @param os - ostream
/// @param p - pont
/// @return os - ostream
std::ostream& operator<<(std::ostream& os, const Pont& p);
#endif // PONT_H
Alakzatlab3/rajztabla.cpp 0 → 100644
/**
* \file rajztabla.cpp
* Ebben a fájlban valósítsa meg a Rajztábla osztály nem inline tagfüggvényeit
*/
#include "rajztabla.h"
Alakzatlab3/rajztabla.h 0 → 100644
/**
* \file rajztabla.h
* Rajztabla osztály deklarációja
*/
#ifndef RAJZTABLA_H
#define RAJZTABLA_H
#include "alakzat.h"
/// Rajztabla osztály
class Rajztabla {
static const size_t MAXDB = 100;///< legegyszerűbb így belső (egész) konstanst felvenni egy osztályban.
Alakzat* tabla[MAXDB]; ///< tároló
size_t db; ///< aktuális darabszám
/// "Elrejtett" másoló konstruktor és értékadó operátor.
/// Az alapértelmezett változat nem jó, ezért ne legyen elérhető.
Rajztabla(const Rajztabla& rhs);
Rajztabla& operator=(const Rajztabla& rhs);
public:
Rajztabla() :db(0) { }
/// Visszadja, hogy hány síkidom van a táblán
/// @return - darabszám
size_t size() const { return db; }
/// Alakzatot tesz a rajztáblára
/// @param ap - pointer az alakzatra
void felrak(Alakzat *ap);
/// Kirajzolja az összes alakzatot
void rajzol() const ;
/// Az összes alakzatot elmozdítja
/// @param d - eltolás vektora
void mozgat(const Pont& d) const ;
/// letörli a táblát eltávolítja az objektumokat
void torol();
/// Lehet, hogy kell destruktor is.
};
#endif // RAJZTABLA_H
Alakzatlab3/szakasz.cpp 0 → 100644
/**
* \file szakasz.cpp
* Szakasz osztly tagfggvnyeinek megvalstsa
*/
#include "szakasz.h"
/// Szakaszt rajzol rajzol fv.
void Szakasz::rajzol() const {
std::cout << "Rajzol: " << *this << std::endl;
}
/// Globlis << opertor a Szakasz adatainak kirshoz
std::ostream& operator<<(std::ostream& os, const Szakasz& sz) {
return os << "Szakasz " << (Alakzat&)sz << ",pv=" << sz.getpv();
}
Alakzatlab3/szakasz.h 0 → 100644
/**
* \file szakasz.h
* Szakasz osztály deklarációja
*/
#ifndef SZAKASZ_H
#define SZAKASZ_H
#include "alakzat.h"
/// Szakasz osztály.
/// Az alaposztály adatait egy újabb ponttal bővítjük
class Szakasz : public Alakzat {
Pont pv; /// szakasz végpontja az origójához (p0) relatívan
public:
/// konstruktor 2 pontból
/// @param p0 - kezdőpont
/// @param pv - végpont
/// @param sz - szín és átlátszóság
Szakasz(const Pont& p0, const Pont& pv, Szin sz)
: Alakzat(p0, sz), pv(pv-p0) { }
/// konstruktor 1 pontból és 2 távolságból
/// @param p0 - kezdõpont
/// @param dx - x irányú távolság
/// @param dy - y irányú távolság
/// @param sz - szín és átlátszóság
Szakasz(const Pont& p0, int dx, int dy, Szin sz)
: Alakzat(p0, sz), pv(getp0()+Pont(dx, dy)) { }
/// Szakasz végpontjának lekérdezése
/// @return szakasz végpontja
Pont getpv() const { return getp0()+pv; }
/// szakaszt rajzol
void rajzol() const; // átdefiniáljuk a virt. fv-t.
};
/// Globális << operátor a Szakasz adatainak kiírásához
/// @param os - ostream
/// @param sz - szakasz
/// @return os - ostream
std::ostream& operator<<(std::ostream& os, const Szakasz& sz);
#endif // SZAKASZ_H
Alakzatlab3/szin.cpp 0 → 100644
/**
* \file szin.cpp
* Szin függvényeinek megvalósítása
*/
#include "szin.h"
// Szinek szövegkonstansai
static const char* szinek[] = { "BLACK", "WHITE", "RED", "GREEN", "BLUE" } ;
/// Globális << operátor a Szin kiírásához
/// Nincs ellenőrzés a túlindexelésre !
std::ostream& operator<<(std::ostream& os, Szin sz) {
return os << szinek[sz];
}
Alakzatlab3/szin.h 0 → 100644
/**
* \file szin.h
* Szin deklarációja
*/
#ifndef SZIN_H
#define SZIN_H
#include <iostream> // ostream miatt kell
/// Szín
enum Szin { BLACK, WHITE, RED, GREEN, BLUE };
/// Háttérszín
const Szin BACKGND = BLACK;
/// Globális << operátor a Szin kiírásához
/// @param os - ostream
/// @param sz - szín
/// @return os - ostream
std::ostream& operator<<(std::ostream& os, Szin sz);
#endif // SZIN_H
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