Skip to content

Prog2 / labor_peldak / lab_07

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

v0

parents
Showing with 1563 additions and 0 deletions
Alakzatlab2/Makefile 0 → 100644
# Makefile Alakzatlab2-hoz
# Solaris (ural2) es Linux ala.
objs = alakzat.o pont.o szin.o kor.o szakasz.o teglalap.o \
haromszog.o poligon.o rajztabla.o main.o memtrace.o
heads = alakzat.h pont.h szin.h kor.h szakasz.h teglalap.h \
haromszog.h poligon.h rajztabla.h memtrace.h
CXX = g++ # # a C++ fordito neve
#CXX = clang++ # # clang-ot (llvm) is erdemes kiprobalni
CXXFLAGS = -pedantic -Wall -Werror # C++ kapcsolok: legyen bobeszedu,
CXXFLAGS += -g # # ... es legyen debug info is
CXXFLAGS += -DMEMTRACE
# alapertelmezett cel: erdeklodik, hogy melyik legyen
.PHONY: all
all: $(objs)
$(CXX) $(objs) -o alakzat2
$(objs1): $(heads)
# takaritas igeny szerint
.PHONY: clean
clean:
rm -f $(objs) alakzat2
Alakzatlab2/alakzat.cpp 0 → 100644
/**
* \file kor.cpp
* Alakzat osztály tagfüggvényinek megvalósítása
*/
#include "alakzat.h"
/// mozgat - eltolja az alakzat origóját
/// @param d - eltolás vektora
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(); // A vonal letörlés az eredeti helyről
p0 += d; // mozgatás: a pozíció változik
sz = tsz; // rajzolási szín a tényleges szín
rajzol(); // A vonal felrajzolása az új pozícióra
}
/// Globális << operátor
std::ostream& operator<<(std::ostream& os, const Alakzat& a) {
return os << "p0=" << a.getp0() << ",szin=" << a.getsz();
}
Alakzatlab2/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" // így mindenki include-olni fogja, mert az alaposztályt minden fordítási egység
#include "pont.h"
#include "szin.h"
/// Alakzat abszrakt osztály
class Alakzat {
protected:
Pont p0; ///< alakzat origója
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
Pont getp0() const { return p0; }
/// Szin lekérdezése
/// @return alakzat színe
Szin getsz() const { return sz; }
/// mozgat: origóját eltolja
/// @param d - eltolás vektora
void mozgat(const Pont& d);
/// rajzol
virtual void rajzol() = 0;
/// Destruktor virtuális, hogy lehessen dinamikus adattagja
/// a származtatottnak
virtual ~Alakzat() {}
};
/// Globális << operátor
std::ostream& operator<<(std::ostream&, const Alakzat&);
#endif // ALAKZAT_H
Alakzatlab2/alakzat2.cbp 0 → 100644
<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
<CodeBlocks_project_file>
<FileVersion major="1" minor="6" />
<Project>
<Option title="alakzat2" />
<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="-DMEMTRACE" />
</Compiler>
<Unit filename="alakzat.cpp" />
<Unit filename="alakzat.h" />
<Unit filename="alakzat2_main.cpp" />
<Unit filename="haromszog.cpp" />
<Unit filename="haromszog.h" />
<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" />
<Unit filename="teglalap.cpp" />
<Unit filename="teglalap.h" />
<Extensions>
<code_completion />
<debugger />
<envvars />
</Extensions>
</Project>
</CodeBlocks_project_file>
Alakzatlab2/alakzat2_main.cpp 0 → 100644
/**
* \file main.cpp
* Demó program az alakzat és rajztábla osztályok kipróbálására.
* Felrajzol pár alakzatot, majd elmozgatja kicsit.
*/
#include <iostream>
#include "szakasz.h"
#include "kor.h"
#include "teglalap.h"
#include "haromszog.h"
#include "poligon.h"
#include "rajztabla.h"
using std::cout;
using std::endl;
//#define MASOL
int main(int argc, char** argv) {
Rajztabla tabla;
tabla.felrak(new Szakasz(Pont(20,40), 100, 0, WHITE));
tabla.felrak(new Kor(Pont(120,140), 50, BLUE));
tabla.felrak(new Teglalap(Pont(20,40), Pont(60, 100), GREEN));
tabla.felrak(new Haromszog(Pont(20,40), Pont(60, 100), Pont(50, 60), GREEN));
Poligon* poli = new Poligon(Pont(120,140), GREEN);
poli->add(Pont(120,200));
poli->add(Pont(250,200));
tabla.felrak(poli);
cout << "Rajztabla rajzol:" << endl;
tabla.rajzol();
Pont delta(100, -10);
cout << endl << "Rajztabla mozgat delta=" << delta << ":" << endl;
tabla.mozgat(delta);
cout << "\nRajztabla torol:" << endl;
tabla.torol();
tabla.felrak(new Kor(Pont(10,20), 50, RED));
cout << endl << "Rajztabla rajzol:" << endl;
tabla.rajzol();
#ifdef MASOL
Rajztabla masik;
masik = tabla;
cout << endl << "Masik rajztabla rajzol:" << endl;
masik.rajzol();
#endif
return 0;
}
Alakzatlab2/alakzatlab2.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>{2F45B2D3-9FE7-4975-BEAE-D3D24AACE45B}</ProjectGuid>
<Keyword>Win32Proj</Keyword>
<RootNamespace>Alakzatlab</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>
</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;MEMTRACE;%(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="alakzat.h" />
<ClInclude Include="haromszog.h" />
<ClInclude Include="kor.h" />
<ClInclude Include="memtrace.h" />
<ClInclude Include="poligon.h" />
<ClInclude Include="pont.h" />
<ClInclude Include="rajztabla.h" />
<ClInclude Include="szakasz.h" />
<ClInclude Include="szin.h" />
<ClInclude Include="teglalap.h" />
</ItemGroup>
<ItemGroup>
<ClCompile Include="alakzat.cpp" />
<ClCompile Include="haromszog.cpp" />
<ClCompile Include="kor.cpp" />
<ClCompile Include="alakzat2_main.cpp" />
<ClCompile Include="memtrace.cpp" />
<ClCompile Include="poligon.cpp" />
<ClCompile Include="pont.cpp" />
<ClCompile Include="rajztabla.cpp" />
<ClCompile Include="szakasz.cpp" />
<ClCompile Include="szin.cpp" />
<ClCompile Include="teglalap.cpp" />
</ItemGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
<ImportGroup Label="ExtensionTargets">
</ImportGroup>
</Project>
Alakzatlab2/alakzatlab2.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="alakzat.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="haromszog.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="kor.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="memtrace.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="poligon.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="pont.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="rajztabla.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="szakasz.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="szin.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="teglalap.h">
<Filter>Header Files</Filter>
</ClInclude>
</ItemGroup>
<ItemGroup>
<ClCompile Include="alakzat.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="haromszog.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="kor.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="main.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="memtrace.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="poligon.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="pont.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="rajztabla.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="szakasz.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="szin.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="teglalap.cpp">
<Filter>Source Files</Filter>
</ClCompile>
</ItemGroup>
</Project>
\ No newline at end of file
Alakzatlab2/doxygen/doxyfile 0 → 100644
This source diff could not be displayed because it is too large. You can view the blob instead.
Alakzatlab2/haromszog.cpp 0 → 100644
/**
* \file haromszog.cpp
* Haromszog osztály tagfüggvényinek megvalósítása
*/
#include "haromszog.h"
/// Háromszög rajzoló rajzol fv.
void Haromszog::rajzol() {
std::cout << "Rajzol: " << *this << std::endl;
}
/// Globális << operátor
std::ostream& operator<<(std::ostream& os, const Haromszog& h) {
return os << "Haromszog " << (Alakzat&)h << ",p1=" << h.getp1() << ",p2=" << h.getp2();
}
Alakzatlab2/haromszog.h 0 → 100644
/**
* \file haromszog.h
* Haromszog osztály deklarációja
*/
#ifndef HAROMSZOG_H
#define HAROMSZOG_H
#include "alakzat.h"
/// Haromszog osztály
class Haromszog : public Alakzat {
Pont p1; ///< második csúcspont
Pont p2; ///< harmadik csúcspont
public:
/// Konstruktor
/// @param p0 - kezdőpont
/// @param p1 - második csúcspont
/// @param p2 - harmadik csúcspont
/// @param sz - szín és átlátszóság
Haromszog(const Pont& p0, const Pont& p1, const Pont &p2, Szin sz)
:Alakzat(p0, sz), p1(p1-p0), p2(p2-p0) // ős osztály inic.
{}
/// Második csúcspont lekérdezése
/// @return második csúcspont
Pont getp1() const { return p1+p0; } // p0-hoz képest relatívan tárolunk
/// Harmadik csúcspont lekérdezése
/// @return harmadik csúcspont
Pont getp2() const { return p2+p0; } // p0-hoz képest relatívan tárolunk
/// háromszöget rajzol
void rajzol();
};
/// Globális << operátor
std::ostream& operator<<(std::ostream& os, const Haromszog& t);
#endif // HAROMSZOG_H
Alakzatlab2/kor.cpp 0 → 100644
/**
* \file kor.cpp
* Kor osztály tagfüggvényinek megvalósítása
*/
#include "kor.h"
/// Kört rajzoló rajzol fv.
void Kor::rajzol() {
std::cout << "Rajzol: " << *this << std::endl;
}
/// Globális << operátor
std::ostream& operator<<(std::ostream& os, const Kor& k) {
return os << "Kor " << (Alakzat&)k << ",r=" << k.getr();
}
Alakzatlab2/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
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();
};
/// Globális << operátor
std::ostream& operator<<(std::ostream& os, const Kor& k);
#endif // KOR_H
Alakzatlab2/memtrace.cpp 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.
meset felszabaditaskor: 2018.
typo: 2019.
singleton: 2019.
*********************************/
/*definialni kell, ha nem paracssorbol allitjuk be (-DMEMTRACE) */
/*#define MEMTRACE */
#ifdef _MSC_VER
#define _CRT_SECURE_NO_WARNINGS 1
#endif
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <ctype.h>
#ifdef MEMTRACE
#define FROM_MEMTRACE_CPP
#include "memtrace.h"
#define FMALLOC 0
#define FCALLOC 1
#define FREALLOC 2
#define FFREE 3
#define FNEW 4
#define FDELETE 5
#define FNEWARR 6
#define FDELETEARR 7
#define COMP(a,d) (((a)<=3 && (d)<=3) || ((d)==(a)+1))
#define PU(p) ((char*)p+CANARY_LEN) // mem pointerbol user poi
#define P(pu) ((char*)pu-CANARY_LEN) // user pointerbol mem poi
#define XSTR(s) STR(s)
#define STR(s) #s
/*******************************************************************/
/* Segedfuggvenyek es egyebek */
/*******************************************************************/
START_NAMESPACE
static FILE *fperror;
#ifdef MEMTRACE_TO_MEMORY
static const unsigned int CANARY_LEN = 64;
#else
static const unsigned int CANARY_LEN = 0;
#endif
static const unsigned char canary_byte1 = 'k';
static const unsigned char canary_byte2 = 'K';
static unsigned char random_byte;
typedef enum {FALSE,TRUE} BOOL;
static const char * pretty[] = {"malloc(", "calloc(", "realloc(", "free(",
"new", "delete", "new[]", "delete[]"};
static const char * basename(const char * s) {
const char *s1,*s2;
s1 = strrchr(s,'/');
if(s1==NULL) s1 = s; else s1++;
s2 = strrchr(s1, '\\');
if(s2==NULL) s2 = s1; else s2++;
return s2;
}
static char *StrCpy(char ** to, const char * from) {
if(from == NULL) {
*to = NULL;
} else {
*to = (char*)malloc(strlen(from)+1);
if(*to) strcpy(*to, from);
}
return *to;
}
static void *canary_malloc(size_t size, unsigned char data) {
char *p = (char *)malloc(size+2*CANARY_LEN);
if (p) {
memset(p, canary_byte1, CANARY_LEN);
memset(p+CANARY_LEN, data, size);
memset(p+CANARY_LEN+size, canary_byte2, CANARY_LEN);
}
return p;
}
static int chk_canary(void *p, size_t size) {
unsigned char *pc = (unsigned char*)p;
unsigned int i;
for (i = 0; i < CANARY_LEN; i++)
if (pc[i] != canary_byte1)
return -1;
pc += CANARY_LEN+size;
for (i = 0; i < CANARY_LEN; i++)
if (pc[i] != canary_byte2)
return 1;
return 0;
}
typedef struct {
int f; /* allocator func */
int line;
char * par_txt;
char * file;
} call_t;
static call_t pack(int f, const char * par_txt, int line, const char * file) {
call_t ret;
ret.f = f;
ret.line = line;
StrCpy(&ret.par_txt, par_txt);
StrCpy(&ret.file, file);
return ret;
}
static void print_call(const char * msg, call_t call) {
if(msg) fprintf(fperror, "%s", msg);
fprintf(fperror, "%s", pretty[call.f]);
fprintf(fperror, "%s", call.par_txt ? call.par_txt : "?");
if (call.f <= 3) fprintf(fperror, ")");
fprintf(fperror," @ %s:", call.file ? basename(call.file) : "?");
fprintf(fperror,"%d\n",call.line ? call.line : 0);
}
/* memoriateruletet dump */
static void dump_memory(void const *mem, size_t size, size_t can_len, FILE* fp) {
unsigned char const *m=(unsigned char const *) mem;
unsigned int s, o;
if (can_len > 0)
fprintf(fp, "Dump (addr: %p kanari hossz: %d):\n", m+can_len, (int)can_len);
else
fprintf(fp, "Dump: (addr: %p) \n", m);
size += 2*can_len;
for (s = 0; s < (size+15)/16; s++) {
fprintf(fp, "%04x:%c ", s*16, s*16 < can_len || s*16 >= size-can_len ? ' ' : '*');
for (o = 0; o < 16; o++) {
if (o == 8) fprintf(fp, " ");
if (s*16+o < size)
fprintf(fp, "%02x ", m[s*16+o]);
else
fprintf(fp, " ");
}
fprintf(fp, " ");
for (o = 0; o < 16; o++) {
if (s*16+o < size)
fprintf(fp, "%c", isprint(m[s*16+o]) ? m[s*16+o] : '.');
else
fprintf(fp, " ");
}
fprintf(fp, "\n");
}
}
void mem_dump(void const *mem, size_t size, FILE* fp) {
dump_memory(mem, size, 0, fp);
}
static BOOL dying;
static void die(const char * msg, void * p, size_t size, call_t * a, call_t * d) {
#ifdef MEMTRACE_ERRFILE
fperror = fopen(XSTR(MEMTRACE_ERRFILE), "w");
#endif
fprintf(fperror,"%s\n",msg);
if (p) {
fprintf(fperror, "\tPointer:\t%p", PU(p));
if (size) fprintf(fperror," (%d byte)", (int)size);
fprintf(fperror,"\n");
}
if (a) print_call("\tFoglalas:\t", *a);
if (d) print_call("\tFelszabaditas:\t", *d);
if (p) dump_memory(p, size, CANARY_LEN, fperror);
dying = TRUE;
exit(120);
}
static void initialize();
END_NAMESPACE
/*******************************************************************/
/* MEMTRACE_TO_MEMORY */
/*******************************************************************/
#ifdef MEMTRACE_TO_MEMORY
START_NAMESPACE
typedef struct _registry_item {
void * p; /* mem pointer*/
size_t size; /* size*/
call_t call;
struct _registry_item * next;
} registry_item;
static registry_item registry; /*sentinel*/
static void print_registry_item(registry_item * p) {
if (p) {
print_registry_item(p->next);
fprintf(fperror, "\t%p%5d byte ",p->p, (int)p->size);
print_call(NULL, p->call);
if(p->call.par_txt) free(p->call.par_txt);
if(p->call.file) free(p->call.file);
free(p);
}
}
/* ha nincs hiba, akkor 0-val tér vissza */
int mem_check(void) {
initialize();
if(dying) return 2; /* címzési hiba */
if(registry.next) {
/*szivarog*/
#ifdef MEMTRACE_ERRFILE
fperror = fopen(XSTR(MEMTRACE_ERRFILE), "w");
#endif
fprintf(fperror, "Szivargas:\n");
print_registry_item(registry.next);
registry.next = NULL;
return 1; /* memória fogyás */
}
return 0;
}
END_NAMESPACE
#endif/*MEMTRACE_TO_MEMORY*/
/*******************************************************************/
/* MEMTRACE_TO_FILE */
/*******************************************************************/
#ifdef MEMTRACE_TO_FILE
START_NAMESPACE
static FILE * trace_file;
END_NAMESPACE
#endif
/*******************************************************************/
/* register/unregister */
/*******************************************************************/
START_NAMESPACE
static int allocated_blks;
int allocated_blocks() { return allocated_blks; }
static BOOL register_memory(void * p, size_t size, call_t call) {
initialize();
allocated_blks++;
#ifdef MEMTRACE_TO_FILE
fprintf(trace_file, "%p\t%d\t%s%s", PU(p), (int)size, pretty[call.f], call.par_txt ? call.par_txt : "?");
if (call.f <= 3) fprintf(trace_file, ")");
fprintf(trace_file, "\t%d\t%s\n", call.line, call.file ? call.file : "?");
fflush(trace_file);
#endif
#ifdef MEMTRACE_TO_MEMORY
{/*C-blokk*/
registry_item * n = (registry_item*)malloc(sizeof(registry_item));
if(n==NULL) return FALSE;
n->p = p;
n->size = size;
n->call = call;
n->next = registry.next;
registry.next = n;
}/*C-blokk*/
#endif
return TRUE;
}
#ifdef MEMTRACE_TO_MEMORY
static registry_item *find_registry_item(void * p) {
registry_item *n = &registry;
for(; n->next && n->next->p != p ; n=n->next);
return n;
}
#endif
static void unregister_memory(void * p, call_t call) {
initialize();
#ifdef MEMTRACE_TO_FILE
fprintf(trace_file, "%p\t%d\t%s%s", PU(p), -1, pretty[call.f], call.par_txt ? call.par_txt : "?");
if (call.f <= 3) fprintf(trace_file, ")");
fprintf(trace_file,"\t%d\t%s\n",call.line, call.file ? call.file : "?");
fflush(trace_file);
#endif
#ifdef MEMTRACE_TO_MEMORY
{ /*C-blokk*/
registry_item * n = find_registry_item(p);
if(n->next) {
allocated_blks--;
registry_item * r = n->next;
n->next = r->next;
if(COMP(r->call.f,call.f)) {
int chk = chk_canary(r->p, r->size);
if (chk < 0)
die("Blokk elott serult a memoria:", r->p,r->size,&r->call,&call);
if (chk > 0)
die("Blokk utan serult a memoria", r->p,r->size,&r->call,&call);
/*rendben van minden*/
if(call.par_txt) free(call.par_txt);
if(r->call.par_txt) free(r->call.par_txt);
if(call.file) free(call.file);
if(r->call.file) free(r->call.file);
memset(PU(r->p), 'f', r->size);
PU(r->p)[r->size-1] = 0;
free(r);
} else {
/*hibas felszabaditas*/
die("Hibas felszabaditas:",r->p,r->size,&r->call,&call);
}
} else {
die("Nem letezo, vagy mar felszabaditott adat felszabaditasa:", p, 0,NULL,&call);
}
} /*C-blokk*/
#endif
}
END_NAMESPACE
/*******************************************************************/
/* C-stílusú memóriakezelés */
/*******************************************************************/
#ifdef MEMTRACE_C
START_NAMESPACE
void * traced_malloc(size_t size, const char * par_txt, int line, const char * file) {
void * p;
initialize();
p = canary_malloc(size, random_byte);
if (p) {
if(!register_memory(p,size,pack(FMALLOC,par_txt,line,file))) {
free(p);
return NULL;
}
return PU(p);
}
return NULL;
}
void * traced_calloc(size_t count, size_t size, const char * par_txt, int line, const char * file) {
void * p;
initialize();
size *= count;
p = canary_malloc(size, 0);
if(p) {
if(!register_memory(p,size,pack(FCALLOC,par_txt,line,file))) {
free(p);
return NULL;
}
return PU(p);
}
return NULL;
}
void traced_free(void * pu, const char * par_txt, int line, const char * file) {
initialize();
if(pu) {
unregister_memory(P(pu), pack(FFREE,par_txt,line,file));
free(P(pu));
} else {
/*free(NULL) eset*/
#ifdef MEMTRACE_TO_FILE
fprintf(trace_file,"%s\t%d\t%10s\t","NULL",-1,pretty[FFREE]);
fprintf(trace_file,"%d\t%s\n",line,file ? file : "?");
fflush(trace_file);
#endif
#ifndef ALLOW_FREE_NULL
{/*C-blokk*/
call_t call;
call = pack(FFREE,par_txt,line,file);
die("free(NULL) hivasa:",NULL,0,NULL,&call);
}/*C-blokk*/
#endif
}
}
void * traced_realloc(void * old, size_t size, const char * par_txt, int line, const char * file) {
void * p;
size_t oldsize = 0;
registry_item * n;
initialize();
#ifdef MEMTRACE_TO_MEMORY
n = find_registry_item(P(old));
if (n) oldsize = n->next->size;
p = canary_malloc(size, random_byte);
#else
p = realloc(old, size);
#endif
if (p) {
/*Ha sikerult a foglalas, regisztraljuk*/
register_memory(p,size,pack(FREALLOC, par_txt, line,file));
if (old) {
#ifdef MEMTRACE_TO_MEMORY
int cpsize = 2*CANARY_LEN;
if (oldsize < size) cpsize += oldsize;
else cpsize += size;
memcpy(p, P(old), cpsize);
#endif
unregister_memory(P(old), pack(FREALLOC, par_txt, line, file));
#ifdef MEMTRACE_TO_MEMORY
free P(old);
#endif
}
return PU(p);
} else {
return NULL;
}
}
END_NAMESPACE
#endif/*MEMTRACE_C*/
/*******************************************************************/
/* C++-stílusú memóriakezelés */
/*******************************************************************/
#ifdef MEMTRACE_CPP
START_NAMESPACE
std::new_handler _new_handler;
void _set_new_handler(std::new_handler h) {
initialize();
_new_handler = h;
}
static call_t delete_call;
static BOOL delete_called;
void set_delete_call(int line, const char * file) {
initialize();
delete_call=pack(0,"",line,file); /*func értéke lényegtelen, majd felülírjuk*/
delete_called = TRUE;
}
void * traced_new(size_t size, int line, const char * file, int func) {
initialize();
for (;;) {
void * p = canary_malloc(size, random_byte);
if(p) {
register_memory(p,size,pack(func,"",line,file));
return PU(p);
}
if (_new_handler == 0)
throw std::bad_alloc();
_new_handler();
}
}
void traced_delete(void * pu, int func) {
initialize();
if(pu) {
/*kiolvasom call-t, ha van*/
memtrace::call_t call = delete_called ? (delete_call.f=func, delete_call) : pack(func,NULL,0,NULL);
memtrace::unregister_memory(P(pu),call);
free(P(pu));
}
delete_called=FALSE;
}
END_NAMESPACE
void * operator new(size_t size, int line, const char * file) THROW_BADALLOC {
return memtrace::traced_new(size,line,file,FNEW);
}
void * operator new[](size_t size, int line, const char * file) THROW_BADALLOC {
return memtrace::traced_new(size,line,file,FNEWARR);
}
void * operator new(size_t size) THROW_BADALLOC {
return memtrace::traced_new(size,0,NULL,FNEW);
}
void * operator new[](size_t size) THROW_BADALLOC {
return memtrace::traced_new(size,0,NULL,FNEWARR);
}
void operator delete(void * p) THROW_NOTHING {
memtrace::traced_delete(p,FDELETE);
}
void operator delete[](void * p) THROW_NOTHING {
memtrace::traced_delete(p,FDELETEARR);
}
/* 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 {
memtrace::traced_delete(p,FDELETE);
}
void operator delete[](void * p, int, const char *) THROW_NOTHING {
memtrace::traced_delete(p,FDELETE);
}
#endif/*MEMTRACE_CPP*/
/*******************************************************************/
/* initialize */
/*******************************************************************/
START_NAMESPACE
static void initialize() {
static BOOL first = TRUE;
if(first) {
fperror = stderr;
random_byte = (unsigned char)time(NULL);
first = FALSE;
dying = FALSE;
#ifdef MEMTRACE_TO_MEMORY
registry.next = NULL;
#if !defined(USE_ATEXIT_OBJECT) && defined(MEMTRACE_AUTO)
atexit((void(*)(void))mem_check);
#endif
#endif
#ifdef MEMTRACE_TO_FILE
trace_file = fopen("memtrace.dump","w");
#endif
#ifdef MEMTRACE_CPP
_new_handler = NULL;
delete_called = FALSE;
delete_call = pack(0,NULL,0,NULL);
#endif
}
}
END_NAMESPACE
#endif
Alakzatlab2/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.
singleton: 2019.
*********************************/
#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:
atexit_class() {
#if defined(CPORTA) && !defined(CPORTA_NOSETBUF)
setbuf(stdout, 0);
setbuf(stderr, 0);
#endif
}
public:
static atexit_class& get_atexit_obj() {
static atexit_class instance; // singleton példány
return instance;
}
int check() {
return mem_check();
}
~atexit_class() {
check();
}
};
/// A statikus referencia minden fordítási egységben keletkezik, de
/// mindegyik egyetlen példányra fog hivatkozni a singleton minta miatt
static atexit_class& atexit_obj = atexit_class::get_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>
#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 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*/
#endif /*MEMCHECK*/
#endif /*MEMTRACE_H*/
Alakzatlab2/poligon.cpp 0 → 100644
/**
* \file kor.cpp
* Poligon osztály tagfüggvényinek megvalósítása
*/
#include <stdexcept>
#include "poligon.h"
Pont Poligon::getcsp(size_t i) const {
if (i >= np) throw std::out_of_range("Poligon: nincs ilyen csucspont!");
if (i == 0) return p0;
return pontok[i-1] + p0; // p0-hoz képest relatívan tárolunk
}
void Poligon::add(const Pont& p) {
Pont *tp = new Pont[np];
for (size_t i = 0; i < np-1; i++)
tp[i] = pontok[i];
delete[] pontok;
pontok = tp;
pontok[np-1] = p - p0; // kezdőponthoz képest relatívan tárolunk
++np;
}
void Poligon::rajzol() {
std::cout << "Rajzol: " << *this << std::endl;
}
std::ostream& operator<<(std::ostream& os, const Poligon& k) {
os << "Poligon " << (Alakzat&)k << ",csp=" << k.getnp();
for (size_t i = 1; i < k.getnp(); ++i)
os << ",p" << i << "=" << k.getcsp(i);
return os;
}
Alakzatlab2/poligon.h 0 → 100644
/**
* \file poligon.h
* Poligon osztály deklarációja
*/
#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
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) :Alakzat(p0, sz), np(1)
{ pontok = new Pont[np-1]; } // eggyel kevesebbet foglal, mert a p0 az alaposztályban van
/// Csúcspontok darabszámának lekérdezése
/// @return darab
size_t getnp() 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 csúcspont koordinátai
Pont getcsp(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();
~Poligon() { delete[] pontok; }
};
/// Globális << operátor
std::ostream& operator<<(std::ostream&, const Poligon&);
#endif // POLIGON_H
Alakzatlab2/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(x-rhs_p.x, y-rhs_p.y);
}
/// + operator
Pont Pont::operator+(const Pont& rhs_p) const {
return Pont(x+rhs_p.x, y+rhs_p.y);
}
/// Globális << operátor
std::ostream& operator<<(std::ostream& os, const Pont& p) {
return os << "(" << p.x <<"," << p.y << ")";
}
Alakzatlab2/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, meg setter.
/// Csak azok az operatorok lettek megvalósítva, melyeket használ a demó
struct Pont {
int x; ///< x koordináta
int y; ///< y koordináta
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;
/// @return megvá pont
/// - operator
/// @param rhs_p - jobb oldali operandus (Pont)
/// @return új új objektum (Pont) a két pont különbsége
Pont operator-(const Pont& rhs_p) const;
};
/// Globális <<< operátor
/// @param os - ostream
/// @param p - pont
std::ostream& operator<<(std::ostream& os, const Pont& p);
#endif // PONT_H
Alakzatlab2/rajztabla.cpp 0 → 100644
/**
* \file rajztabla.cpp
* Rajztábla osztály tagfüggvényinek megvalósítása
*/
#include <stdexcept>
#include "rajztabla.h"
#error "itt valositsa meg a Rajztabla osztály tagfuggvenyeit!"
Alakzatlab2/rajztabla.h 0 → 100644
/**
* \file rajztabla.h
* Rajztabla osztály deklarációja
*/
#ifndef RAJZTABLA_H
#define RAJZTABLA_H
#include "alakzat.h"
#error "Itt deklaralja a Rajztabla osztalyt!"
#endif // RAJZTABLA_H
Alakzatlab2/szakasz.cpp 0 → 100644
/**
* \file szakasz.cpp
* Szakasz osztály tagfüggvényinek megvalósítása
*/
#include "szakasz.h"
/// Szakaszt rajzoló rajzol fv.
void Szakasz::rajzol() {
std::cout << "Rajzol: " << *this << std::endl;
}
/// Globális << operátor
std::ostream& operator<<(std::ostream& os, const Szakasz& sz) {
return os << "Szakasz " << (Alakzat&)sz << ",pv=" << sz.getpv();
}
Alakzatlab2/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
class Szakasz : public Alakzat {
Pont pv; ///< szakasz végpontja az origóhoz (p0-hoz) képest
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 hosszból
/// @param p0 - kezdőpont
/// @param xl - x irányú hossz
/// @param yl - y irányú hossz
/// @param sz - szín és átlátszóság
Szakasz(const Pont& p0, int xl, int yl, Szin sz)
: Alakzat(p0, sz), pv(Pont(xl, yl)) { }
/// Szakasz végpontjának lekérdezése
/// @return szakasz végpontja
Pont getpv() const { return pv+p0; } // p0-hoz lépest relatívan tárolunk
/// szakaszt rajzol
void rajzol(); // átdefiniáljuk a virt. fv-t.
};
/// Globális << operátor
std::ostream& operator<<(std::ostream& os, const Szakasz& k);
#endif // SZAKASZ_H
Alakzatlab2/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
/// Nincs ellenőrzés a túlindexelésre !
std::ostream& operator<<(std::ostream& os, Szin sz) {
return os << szinek[sz];
}
Alakzatlab2/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
std::ostream& operator<<(std::ostream& os, Szin sz);
#endif // SZIN_H
Alakzatlab2/teglalap.cpp 0 → 100644
/**
* \file teglalap.cpp
* Teglalap osztály tagfüggvényinek megvalósítása
*/
#include "teglalap.h"
/// Téglalapot rajzoló rajzol fv.
void Teglalap::rajzol() {
std::cout << "Rajzol: " << *this << std::endl;
}
/// Globális << operátor
std::ostream& operator<<(std::ostream& os, const Teglalap& t) {
return os << "Teglalap " << (Alakzat&)t << ",p1=" << t.getp1();
}
Alakzatlab2/teglalap.h 0 → 100644
/**
* \file teglalap.h
* Téglalap osztály deklarációja
*/
#ifndef TEGLALAP_H
#define TEGLALAP_H
#include "alakzat.h"
/// Teglalap osztály
/// Tengelyekkel párhuzamos oldalú téglalap
class Teglalap : public Alakzat {
Pont p1; ///< szemben levő csúcspont
public:
/// Konstruktor
/// @param p0 - kezdőpont
/// @param p1 - szemközti csúcspont
/// @param sz - szín és átlátszóság
Teglalap(const Pont& p0, const Pont& p1, Szin sz)
:Alakzat(p0, sz), p1(p1-p0) // ös ossztály inic
{}
/// Másik csúcspont lekérdezése
/// @return másik csúcspont
Pont getp1() const { return p1+p0; } // p0-hoz képest relatívan tárolunk
/// téglalapot rajzol
void rajzol();
};
/// Globális << operátor
std::ostream& operator<<(std::ostream& os, const Teglalap& t);
#endif // TEGLALAP_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