Skip to content

Prog2 / labor_peldak / lab_06

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

bicikli

parent b021771a
Showing with 556 additions and 762 deletions
Alakzatlab/alakzat.cpp deleted 100644 → 0
/**
* \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
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
std::ostream& operator<<(std::ostream& os, const Alakzat& a) {
return os << "p0=" << a.getp0() << ",szin=" << a.getsz();
}
Alakzatlab/alakzat.h deleted 100644 → 0
/**
* \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
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() = 0;
/// Destruktor virtuális, hogy lehessen dinamikus adattagja
/// a származtatottnak
virtual ~Alakzat() {}
};
/// Globális << operátor
/// @param os - ostream
/// @param a - alakzat
/// @return os - ostream
std::ostream& operator<<(std::ostream& os, const Alakzat& a);
#endif // ALAKZAT_H
Alakzatlab/alakzat.vcproj deleted 100644 → 0
<?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>
Alakzatlab/alakzatlab.uxf deleted 100644 → 0
<?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>
Alakzatlab/kor.cpp deleted 100644 → 0
/**
* \file kor.cpp
* Kor osztly tagfggvnyinek megvalstsa
*/
#include "kor.h"
/// Krt rajzol rajzol fv.
void Kor::rajzol() {
std::cout << "Rajzol: " << *this << std::endl;
}
/// Globlis << opertor
std::ostream& operator<<(std::ostream& os, const Kor& k) {
return os << "Kor " << (Alakzat&)k << ",r=" << k.getr();
}
Alakzatlab/kor.h deleted 100644 → 0
/**
* \file kor.h
* Kor osztály deklarációja
*/
#ifndef KOR_H
#define KOR_H
#include "alakzat.h"
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
/// @param os - ostream
/// @param k - kor
/// @return os - ostream
std::ostream& operator<<(std::ostream& os, const Kor& k);
#endif // KOR_H
Alakzatlab/main.cpp deleted 100644 → 0
/**
* \file main.cpp
* Demo program az alakzat osztályok kipróbálására.
* Felrajzol pár alakzatot, majd elmozgatja kicsit.
*/
#include <iostream>
#include "szakasz.h"
#include "kor.h"
using std::cout;
using std::endl;
int main(int argc, char** argv) {
const int N = 100; // maximum 100 alakzatunk lehet
Alakzat *idom[N];
int db = 0; // most nincs egy se
Szakasz sz1(Pont(20,40), 100, 0, WHITE);
sz1.rajzol();
idom[db++] = &sz1; // nem kell cast, mert kompatibilis
Kor k1(Pont(120,140), 50, BLUE);
k1.rajzol();
idom[db++] = &k1;
cout << "\nMost kirajzoljuk alaposztaly pointerrel:" << endl;
for (int i = 0; i < db; i++) // végigmegyünk az összes alakzaton
idom[i]->rajzol(); // kirajzoljuk
cout << "\nMost mozgatunk (x+100, y+100) (pointerrel):" << endl;
for (int i = 0; i < db; i++) // az összes alakzatra
idom[i]->mozgat(Pont(100, 100)); // kicsit mozdítunk rajta
return 0;
}
Alakzatlab/pont.cpp deleted 100644 → 0
/**
* \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);
}
/// Globális << operátor
std::ostream& operator<<(std::ostream& os, const Pont& p) {
return os << "(" << p.x <<"," << p.y << ")";
}
Alakzatlab/pont.h deleted 100644 → 0
/**
* \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 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;
/// @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
/// @return os - ostream
std::ostream& operator<<(std::ostream& os, const Pont& p);
#endif // PONT_H
Alakzatlab/szakasz.cpp deleted 100644 → 0
/**
* \file szakasz.cpp
* Szakasz osztly tagfggvnyinek megvalstsa
*/
#include "szakasz.h"
/// Szakaszt rajzol rajzol fv.
void Szakasz::rajzol() {
std::cout << "Rajzol: " << *this << std::endl;
}
/// Globlis << opertor
std::ostream& operator<<(std::ostream& os, const Szakasz& sz) {
return os << "Szakasz " << (Alakzat&)sz << ",pv=" << sz.getpv();
}
Alakzatlab/szakasz.h deleted 100644 → 0
/**
* \file szakasz.h
* Szakasz osztály deklarációja
*/
#ifndef SZAKASZ_H
#define SZAKASZ_H
#include "alakzat.h"
/// szakasz
class Szakasz : public Alakzat {
Pont pv; /// szakasz végpontja a 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(getp0()+Pont(xl, yl)) { }
/// Szakasz végpontjénak lekérdezése
/// @return szakasz végpontjaa
Pont getpv() const { return getp0()+pv; }
/// szakaszt rajzol
void rajzol(); // átdefiniáljuk a virt. fv-t.
};
/// Globális << operátor
/// @param os - ostream
/// @param sz - szakasz
/// @return os - ostream
std::ostream& operator<<(std::ostream& os, const Szakasz& sz);
#endif // SZAKASZ_H
Alakzatlab/szin.cpp deleted 100644 → 0
/**
* \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];
}
Alakzatlab/szin.h deleted 100644 → 0
/**
* \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
/// @param os - ostream
/// @param sz - szín
/// @return os - ostream
std::ostream& operator<<(std::ostream& os, Szin sz);
#endif // SZIN_H
Alakzatlab/Makefile → bicikli/Makefile
#
# Makefile pelda a string1 feladat (3. labor) megoldasanak forditasara
# Makefile pelda a bicikli feladat (6. labor) megoldasanak forditasara
# gnumake valtozat
# Linuxokon es ural2-n is elerheto
#
# A make paranccsorabol magadott CMD valtozo tartalma atadodik a forditonak
# Pl:
# make -CMD=-DMEMTRACE
#
PROG = main # a program neve (ezt allitjuk elo)
PROG_O = main.o alakzat.o kor.o szakasz.o szin.o pont.o # program object fajljai
PROG_H = alakzat.h kor.h szakasz.h szin.h pont.h # program header fajljai
PROG = bicikli_teszt # a program neve (ezt allitjuk elo)
PROG_O = bicikli_teszt0.o # program object fajljai
PROG_H = bicikli.h # program header fajljai
PROG_L = # program libjei
MTRACE_O = memtrace.o # memtrace object fajl
MTRACE_H = memtrace.h # memtrace header fajlja
MEMCHK_L = -lmalloc # ural2-n a memcheck-hez kell. linuxon kikommentezendo
CXX = g++ # a C fordito neve
#CXX = clang++ # clang-ot (llvm) is erdemes kiprobalni
CXXFLAGS = -pedantic -Wall # kapcsolok: legyen bobeszedu es pedans
CXXFLAGS += -g # es legyeb debug info is
CXXFLAGS += $(CMD) # es amit a parancsorbol megadnak
CXXFLAGS = -pedantic -Wall -Werror # kapcsolok: legyen bobeszedu es pedans
CXXFLAGS += -g -DMEMTRACE # es debug info is
LDFLAGS = -g # debug a linkelesnel
# osszes object, osszes header osszes lib
OBJS = $(PROG_O) $(MTRACE_O)
HEADS = $(PROG_H) $(MTRACE_H)
LIBS = $(PROG_L) $(MEMCHK_L)
LIBS = $(PROG_L)
# alapertelmezett cel: program
.PHONY: all
......@@ -35,7 +29,7 @@ all: $(PROG)
$(PROG): $(OBJS)
$(CXX) $(LDFLAGS) $(OBJS) -o $@ $(LIBS)
# feltetelezzuk, hogy az osszes obj fugg az osszes headertol, ami nem feltetlenul igaz
# feltetelezzuk, hogy az osszes obj fugg az osszes headertol
$(OBJS): $(HEADS)
# takaritas igeny szerint
......
Alakzatlab/alakzat.cbp → bicikli/bicikli.cbp
......@@ -2,22 +2,23 @@
<CodeBlocks_project_file>
<FileVersion major="1" minor="6" />
<Project>
<Option title="alakzat" />
<Option title="bicikli" />
<Option pch_mode="2" />
<Option compiler="gcc" />
<Build>
<Target title="Debug">
<Option output="bin/Debug/alakzat" prefix_auto="1" extension_auto="1" />
<Option output="bin/Debug/bicikli" prefix_auto="1" extension_auto="1" />
<Option object_output="obj/Debug/" />
<Option type="1" />
<Option compiler="gcc" />
<Compiler>
<Add option="-std=c++11" />
<Add option="-g" />
<Add option="-DMEMTRACE" />
</Compiler>
</Target>
<Target title="Release">
<Option output="bin/Release/alakzat" prefix_auto="1" extension_auto="1" />
<Option output="bin/Release/bicikli" prefix_auto="1" extension_auto="1" />
<Option object_output="obj/Release/" />
<Option type="1" />
<Option compiler="gcc" />
......@@ -30,36 +31,19 @@
</Target>
</Build>
<Compiler>
<Add option="-pedantic" />
<Add option="-Wall" />
<Add option="-Werror" />
<Add option="-fexceptions" />
</Compiler>
<Unit filename="alakzat.cpp" />
<Unit filename="alakzat.h" />
<Unit filename="kor.cpp" />
<Unit filename="kor.h" />
<Unit filename="main.cpp" />
<Unit filename="bicikli.h" />
<Unit filename="bicikli_teszt0.cpp" />
<Unit filename="gtest_lite.h" />
<Unit filename="memtrace.cpp" />
<Unit filename="memtrace.h" />
<Unit filename="pont.cpp" />
<Unit filename="pont.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 />
<debugger />
<lib_finder disable_auto="1" />
</Extensions>
</Project>
</CodeBlocks_project_file>
bicikli/bicikli_teszt0.cpp 0 → 100644
/**
* 6. labor önellenőrző feladat teszt
*
* A jporta nem pontosan ezt a tesztet futtatja, de az elvárt kimenete azonos.
* Ha érdeklik a részletek, nézze meg a Jporta-n a teszt forrását.
*
*/
#include "memtrace.h"
#include "bicikli.h"
struct MyKerek : Kerek {
MyKerek() : Kerek(-1) {
std::cout << "\tMyKerek ctor ";
kiir();
}
~MyKerek() {
std::cout << "\tMyKerek dtor ";
kiir();
}
};
int main() {
Szan sz1(1.1, 7);
Szan sz2 = sz1;
Bicikli b1(10, 16);
Bicikli b2 = b1;
Kerek *k = new MyKerek;
delete k;
Jarmu *j = new Bicikli(0,0);
delete j;
}
bicikli/gtest_lite.h 0 → 100644
#ifndef GTEST_LITE_H
#define GTEST_LITE_H
/**
* \file gtest_lite.h (v3/2019)
*
* Google gtest keretrendszerhez hasonló rendszer.
* Sz.I. 2015., 2016., 2017. (_Has_X)
* Sz.I. 2018 (template), ENDM, ENDMsg, nullptr_t
* Sz.I. 2019 singleton
* Sz.I. 2021 ASSERT.., STRCASE...
* Sz.I. 2021 EXPEXT_REGEXP
*
* A tesztelés legalapvetőbb funkcióit támogató függvények és makrók.
* Nem szálbiztos megvalósítás.
*
*
* Szabadon felhasználható, bővíthető.
*
* Használati példa:
* Teszteljük az f(x)=2*x függvényt:
* int f(int x) { return 2*x; }
*
* int main() {
* TEST(TeszEsetNeve, TesztNeve)
* EXPECT_EQ(0, f(0));
* EXPECT_EQ(4, f(2)) << "A függvény hibás eredményt adott" << std::endl;
* ...
* END
* ...
* // Fatális hiba esetén a teszteset nem fut tovább. Ezek az ASSERT... makrók.
* // Nem lehet a kiírásukhoz további üzenetet fűzni. PL:
* TEST(TeszEsetNeve, TesztNeve)
* ASSERT_NO_THROW(f(0)); // itt nem lehet << "duma"
* EXPECT_EQ(4, f(2)) << "A függvény hibás eredményt adott" << std::endl;
* ...
* END
* ...
*
* A működés részleteinek megértése szorgalmi feladat.
*/
#include <iostream>
#include <cassert>
#include <cmath>
#include <cstring>
#include <limits>
#include <cstdlib>
#include <string>
#include <fstream>
#if __cplusplus >= 201103L
# include <iterator>
# include <regex>
#endif
#ifdef MEMTRACE
# include "memtrace.h"
#endif
// Két makró az egyes tesztek elé és mögé:
// A két makró a kapcsos zárójelekkel egy új blokkot hoz létre, amiben
// a nevek lokálisak, így elkerülhető a névütközés.
/// Teszt kezdete. A makró paraméterezése hasonlít a gtest
/// paraméterezéséhez. Így az itt elkészített testek könnyen átemelhetők
/// a gtest keretrendszerbe.
/// @param C - teszteset neve (csak a gtest kompatibilitás miatt van külön neve az eseteknek)
/// @param N - teszt neve
#define TEST(C, N) do { gtest_lite::test.begin(#C"."#N);
/// Teszteset vége.
#define END gtest_lite::test.end(); } while (false);
/// Teszteset vége allokált blokkok számának összehasonlításával
/// Ez az ellenőrzés nem bomba biztos.
#define ENDM gtest_lite::test.end(true); } while (false);
/// Teszteset vége allokált blokkok számának összehasonlításával
/// Ez az ellenőrzés nem bomba biztos.
/// Ha hiba van kiírja az üzenetet.
#define ENDMsg(t) gtest_lite::test.end(true) << t << std::endl; } while (false);
// Eredmények vizsgálatát segítő makrók.
// A paraméterek és a funkciók a gtest keretrendszerrel megegyeznek.
/// Sikeres teszt makrója
#define SUCCEED() gtest_lite::test.expect(true, __FILE__, __LINE__, "SUCCEED()", true)
/// Sikertelen teszt fatális hiba makrója
#define FAIL() gtest_lite::test.expect(false, __FILE__, __LINE__, "FAIL()", true)
/// Sikertelen teszt makrója
#define ADD_FAILURE() gtest_lite::test.expect(false, __FILE__, __LINE__, "ADD_FAILURE()", true)
/// Azonosságot elváró makró
#define EXPECT_EQ(expected, actual) gtest_lite::EXPECT_(expected, actual, gtest_lite::eq, __FILE__, __LINE__, "EXPECT_EQ(" #expected ", " #actual ")" )
/// Eltérést elváró makró
#define EXPECT_NE(expected, actual) gtest_lite::EXPECT_(expected, actual, gtest_lite::ne, __FILE__, __LINE__, "EXPECT_NE(" #expected ", " #actual ")", "etalon" )
/// Kisebb, vagy egyenlő relációt elváró makró
#define EXPECT_LE(expected, actual) gtest_lite::EXPECT_(expected, actual, gtest_lite::le, __FILE__, __LINE__, "EXPECT_LE(" #expected ", " #actual ")", "etalon" )
/// Kisebb, mint relációt elváró makró
#define EXPECT_LT(expected, actual) gtest_lite::EXPECT_(expected, actual, gtest_lite::lt, __FILE__, __LINE__, "EXPECT_LT(" #expected ", " #actual ")", "etalon" )
/// Nagyobb, vagy egyenlő relációt elváró makró
#define EXPECT_GE(expected, actual) gtest_lite::EXPECT_(expected, actual, gtest_lite::ge, __FILE__, __LINE__, "EXPECT_GE(" #expected ", " #actual ")", "etalon" )
/// Nagyobb, mint relációt elváró makró
#define EXPECT_GT(expected, actual) gtest_lite::EXPECT_(expected, actual, gtest_lite::gt, __FILE__, __LINE__, "EXPECT_GT(" #expected ", " #actual ")", "etalon" )
/// Igaz értéket elváró makró
#define EXPECT_TRUE(actual) gtest_lite::EXPECT_(true, actual, gtest_lite::eq, __FILE__, __LINE__, "EXPECT_TRUE(" #actual ")" )
/// Hamis értéket elváró makró
#define EXPECT_FALSE(actual) gtest_lite::EXPECT_(false, actual, gtest_lite::eq, __FILE__, __LINE__, "EXPECT_FALSE(" #actual ")" )
/// Valós számok azonosságát elváró makró
#define EXPECT_FLOAT_EQ(expected, actual) gtest_lite::EXPECT_(expected, actual, gtest_lite::almostEQ, __FILE__, __LINE__, "EXPECT_FLOAT_EQ(" #expected ", " #actual ")" )
/// Valós számok azonosságát elváró makró
#define EXPECT_DOUBLE_EQ(expected, actual) gtest_lite::EXPECT_(expected, actual, gtest_lite::almostEQ, __FILE__, __LINE__, "EXPECT_DOUBLE_EQ(" #expected ", " #actual ")" )
/// C stringek (const char *) azonosságát tesztelő makró
#define EXPECT_STREQ(expected, actual) gtest_lite::EXPECTSTR(expected, actual, gtest_lite::eqstr, __FILE__, __LINE__, "EXPECT_STREQ(" #expected ", " #actual ")" )
/// C stringek (const char *) eltéréset tesztelő makró
#define EXPECT_STRNE(expected, actual) gtest_lite::EXPECTSTR(expected, actual, gtest_lite::nestr, __FILE__, __LINE__, "EXPECT_STRNE(" #expected ", " #actual ")", "etalon" )
/// C stringek (const char *) azonosságát tesztelő makró (kisbetű/nagybetű azonos)
#define EXPECT_STRCASEEQ(expected, actual) gtest_lite::EXPECTSTR(expected, actual, gtest_lite::eqstrcase, __FILE__, __LINE__, "EXPECT_STRCASEEQ(" #expected ", " #actual ")" )
/// C stringek (const char *) eltéréset tesztelő makró (kisbetű/nagybetű azonos)
#define EXPECT_STRCASENE(expected, actual) gtest_lite::EXPECTSTR(expected, actual, gtest_lite::nestrcase, __FILE__, __LINE__, "EXPECT_STRCASENE(" #expected ", " #actual ")", "etalon" )
/// Kivételt várunk
#define EXPECT_THROW(statement, exception_type) try { gtest_lite::test.tmp = false; statement; } \
catch (exception_type) { gtest_lite::test.tmp = true; } \
catch (...) { } \
EXPECTTHROW(statement, "kivetelt dob.", "nem dobott '"#exception_type"' kivetelt.")
/// Kivételt várunk
#define EXPECT_ANY_THROW(statement) try { gtest_lite::test.tmp = false; statement; } \
catch (...) { gtest_lite::test.tmp = true; } \
EXPECTTHROW(statement, "kivetelt dob.", "nem dobott kivetelt.")
/// Nem várunk kivételt
#define EXPECT_NO_THROW(statement) try { gtest_lite::test.tmp = true; statement; } \
catch (...) { gtest_lite::test.tmp = false; }\
EXPECTTHROW(statement, "nem dob kivetelt.", "kivetelt dobott.")
/// Nem várunk kivételt
#define ASSERT_NO_THROW(statement) try { gtest_lite::test.tmp = true; statement; } \
catch (...) { gtest_lite::test.tmp = false; }\
ASSERTTHROW(statement, "nem dob kivetelt.", "kivetelt dobott.")
/// Kivételt várunk és továbbdobjuk -- ilyen nincs a gtest-ben
#define EXPECT_THROW_THROW(statement, exception_type) try { gtest_lite::test.tmp = false; statement; } \
catch (exception_type) { gtest_lite::test.tmp = true; throw; } \
EXPECTTHROW(statement, "kivetelt dob.", "nem dobott '"#exception_type"' kivetelt.")
/// Környezeti változóhoz hasonlít -- ilyen nincs a gtest-ben
#define EXPECT_ENVEQ(expected, actual) gtest_lite::EXPECTSTR(std::getenv(expected), actual, gtest_lite::eqstr, __FILE__, __LINE__, "EXPECT_ENVEQ(" #expected ", " #actual ")" )
/// Környezeti változóhoz hasonlít -- ilyen nincs a gtest-ben (kisbetű/nagybetű azonos)
#define EXPECT_ENVCASEEQ(expected, actual) gtest_lite::EXPECTSTR(std::getenv(expected), actual, gtest_lite::eqstrcase, __FILE__, __LINE__, "EXPECT_ENVCASEEQ(" #expected ", " #actual ")" )
#if __cplusplus >= 201103L
/// Reguláris kifejezés illesztése
# define EXPECT_REGEXP(expected, actual, match, err) gtest_lite::EXPECTREGEXP(expected, actual, match, err, __FILE__, __LINE__, "EXPECT_REGEXP(" #expected ", " #actual ", " #match ")" )
#endif
////--------------------------------------------------------------------------------------------
/// ASSERT típusú ellenőrzések. CSak 1-2 van megvalósítva. Nem ostream& -val térnek vissza !!!
/// Kivételt várunk
/// Azonosságot elváró makró
#define ASSERT_EQ(expected, actual) gtest_lite::ASSERT_(expected, actual, gtest_lite::eq, "ASSER_EQ")
/// Nem várunk kivételt
#define ASSERT_NO_THROW(statement) try { gtest_lite::test.tmp = true; statement; } \
catch (...) { gtest_lite::test.tmp = false; }\
ASSERTTHROW(statement, "nem dob kivetelt.", "kivetelt dobott.")
/// Segédmakró egy adattag, vagy tagfüggvény létezésének tesztelésére futási időben
/// Ötlet:
/// https://cpptalk.wordpress.com/2009/09/12/substitution-failure-is-not-an-error-2
/// Használat:
/// CREATE_Has_(size)
/// ... if (Has_size<std::string>::member)...
#define CREATE_Has_(X) \
template<typename T> struct _Has_##X { \
struct Fallback { int X; }; \
struct Derived : T, Fallback {}; \
template<typename C, C> struct ChT; \
template<typename D> static char (&f(ChT<int Fallback::*, &D::X>*))[1]; \
template<typename D> static char (&f(...))[2]; \
static bool const member = sizeof(f<Derived>(0)) == 2; \
};
/// Segédfüggvény egy publikus adattag, vagy tagfüggvény létezésének tesztelésére
/// fordítási időben
inline void hasMember(...) {}
/// Segédsablon típuskonverzió futás közbeni ellenőrzésere
template <typename F, typename T>
struct _Is_Types {
template<typename D> static char (&f(D))[1];
template<typename D> static char (&f(...))[2];
static bool const convertable = sizeof(f<T>(F())) == 1;
};
/// -----------------------------------
/// Belső megvalósításhoz tartozó makrók, és osztályok.
/// Nem célszerű közvetlenül használni, vagy módosítani
/// -----------------------------------
/// EXPECTTHROW: kivételkezelés
#define EXPECTTHROW(statement, exp, act) gtest_lite::test.expect(gtest_lite::test.tmp, __FILE__, __LINE__, #statement) \
<< "** Az utasitas " << (act) \
<< "\n** Azt vartuk, hogy " << (exp) << std::endl
#define ASSERTTHROW(statement, exp, act) gtest_lite::test.expect(gtest_lite::test.tmp, __FILE__, __LINE__, #statement) \
<< "** Az utasitas " << (act) \
<< "\n** Azt vartuk, hogy " << (exp) << std::endl; if (!gtest_lite::test.status) { gtest_lite::test.end(); break; }
#define ASSERT_(expected, actual, fn, op) EXPECT_(expected, actual, fn, __FILE__, __LINE__, #op "(" #expected ", " #actual ")" ); \
if (!gtest_lite::test.status) { gtest_lite::test.end(); break; }
#ifdef CPORTA
#define GTINIT(is) \
int magic; \
is >> magic;
#else
#define GTINIT(IS)
#endif // CPORTA
#ifdef CPORTA
#define GTEND(os) \
os << magic << (gtest_lite::test.fail() ? " NO" : " OK?") << std::endl;
#else
#define GTEND(os)
#endif // CPORTA
/// gtest_lite: a keretrendszer függvényinek és objektumainak névtere
namespace gtest_lite {
/// Tesztek állapotát tároló osztály.
/// Egyetlen egy statikus példány keletkezik, aminek a
/// destruktora a futás végén hívódik meg.
struct Test {
int sum; ///< tesztek számlálója
int failed; ///< hibás tesztek
int ablocks; ///< allokált blokkok száma
bool status; ///< éppen futó teszt státusza
bool tmp; ///< temp a kivételkezeléshez;
std::string name; ///< éppen futó teszt neve
std::fstream null; ///< nyelő, ha nem kell kiírni semmit
static Test& getTest() {
static Test instance;///< egyedüli (singleton) példány
return instance;
}
private: /// singleton minta miatt
Test() :sum(0), failed(0), status(false), null("/dev/null") {}
Test(const Test&);
void operator=(const Test&);
public:
/// Teszt kezdete
void begin(const char *n) {
name = n; status = true;
#ifdef MEMTRACE
ablocks = memtrace::allocated_blocks();
#endif
#ifndef CPORTA
std::cerr << "\n---> " << name << std::endl;
#endif // CPORTA
++sum;
}
/// Teszt vége
std::ostream& end(bool memchk = false) {
#ifdef MEMTRACE
if (memchk && ablocks != memtrace::allocated_blocks()) {
status = false;
return std::cerr << "** Lehet, hogy nem szabaditott fel minden memoriat! **" << std::endl;
}
#endif
#ifdef CPORTA
if (!status)
#endif // CPORTA
std::cerr << (status ? " SIKERES" : "** HIBAS ****") << "\t" << name << " <---" << std::endl;
if (!status)
return std::cerr;
else
return null;
}
bool fail() { return failed; }
bool astatus() { return status; }
/// Eredményt adminisztráló tagfüggvény True a jó eset.
std::ostream& expect(bool st, const char *file, int line, const char *expr, bool pr = false) {
if (!st) {
++failed;
status = false;
}
if (!st || pr) {
std::string str(file);
size_t i = str.rfind("\\");
if (i == std::string::npos) i = str.rfind("/");
if (i == std::string::npos) i = 0; else i++;
return std::cerr << "\n**** " << &file[i] << "(" << line << "): " << expr << " ****" << std::endl;
}
return null;
}
/// Destruktor
~Test() {
#ifdef CPORTA
if (failed)
#endif // CPORTA
std::cerr << "\n==== TESZT VEGE ==== HIBAS/OSSZES: " << failed << "/" << sum << std::endl;
}
};
/// A statikus referencia minden fordítási egységben keletkezik, de
/// mindegyik egyetlen példányra fog hivatkozni a singleton minta miatt
static Test& test = Test::getTest();
/// általános sablon a várt értékhez.
template <typename T1, typename T2>
std::ostream& EXPECT_(T1 exp, T2 act, bool (*pred)(T1, T2), const char *file, int line,
const char *expr, const char *lhs = "elvart", const char *rhs = "aktual") {
return test.expect(pred(exp, act), file, line, expr)
<< "** " << lhs << ": " << std::boolalpha << exp
<< "\n** " << rhs << ": " << std::boolalpha << act << std::endl;
}
/// pointerre specializált sablon a várt értékhez.
template <typename T1, typename T2>
std::ostream& EXPECT_(T1* exp, T2* act, bool (*pred)(T1*, T2*), const char *file, int line,
const char *expr, const char *lhs = "elvart", const char *rhs = "aktual") {
return test.expect(pred(exp, act), file, line, expr)
<< "** " << lhs << ": " << (void*) exp
<< "\n** " << rhs << ": " << (void*) act << std::endl;
}
#if __cplusplus >= 201103L
/// nullptr-re specializált sablon a várt értékhez.
template <typename T1>
std::ostream& EXPECT_(T1* exp, std::nullptr_t act, bool (*pred)(T1*, std::nullptr_t), const char *file, int line,
const char *expr, const char *lhs = "elvart", const char *rhs = "aktual") {
return test.expect(pred(exp, act), file, line, expr)
<< "** " << lhs << ": " << (void*) exp
<< "\n** " << rhs << ": " << (void*) act << std::endl;
}
#endif
/// stringek összehasonlításához.
/// azért nem spec. mert a sima EQ-ra másként kell működnie.
inline
std::ostream& EXPECTSTR(const char *exp, const char *act, bool (*pred)(const char*, const char*), const char *file, int line,
const char *expr, const char *lhs = "elvart", const char *rhs = "aktual") {
return test.expect(pred(exp, act), file, line, expr)
<< "** " << lhs << ": " << (exp == NULL ? "NULL pointer" : std::string("\"") + exp + std::string("\""))
<< "\n** " << rhs << ": " << (act == NULL ? "NULL pointer" : std::string("\"") + act + std::string("\"")) << std::endl;
}
#if __cplusplus >= 201103L
/// regexp összehasonlításhoz.
template <typename E, typename S>
int count_regexp(E exp, S str) {
std::regex rexp(exp);
auto w_beg = std::sregex_iterator(str.begin(), str.end(), rexp);
auto w_end = std::sregex_iterator();
return std::distance(w_beg, w_end);
}
template <typename E, typename S>
std::ostream& EXPECTREGEXP(E exp, S str, int match, const char *err, const char *file, int line,
const char *expr, const char *lhs = "regexp", const char *rhs = "string",
const char *m = "elvart/illeszkedik") {
int cnt = count_regexp(exp, str);
if (match < 0) match = cnt;
return test.expect(cnt == match, file, line, expr)
<< "** " << lhs << ": " << std::string("\"") + exp + std::string("\"")
<< "\n** " << rhs << ": " << (err == NULL ? std::string("\"") + str + std::string("\"") : err)
<< "\n** " << m << ": " << match << "/" << cnt << std::endl;
}
#else
#error "EXPEXTREGEXP requires compiler and library support for the ISO C++ 2011 standard."
#endif
/// segéd sablonok a relációkhoz.
/// azért nem STL (algorithm), mert csak a függvény lehet, hogy menjen a deduckció
template <typename T1, typename T2>
bool eq(T1 a, T2 b) { return a == b; }
inline
bool eqstr(const char *a, const char *b) {
if (a != NULL && b != NULL)
return strcmp(a, b) == 0;
return false;
}
inline
bool eqstrcase(const char *a, const char *b) {
if (a != NULL && b != NULL) {
while (toupper(*a) == toupper(*b) && *a != '\0') {
a++;
b++;
}
return *a == *b;
}
return false;
}
template <typename T1, typename T2>
bool ne(T1 a, T2 b) { return a != b; }
inline
bool nestr(const char *a, const char *b) {
if (a != NULL && b != NULL)
return strcmp(a, b) != 0;
return false;
}
template <typename T1, typename T2>
bool le(T1 a, T2 b) { return a <= b; }
template <typename T1, typename T2>
bool lt(T1 a, T2 b) { return a < b; }
template <typename T1, typename T2>
bool ge(T1 a, T2 b) { return a >= b; }
template <typename T1, typename T2>
bool gt(T1 a, T2 b) { return a > b; }
/// Segédsablon valós számok összehasonlításához
/// Nem bombabiztos, de nekünk most jó lesz
/// Elméleti hátér:
/// http://www.cygnus-software.com/papers/comparingfloats/comparingfloats.htm
template <typename T>
bool almostEQ(T a, T b) {
// eps: ha a relatív, vagy abszolút hiba ettől kisebb, akkor elfogadjuk
T eps = 10 * std::numeric_limits<T>::epsilon(); // 10-szer a legkisebb érték
if (a == b) return true;
if (fabs(a - b) < eps)
return true;
double aa = fabs(a);
double ba = fabs(b);
if (aa < ba) {
aa = ba;
ba = fabs(a);
}
return (aa - ba) < aa * eps;
}
} // namespace gtest_lite
#endif // GTEST_LITE_H
Alakzatlab/memtrace.cpp → bicikli/memtrace.cpp
......@@ -7,7 +7,6 @@ VS 2012: Szeberényi Imre, 2015.,
mem_dump: 2016.
meset felszabaditaskor: 2018.
typo: 2019.
singleton: 2019.
*********************************/
/*definialni kell, ha nem paracssorbol allitjuk be (-DMEMTRACE) */
......@@ -488,7 +487,15 @@ void operator delete(void * p) THROW_NOTHING {
void operator delete[](void * p) THROW_NOTHING {
memtrace::traced_delete(p,FDELETEARR);
}
#if __cplusplus >= 201402L
void operator delete(void * p, size_t) THROW_NOTHING {
memtrace::traced_delete(p,FDELETE);
}
void operator delete[](void * p, size_t) THROW_NOTHING {
memtrace::traced_delete(p,FDELETEARR);
}
#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 {
......@@ -530,5 +537,9 @@ START_NAMESPACE
}
}
#if defined(MEMTRACE_TO_MEMORY) && defined(USE_ATEXIT_OBJECT)
int atexit_class::counter = 0;
int atexit_class::err = 0;
#endif
END_NAMESPACE
#endif
Alakzatlab/memtrace.h → bicikli/memtrace.h
......@@ -5,8 +5,7 @@ Keszitette: Peregi Tamas, BME IIT, 2011
Kanari: Szeberenyi Imre, 2013.,
VS 2012: Szeberényi Imre, 2015.,
mem_dump: 2016.
inclue-ok: 2017., 2018. 2019.
singleton: 2019.
inclue-ok: 2017., 2018., 2019., 2021.
*********************************/
#ifndef MEMTRACE_H
......@@ -111,20 +110,23 @@ END_NAMESPACE
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
}
public:
static atexit_class& get_atexit_obj() {
static atexit_class instance; // singleton példány
return instance;
#endif
counter++;
}
int check() {
return mem_check();
if(--counter == 0)
err = mem_check();
return err;
}
~atexit_class() {
......@@ -132,9 +134,7 @@ START_NAMESPACE
}
};
/// 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();
static atexit_class atexit_obj;
END_NAMESPACE
#endif/*MEMTRACE_TO_MEMORY && USE_ATEXIT_OBJECT*/
......@@ -153,6 +153,13 @@ END_NAMESPACE
#include <map>
#include <algorithm>
#include <functional>
#include <memory>
#include <iomanip>
#include <locale>
#include <typeinfo>
#include <ostream>
#include <stdexcept>
#include <ctime>
#endif
#ifdef MEMTRACE_CPP
namespace std {
......@@ -178,7 +185,7 @@ START_NAMESPACE
#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);
void mem_dump(void const *mem, size_t size, FILE* fp = stdout);
END_NAMESPACE
......@@ -200,6 +207,12 @@ 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;
......@@ -215,5 +228,8 @@ void operator delete[](void *p, int, const char *) THROW_NOTHING;
#endif /*MEMTRACE_CPP*/
#endif /*FROM_MEMTRACE_CPP*/
#endif /*MEMCHECK*/
#else
#pragma message ( "MEMTRACE NOT DEFINED" )
#endif /*MEMTRACE*/
#endif /*MEMTRACE_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