Skip to content

Prog2 / eloadas_peldak / ea_08

Go to a project
Commit 6fe6dcb6 by Szeberényi Imre
Options

v0

parents
Showing with 2589 additions and 0 deletions
SharksAndFishes/Makefile 0 → 100644
#
# Makefile
#
PROG = sharks
OBJ = main.o koord.o obj.o halak.o ocean.o
HEAD = koord.h obj.h halak.h ocean.h
CXXFLAGS = -g -Wall -pedantic
all: $(PROG)
sharks: $(OBJ)
$(CXX) $(CXXFLAGS) -o $(PROG) $(OBJ)
$(OBJ): $(HEAD)
clean:
rm -f $(PROG) $(OBJ)
tar:
tar -czf $(PROG).tgz $(SRC) $(HEAD) $(TEST) $(DATA)
doc:
doxygen Doxyfile
SharksAndFishes/SharksAndFishes.cbp 0 → 100644
<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
<CodeBlocks_project_file>
<FileVersion major="1" minor="6" />
<Project>
<Option title="SharksAndFishes" />
<Option pch_mode="2" />
<Option compiler="gcc" />
<Build>
<Target title="Debug">
<Option output="bin/Debug/SharksAndFishes" 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/SharksAndFishes" 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" />
</Compiler>
<Unit filename="halak.cpp" />
<Unit filename="halak.h" />
<Unit filename="koord.cpp" />
<Unit filename="koord.h" />
<Unit filename="main.cpp" />
<Unit filename="memtrace.cpp" />
<Unit filename="memtrace.h" />
<Unit filename="obj.cpp" />
<Unit filename="obj.h" />
<Unit filename="ocean.cpp" />
<Unit filename="ocean.h" />
<Extensions>
<code_completion />
<envvars />
<debugger />
</Extensions>
</Project>
</CodeBlocks_project_file>
SharksAndFishes/SharksAndFishes.vcproj 0 → 100644
<?xml version="1.0" encoding="windows-1250"?>
<VisualStudioProject
ProjectType="Visual C++"
Version="9,00"
Name="SharksAndFishes"
ProjectGUID="{FABBC104-5CF2-4641-A112-F8291F620C50}"
Keyword="Win32Proj"
TargetFrameworkVersion="131072"
>
<Platforms>
<Platform
Name="Win32"
/>
</Platforms>
<ToolFiles>
</ToolFiles>
<Configurations>
<Configuration
Name="Debug|Win32"
OutputDirectory="Debug"
IntermediateDirectory="Debug"
ConfigurationType="1"
InheritedPropertySheets="$(VCInstallDir)VCProjectDefaults\UpgradeFromVC71.vsprops"
CharacterSet="2"
>
<Tool
Name="VCPreBuildEventTool"
/>
<Tool
Name="VCCustomBuildTool"
/>
<Tool
Name="VCXMLDataGeneratorTool"
/>
<Tool
Name="VCWebServiceProxyGeneratorTool"
/>
<Tool
Name="VCMIDLTool"
/>
<Tool
Name="VCCLCompilerTool"
Optimization="0"
PreprocessorDefinitions="WIN32;_DEBUG;_CONSOLE"
MinimalRebuild="true"
BasicRuntimeChecks="3"
RuntimeLibrary="1"
UsePrecompiledHeader="0"
WarningLevel="3"
Detect64BitPortabilityProblems="false"
DebugInformationFormat="4"
/>
<Tool
Name="VCManagedResourceCompilerTool"
/>
<Tool
Name="VCResourceCompilerTool"
/>
<Tool
Name="VCPreLinkEventTool"
/>
<Tool
Name="VCLinkerTool"
OutputFile="$(OutDir)/SharksAndFishes.exe"
LinkIncremental="2"
GenerateDebugInformation="true"
ProgramDatabaseFile="$(OutDir)/SharksAndFishes.pdb"
SubSystem="1"
RandomizedBaseAddress="1"
DataExecutionPrevention="0"
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="Release"
IntermediateDirectory="Release"
ConfigurationType="1"
InheritedPropertySheets="$(VCInstallDir)VCProjectDefaults\UpgradeFromVC71.vsprops"
CharacterSet="2"
>
<Tool
Name="VCPreBuildEventTool"
/>
<Tool
Name="VCCustomBuildTool"
/>
<Tool
Name="VCXMLDataGeneratorTool"
/>
<Tool
Name="VCWebServiceProxyGeneratorTool"
/>
<Tool
Name="VCMIDLTool"
/>
<Tool
Name="VCCLCompilerTool"
PreprocessorDefinitions="WIN32;NDEBUG;_CONSOLE"
RuntimeLibrary="0"
UsePrecompiledHeader="0"
WarningLevel="3"
Detect64BitPortabilityProblems="true"
DebugInformationFormat="3"
/>
<Tool
Name="VCManagedResourceCompilerTool"
/>
<Tool
Name="VCResourceCompilerTool"
/>
<Tool
Name="VCPreLinkEventTool"
/>
<Tool
Name="VCLinkerTool"
OutputFile="$(OutDir)/SharksAndFishes.exe"
LinkIncremental="1"
GenerateDebugInformation="true"
SubSystem="1"
OptimizeReferences="2"
EnableCOMDATFolding="2"
RandomizedBaseAddress="1"
DataExecutionPrevention="0"
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;cxx;def;odl;idl;hpj;bat;asm;asmx"
UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}"
>
<File
RelativePath=".\halak.cpp"
>
</File>
<File
RelativePath=".\koord.cpp"
>
</File>
<File
RelativePath=".\main.cpp"
>
</File>
<File
RelativePath=".\obj.cpp"
>
</File>
<File
RelativePath=".\ocean.cpp"
>
</File>
</Filter>
<Filter
Name="Header Files"
Filter="h;hpp;hxx;hm;inl;inc;xsd"
UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}"
>
<File
RelativePath=".\halak.h"
>
</File>
<File
RelativePath=".\koord.h"
>
</File>
<File
RelativePath=".\memcheck.h"
>
</File>
<File
RelativePath=".\obj.h"
>
</File>
<File
RelativePath=".\ocean.h"
>
</File>
</Filter>
<Filter
Name="Resource Files"
Filter="rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx"
UniqueIdentifier="{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}"
>
</Filter>
</Files>
<Globals>
</Globals>
</VisualStudioProject>
SharksAndFishes/SharksAndFishes.vcxproj 0 → 100644
<?xml version="1.0" encoding="utf-8"?>
<Project DefaultTargets="Build" ToolsVersion="12.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>{FABBC104-5CF2-4641-A112-F8291F620C50}</ProjectGuid>
<Keyword>Win32Proj</Keyword>
</PropertyGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
<ConfigurationType>Application</ConfigurationType>
<PlatformToolset>v120</PlatformToolset>
<CharacterSet>MultiByte</CharacterSet>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
<ConfigurationType>Application</ConfigurationType>
<PlatformToolset>v120</PlatformToolset>
<CharacterSet>MultiByte</CharacterSet>
</PropertyGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
<ImportGroup Label="ExtensionSettings">
</ImportGroup>
<ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="PropertySheets">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
<Import Project="$(VCTargetsPath)Microsoft.CPP.UpgradeFromVC71.props" />
</ImportGroup>
<ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="PropertySheets">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
<Import Project="$(VCTargetsPath)Microsoft.CPP.UpgradeFromVC71.props" />
</ImportGroup>
<PropertyGroup Label="UserMacros" />
<PropertyGroup>
<_ProjectFileVersion>12.0.30501.0</_ProjectFileVersion>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
<OutDir>Debug\</OutDir>
<IntDir>Debug\</IntDir>
<LinkIncremental>true</LinkIncremental>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
<OutDir>Release\</OutDir>
<IntDir>Release\</IntDir>
<LinkIncremental>false</LinkIncremental>
</PropertyGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
<ClCompile>
<Optimization>Disabled</Optimization>
<PreprocessorDefinitions>WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<MinimalRebuild>true</MinimalRebuild>
<BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
<RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
<PrecompiledHeader />
<WarningLevel>Level3</WarningLevel>
<DebugInformationFormat>EditAndContinue</DebugInformationFormat>
</ClCompile>
<Link>
<OutputFile>$(OutDir)SharksAndFishes.exe</OutputFile>
<GenerateDebugInformation>true</GenerateDebugInformation>
<ProgramDatabaseFile>$(OutDir)SharksAndFishes.pdb</ProgramDatabaseFile>
<SubSystem>Console</SubSystem>
<RandomizedBaseAddress>false</RandomizedBaseAddress>
<DataExecutionPrevention />
<TargetMachine>MachineX86</TargetMachine>
</Link>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
<ClCompile>
<PreprocessorDefinitions>WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<RuntimeLibrary>MultiThreaded</RuntimeLibrary>
<PrecompiledHeader />
<WarningLevel>Level3</WarningLevel>
<DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
</ClCompile>
<Link>
<OutputFile>$(OutDir)SharksAndFishes.exe</OutputFile>
<GenerateDebugInformation>true</GenerateDebugInformation>
<SubSystem>Console</SubSystem>
<OptimizeReferences>true</OptimizeReferences>
<EnableCOMDATFolding>true</EnableCOMDATFolding>
<RandomizedBaseAddress>false</RandomizedBaseAddress>
<DataExecutionPrevention />
<TargetMachine>MachineX86</TargetMachine>
</Link>
</ItemDefinitionGroup>
<ItemGroup>
<ClCompile Include="halak.cpp" />
<ClCompile Include="koord.cpp" />
<ClCompile Include="main.cpp" />
<ClCompile Include="obj.cpp" />
<ClCompile Include="ocean.cpp" />
</ItemGroup>
<ItemGroup>
<ClInclude Include="halak.h" />
<ClInclude Include="koord.h" />
<ClInclude Include="memcheck.h" />
<ClInclude Include="obj.h" />
<ClInclude Include="ocean.h" />
</ItemGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
<ImportGroup Label="ExtensionTargets">
</ImportGroup>
</Project>
\ No newline at end of file
SharksAndFishes/SharksAndFishes.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;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</Extensions>
</Filter>
</ItemGroup>
<ItemGroup>
<ClCompile Include="halak.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="koord.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="main.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="obj.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="ocean.cpp">
<Filter>Source Files</Filter>
</ClCompile>
</ItemGroup>
<ItemGroup>
<ClInclude Include="halak.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="koord.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="memcheck.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="obj.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="ocean.h">
<Filter>Header Files</Filter>
</ClInclude>
</ItemGroup>
</Project>
\ No newline at end of file
SharksAndFishes/doxygen/Doxyfile 0 → 100644
This source diff could not be displayed because it is too large. You can view the blob instead.
SharksAndFishes/doxygen/rtf/a00576.md5 0 → 100644
71da3492b7a4846dc5f83065494fc9ea
\ No newline at end of file
SharksAndFishes/doxygen/rtf/a00580.md5 0 → 100644
7ab915db639e3d749491734b65ca68b2
\ No newline at end of file
SharksAndFishes/doxygen/rtf/a00584.md5 0 → 100644
c33cbe769ebeb3d19d9a4b6ff518b2bd
\ No newline at end of file
SharksAndFishes/doxygen/rtf/a00588.md5 0 → 100644
7f0135eb30a4e6396c84362e9dc68da7
\ No newline at end of file
SharksAndFishes/doxygen/rtf/a00596.md5 0 → 100644
4b348fb81c4b86cb27f2780847019702
\ No newline at end of file
SharksAndFishes/doxygen/rtf/refman.rtf 0 → 100644
This source diff could not be displayed because it is too large. You can view the blob instead.
SharksAndFishes/halak.cpp 0 → 100644
/**
* \file: halak.cpp
*
* Obj leszrmazottainak megvalstsa
*
*/
#include "halak.h"
/// Hal viselkedse
void Hal::lep(const Koord& pos, Ocean& oc, int it) {
if (iter >= it) return;
iter = it;
kor++;
Koord ujPos = keres(pos, oc);
if (oc.ervenyes(ujPos)) {
oc.replObj(ujPos, this); // j cellba szik
Obj* o;
if (kor > halSzapKor)
o = new Hal(*this);
else
o = new Viz;
oc.setObj(pos, o);
}
}
/// Cpa viselkedse
void Capa::lep(const Koord& pos, Ocean& oc, int it) {
if (iter >= it) return; // mr lptetk
iter = it;
kor++; // regszik
if (nemEvett++ >= capaEhenhal) {
ittaveg = true; // hen halt
nev = 'd';
return;
}
Koord ujPos = keres(pos, oc);
if (oc.ervenyes(ujPos)) {
if (oc.getObj(ujPos)->getmeret() > 0)
nemEvett = 0; // fincsi volt a kaja
oc.replObj(ujPos, this); // j cellba uszik
Obj* o;
if (kor > capaSzapKor)
o = new Capa(*this); // szaporodik
else
o = new Viz;
oc.setObj(pos, o);
}
}
SharksAndFishes/halak.h 0 → 100644
#ifndef HALAK_H
#define HALAK_H
/**
* \file: halak.h
*
* Obj leszrmazottai
*
*/
#include "obj.h"
class Ocean;
/// Vz
class Viz :public Obj {
public:
Viz() :Obj('.') {}
};
/// Part vagy sziget
class Part :public Obj {
public:
Part() :Obj('#', 10000) {}
};
/// Hal
class Hal :public Obj {
static const int halSzapKor = 1; // halak szaporodsi kora
int kor; // kora
public:
/// 0-ra lltja a kort
Hal() :Obj('H', 10), kor(0){}
/// Msol - a kor kivtelvel mindent lemsol
Hal(const Hal& h) :Obj(h), kor(0) {}
/// Viselkedst megvalst fggvny
/// @param pos - pozci
/// @param oc - cen
/// @param it - itercis lpsszm
void lep(const Koord& pos, Ocean& oc, int it);
};
/// Cpa
class Capa :public Obj {
static const int capaSzapKor = 5; // cpk szaporodsi kora
static const int capaEhenhal = 7; // cpa hallnak kora
int kor; /// kora
int nemEvett; /// ennyi ideje nem evett
public:
/// 0-ra lltja a kort
Capa() :Obj('C', 100), kor(0), nemEvett(0) {}
/// Msol - a kor kivtelvel mindent lemsol
Capa(const Capa& h) :Obj(h), kor(0), nemEvett(h.nemEvett) {}
/// Viselkedst megvalst fggvny
/// @param pos - pozci
/// @param oc - cen
/// @param it - itercis lpsszm
void lep(const Koord& pos, Ocean& oc, int it);
};
#endif
SharksAndFishes/koord.cpp 0 → 100644
/**
* \file: koord.cpp
*
* Koord segédobjektum megvalósítása
*
*/
#include "koord.h"
/// Adott iránynak megfelelően lépve új pozíciót ad
/// @param ir - irány
/// @return új pozició
Koord Koord::lep(Irany ir) const {
switch(ir) {
case fel:
return Koord(i-1,j);
break;
case le:
return Koord(i+1,j);
break;
case balra:
return Koord(i,j-1);
break;
case jobbra:
return Koord(i,j+1);
break;
}
return *this;
}
SharksAndFishes/koord.h 0 → 100644
#ifndef KOORD_H
#define KOORD_H
/**
* \file: koord.h
*
* Koord segédobjektum
*
*/
/// Cellarács koordinátáinak kezeléséhez
/// Koord osztály minden része publikus.
struct Koord {
public:
enum Irany { fel, jobbra, le, balra }; /// típus az eltoláshoz
int i; /// sor
int j; /// oszlop
/// Konstruktor:
/// @param i - sor index
/// @param j - oszlop index
Koord(int i, int j) :i(i), j(j) {}
/// Összehasonlítás
/// @param k - jobb oldali operandus
/// @return true - ha mindkét koordináta azonos
bool operator==(const Koord& k) const {
return i == k.i && j == k.j;
}
/// Adott iránynak megfelelően lépve új pozíciót ad
/// @param ir - irány
/// @return új pozíció
Koord lep(Irany ir) const;
};
#endif
SharksAndFishes/main.cpp 0 → 100644
/**
* \file: main.cpp
*
* Főprogram az óceánmodell teszteléséhez.
*
*/
#include <iostream>
#include "ocean.h"
#include "halak.h"
using namespace std;
/// Összegző sablon.
/// Iterátor alapján bejárja a tárolót és
/// megszámolja, hogy hány olyan van, ami megfelel a
/// predikátumnak
template<class Iter, class Pred>
int szamol(Iter elso, Iter utso, Pred pred) {
int db = 0;
while (elso != utso)
if (pred(*elso++)) db++;
return db;
}
/// Halneveket összehasonlító fv.objektum
struct HalnevCmp {
char refnev; // referencia név
/// Konstruktor letárolja a referencia karaktert
/// @param nev - referencianév
HalnevCmp(char nev) :refnev(nev) {}
/// Referencia összehasonlítása
/// @param o - Obj objektum
/// @return - true, ha az objektum neve megegyezik a referencianévvel
bool operator()(const Obj* o) const {
return o->getnev() == refnev;
}
};
int main() {
Ocean atlanti;
atlanti.replObj(Koord(0,0), new Hal); // első hal
atlanti.replObj(Koord(5,10), new Hal); // újabb
atlanti.replObj(Koord(MaxN-1, MaxM-1), new Hal);
atlanti.replObj(Koord(2,5), new Capa); // cápa
char cont = 'N';
for (int i = 0; i < 52; i++) {
atlanti.rajzol(cout);
// A szamol template argumentumai levezethetők igy nem kell kírni
std::cout << "(Hal:" << szamol(atlanti.begin(), atlanti.end(), HalnevCmp('H'));
// de ki is írhatnánk...
std::cout << ", Capa:" << szamol<Ocean::Iterator, HalnevCmp>(atlanti.begin(), atlanti.end(),
HalnevCmp('C')) << ")" << endl;
if (cont != 'I') {
std::cin >> noskipws >> cont;
}
atlanti.lep();
}
}
SharksAndFishes/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.
*********************************/
/*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
}
}
#if defined(MEMTRACE_TO_MEMORY) && defined(USE_ATEXIT_OBJECT)
int atexit_class::counter = 0;
int atexit_class::err = 0;
#endif
END_NAMESPACE
#endif
SharksAndFishes/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.
*********************************/
#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>
#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*/
SharksAndFishes/obj.cpp 0 → 100644
/**
* \file: obj.cpp
*
* Obj objektum és leszármazottainak megvalósítása
*
*/
#include "obj.h"
/// Kisebb/nagyobb hal vagy víz keresése. Először halat keres.
/// @param pos - kezdő pozíció
/// @param oc - óceán
/// @param cmp - predikátum a méret összehasonlításához
/// @return - megtalált pozício - ha nincs, érvénytelen
Koord Obj::keres(const Koord& pos, Ocean& oc, cmpf_t cmp) const {
const Koord noPos(-1,-1); // nemlétező pozíció
Koord talalt = noPos; // nem talált semmit
for (int i = 0; i < 4; i++) { // kihasználjuk az enum tulajdonságát
Koord ujPos = pos.lep(Koord::Irany(i));
if (oc.ervenyes(ujPos)) {
int m = oc.getObj(ujPos)->getmeret();
if (m == 0) {
if (talalt == noPos) talalt = ujPos; // megjegyzi a víz helyét
} else if (cmp(m, meret)) { // perdikátum alapján dönt
return ujPos;
}
}
}
return talalt;
}
SharksAndFishes/obj.h 0 → 100644
#ifndef OBJ_H
#define OBJ_H
/**
* \file: obj.h
*
* Obj Alapobjektum.
*
*/
#include "memtrace.h"
#include "koord.h"
#include "ocean.h"
class Ocean; /// Elődeklaráció. A körkörös hivatkozás miatt kell
/// összehasonlító függvény típusa
typedef bool cmpf_t(int, int);
/// alapértelmezés szerint kisebbet (gyengébbet) keres
inline bool kisebb(int a, int b) { return a < b; }
/// Õs objektum.
class Obj {
protected:
char nev; /// Objektum neve
int meret; /// nagyobb megeszi a kisebbet
int iter; /// Iteráció számlálója
bool ittaveg; /// megszűnést jelző flag
public:
/// Konstruktor:
/// @param nev - név 1 char
/// @param meret - hal mérete (ereje)
Obj(char nev, int meret = 0)
:nev(nev), meret(meret), iter(0), ittaveg(false) {}
/// Név lekérdezése
/// @return - nev
char getnev() const { return nev; }
/// Méret lekérdezése
/// @return - meret
char getmeret() const { return meret; }
/// ittaveg flag - ha az objektumot meg kell semmisíteni
/// @return - ittaveg
bool is_vege() const { return ittaveg; }
/// Kisebb/nagyobb hal vagy víz keresése. Először halat keres.
/// @param pos - kezdő pozíció
/// @param oc - óceán
/// @param cmp - predikátum a méret összehasonlításához
/// @return - megtalált pozíció - ha nincs, érvénytelen
Koord keres(const Koord& pos, Ocean& oc, cmpf_t cmp = kisebb) const;
/// Viselkedést megvalósító függvény
/// Nem absztrakt, hogy ne kelljen megvalósítani mindenütt
/// @param pos - pozíció
/// @param oc - óceán
/// @param it - iterációs lépésszám
virtual void lep(const Koord& pos, Ocean& oc, int it) {}
/// Destruktor:
/// Virtuális, hogy a leszármazottaknak is meghívódjon
virtual ~Obj() {}
};
#endif
SharksAndFishes/ocean.cpp 0 → 100644
/**
* \file: ocean.cpp
*
* Ocean objektum megvalstsa.
*
*/
#include <stdexcept>
#include "ocean.h"
#include "halak.h"
using namespace std;
/// Minden cellt vzzel "tlt fel"
Ocean::Ocean() :iter(0) {
for (int i = 0; i < MaxN; i++)
for (int j = 0; j < MaxM; j++)
cellak[i][j] = new Viz;
}
/// Megszntet minden trolt objektumot
Ocean::~Ocean() {
for (int i = 0; i < MaxN; i++)
for (int j = 0; j < MaxM; j++)
delete cellak[i][j];
}
/// Cellban trolt pointer lekrdezse.
/// @param pos - cellapozci
/// @return objektum pointere
Obj* Ocean::getObj(Koord pos) const {
return cellak[pos.i][pos.j];
}
/// Cellban trolt pointer bersa.
/// @param pos - cellapozci
/// @param o - j objektum pointere
void Ocean::setObj(Koord pos, Obj* o) {
cellak[pos.i][pos.j] = o;
}
/// Cellban trolt pointer kicsrlse.
/// A rgi objektum felszabadul
/// @param pos - cellapozci
/// @param o - j objektum pointere
void Ocean::replObj(Koord pos, Obj* o) {
delete cellak[pos.i][pos.j];
cellak[pos.i][pos.j] = o;
}
/// Cellarcsok "kirajzolsa"
/// @param os - output steram
void Ocean::rajzol(std::ostream& os) const {
os << iter << "." << std::endl;
for (int i = 0; i < MaxN; i++) {
for (int j = 0; j < MaxM; j++)
os << cellak[i][j]->getnev();
os << std::endl;
}
}
/// Egy itercis lps
void Ocean::lep() {
iter++;
for (int i = 0; i < MaxN; i++)
for (int j = 0; j < MaxM; j++) {
Koord pos(i,j);
cellak[i][j]->lep(pos, *this, iter);
if (cellak[i][j]->is_vege())
replObj(pos, new Viz);
}
}
/// Ocean Iterator Pre inkremens
Ocean::Iterator& Ocean::Iterator::operator++() {
if (p == 0 || p == pe)
throw out_of_range("Iterator++");
p++;
return *this;
}
/// Ocean Iterator Post inkremens
Ocean::Iterator Ocean::Iterator::operator++(int) {
Iterator tmp = *this;
if (p == 0 || p == pe)
throw out_of_range("Iterator++");
p++;
return tmp;
}
/// Ocean Iterator Csillag
Obj* Ocean::Iterator::operator*() {
if (p == 0 || p == pe)
throw out_of_range("Iterator*");
return *p;
}
/// Ocean Iterator Nyil operator
Obj** Ocean::Iterator::operator->() {
if (p == 0 || p == pe)
throw out_of_range("Iterator->");
return p;
}
SharksAndFishes/ocean.h 0 → 100644
/**
* \file: ocean.h
*
* Ocean objektum deklarációja
*
*
*/
#ifndef OCEAN_H
#define OCEAN_H
#include <iostream>
#include "obj.h"
/// Óceán mérete.
const int MaxN = 10;
const int MaxM = 40;
class Obj; // Elődeklaráció. (A körkörös include miatt kell.)
/// Ocean objektum.
/// Statikus méretű cellarácsot tartalmaz.
/// Minden cella egy objektum mutatóját tárolja.
class Ocean {
int iter; /// Iteráció számlálója
Obj *cellak[MaxN][MaxM]; /// Cellák tárolója
public:
class Iterator; // elődeklaráció
/// Deafult konstruktor
Ocean();
/// Eldönti egy pozícióról, hogy az érvényes óceán pozíció-e
/// @return - true, ha érvényes
bool ervenyes(const Koord& k) const {
return k.i >= 0 && k.i < MaxN && k.j >= 0 && k.j < MaxM;
}
/// Cellában tárolt pointer lekérdezése.
/// @param pos - cellapozíció
/// @return objektum pointere
Obj* getObj(Koord pos) const;
/// Cellában tárolt pointer beírása.
/// @param pos - cellapozíció
/// @param o - új objektum pointere
void setObj(Koord pos, Obj* o);
/// Cellában tárolt pointer kicserélése.
/// A régi objektum felszabadul
/// @param pos - cellapozíció
/// @param o - új objektum pointere
void replObj(Koord pos, Obj* o);
/// Cellarácsok "kirajzolása"
/// @param os - output steram
void rajzol(std::ostream& os) const;
/// Egy iterációs lépés
void lep();
/// Kezdőérték
Iterator begin() { return Iterator(*this); }
/// Végérték
Iterator end() { return Iterator(*this, MaxN*MaxM); }
/// Óceán iterátora
class Iterator {
Obj **p; // aktuális pointer
Obj **pe; // végpointer
public:
/// Inicializálatlan iterátor
Iterator() :p(0), pe(0) {}
/// Konstruktor a begin-hez és az end-hez
/// @param o - óceán
/// @param n - akt. index
Iterator(Ocean& o, int n = 0)
:p(&o.cellak[0][0]+n), pe(&o.cellak[0][0]+MaxN*MaxM) {}
/// !=
bool operator!=(Iterator& it) {
return p != it.p;
}
/// ==
bool operator==(Iterator& it) {
return p == it.p;
}
/// Pre inkremens
Iterator& operator++();
/// Post inkremens
Iterator operator++(int);
/// Csillag
Obj* operator*();
/// Nyíl operátor
Obj** operator->();
};
~Ocean();
};
#endif
gen_array_iter/gen_aaray_iter.vcproj 0 → 100644
<?xml version="1.0" encoding="windows-1250"?>
<VisualStudioProject
ProjectType="Visual C++"
Version="9,00"
Name="gen_array_iter"
ProjectGUID="{B3B5A5E4-61E3-49F0-B0C5-026D68149895}"
RootNamespace="gen_aaray_iter"
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"
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="..\gen_array_iter\gen_array_iter.cpp"
>
</File>
</Filter>
<Filter
Name="Header Files"
Filter="h;hpp;hxx;hm;inl;inc;xsd"
UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}"
>
<File
RelativePath="..\gen_array_iter\gen_array_iter.hpp"
>
</File>
</Filter>
</Files>
<Globals>
</Globals>
</VisualStudioProject>
gen_array_iter/gen_array_iter.cbp 0 → 100644
<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
<CodeBlocks_project_file>
<FileVersion major="1" minor="6" />
<Project>
<Option title="gen_array_iter" />
<Option pch_mode="2" />
<Option compiler="gcc" />
<Build>
<Target title="Debug">
<Option output="bin/Debug/gen_array_iter" prefix_auto="1" extension_auto="1" />
<Option object_output="obj/Debug/" />
<Option type="1" />
<Option compiler="gcc" />
<Compiler>
<Add option="-g" />
</Compiler>
</Target>
<Target title="Release">
<Option output="bin/Release/gen_array_iter" prefix_auto="1" extension_auto="1" />
<Option object_output="obj/Release/" />
<Option type="1" />
<Option compiler="gcc" />
<Compiler>
<Add option="-O2" />
</Compiler>
<Linker>
<Add option="-s" />
</Linker>
</Target>
</Build>
<Compiler>
<Add option="-Wall" />
</Compiler>
<Unit filename="gen_array_iter.cpp" />
<Unit filename="gen_array_iter.hpp" />
<Extensions>
<code_completion />
<debugger />
<envvars />
</Extensions>
</Project>
</CodeBlocks_project_file>
gen_array_iter/gen_array_iter.cpp 0 → 100644
/**
* \file: gen_array_iter.cpp
*
* Egyszerű program az iterátoros generikus tömb eladáson
* bemutatott minimál változatához.
* + kivételkezelés példa
*/
#include <iostream>
#include "gen_array_iter.hpp"
using std::cout;
using std::endl;
int main() {
int t0[6] = { 2, 6, 5, 10, 18, 36 }; // ebből fogunk inicializálni
Array<int> t(t0, t0+6); // létrehozás t0 és t0+6 közötti elemekből
try {
Array<int>::iterator i1, i2;
cout << "A tomb tartalma:"; // kiírjuk
for (i1 = t.begin(); i1 != t.end(); i1++)
cout << " " << *i1;
cout << endl;
for (i1 = t.begin(); i1 != t.end(); i1++) {
cout << *i1 << " osztja a kovetkezoket:";
i2 = i1;
for (i2++; i2 != t.end(); i2++)
if (*i2 % *i1 == 0) cout << " " << *i2;
cout << endl;
}
*i2 = 8; // ez már hibás lesz!
} catch (std::exception& e) {
cout << e.what() << endl;
}
}
gen_array_iter/gen_array_iter.hpp 0 → 100644
/**
* \file: gen_array_iter.hpp
*
* Generikus tömb iterátorral.
* Előadáson bemutatott változat kis kiegészítéssel (inic, i++, ->)
* Az osztály definícióját és a tagfüggvények deklarációit
* nem tesszük külön fájlba, mivel a fordításnál mindkettőnek
* jelen kell lennie!
*/
#ifndef GEN_ARRAY_ITER
#define GEN_ARRAY_ITER
#include <stdexcept>
/// Array sablon
template<class T, unsigned int maxsiz = 6>
class Array {
T t[maxsiz]; // elemek tömbje
public:
// minden default tagfüggvény jó, nem kell átdefiniálni
class iterator; // elõdeklaráció
/// Konstruktor T-ket tartalmazó tömbből
/// @param p - poninter T elemeket tartalmazó tömb elejére
/// @param pe - poninter a tömb utolsó eleme után
Array(T *p, T*pe) { // két pointer közötti elemekbõl inicializaló konstruktor
for (unsigned int i = 0; p != pe && i < maxsiz; i++)
t[i] = *p++;
}
/// Iterátor létrehozása az elejére
iterator begin() { // létrehoz egy iterátort és az elejére állítja
return iterator(*this);
}
/// Iterátor létrehozása a végére
iterator end() { // létrehozza és az utolsó elem után állítja
return iterator(*this, maxsiz);
}
/// iterator osztály
class iterator {
T *p, *pe; // pointer az akt elemre, és az utolsó utánira
public:
// Van benne pointer, mégis jó a default másoló konstruktor és az értékadó op. Miért ?
/// Konstruktorok
iterator() :p(0), pe(0) {} // default kontruktor
iterator(Array& a, int ix = 0)
:p(a.t+ix), pe(a.t+maxsiz) {} // kontruktor Array-ról
/// Pre-inkremens
iterator& operator++() { // növeli az iterátort (pre)
if (p != pe) ++p;
return *this;
}
/// Post-inkemens
iterator operator++(int) { // növeli az iterátort (post)
// nem referencia értékû (miért ?)
iterator tmp = *this;
if (p != pe) p++;
return tmp;
}
/// operator!=
bool operator!=(const iterator &i) { // összehasonlít
return(p != i.p);
}
/// operator*
T& operator*() { // indirekció
if (p != pe) return *p;
else throw std::out_of_range("Array: Hibas indirekcio");
}
/// operator->
T* operator->() { // indirekció
if (p != pe) return p;
else throw std::out_of_range("Array: Hibas indirekcio");
}
}; // iterator osztály vége
}; // generikus tömb vége
#endif
gen_array_iter/gen_array_iter.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>{2CBDD241-E111-4EAC-A269-8440CC21BC18}</ProjectGuid>
<Keyword>Win32Proj</Keyword>
<RootNamespace>gen_array_iter</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;%(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>
<ClCompile Include="gen_array_iter.cpp" />
</ItemGroup>
<ItemGroup>
<ClInclude Include="gen_array_iter.hpp" />
</ItemGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
<ImportGroup Label="ExtensionTargets">
</ImportGroup>
</Project>
\ No newline at end of file
gen_array_iter/gen_array_iter.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>
<ClCompile Include="gen_array_iter.cpp">
<Filter>Source Files</Filter>
</ClCompile>
</ItemGroup>
<ItemGroup>
<ClInclude Include="gen_array_iter.hpp">
<Filter>Header Files</Filter>
</ClInclude>
</ItemGroup>
</Project>
\ No newline at end of file
generikus_lista/generikus_lista.cbp 0 → 100644
<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
<CodeBlocks_project_file>
<FileVersion major="1" minor="6" />
<Project>
<Option title="lista" />
<Option pch_mode="2" />
<Option compiler="gcc" />
<Build>
<Target title="Debug">
<Option output="bin/Debug/lanc" prefix_auto="1" extension_auto="1" />
<Option object_output="obj/Debug/" />
<Option type="1" />
<Option compiler="gcc" />
<Compiler>
<Add option="-g" />
</Compiler>
</Target>
<Target title="Release">
<Option output="bin/Release/lanc" prefix_auto="1" extension_auto="1" />
<Option object_output="obj/Release/" />
<Option type="1" />
<Option compiler="gcc" />
<Compiler>
<Add option="-O2" />
</Compiler>
<Linker>
<Add option="-s" />
</Linker>
</Target>
</Build>
<Compiler>
<Add option="-Wall" />
</Compiler>
<Unit filename="generikus_lista.hpp" />
<Unit filename="main.cpp" />
<Extensions>
<code_completion />
<debugger />
<envvars />
</Extensions>
</Project>
</CodeBlocks_project_file>
generikus_lista/generikus_lista.hpp 0 → 100644
/**
* \file: generikus_lista.hpp
*
*
* Előadáson bemutatott generikus lista
* Generilus lista
*/
#ifndef GENERIKUS_LISTA_HPP
#define GENERIKUS_LISTA_HPP
template<class T>
class Lista {
struct ListaElem { // privát struktúra
T adat; // adat
ListaElem *kov; // pointer a következőre
ListaElem(ListaElem *p = NULL) :kov(p) {}
// kihasználjuk, hogy pointert másol a másoló
ListaElem& operator=(const ListaElem); // véletlenül se használjuk
};
ListaElem *elso; // pointer az elsőre
ListaElem *akt; // pointer az aktuálisra
Lista(const Lista&); // nem használható
Lista& operator=(const Lista&); // nem használható
bool hasonlit(const T d1, T d2) { return(d1<d2); }
public:
Lista() { akt = elso = new ListaElem;} // strázsa létrehozása
void beszur(const T& dat); // elem beszúrása
bool kovetkezo(T& dat);
~Lista();
};
template <class T> // tagfüggvénysablon
Lista<T>::~Lista() {
ListaElem *p; // futó pointer
while ((p = elso) != NULL) {
elso = p->kov;
delete p;
}
}
template <class T> // tagfüggvénysablon
void Lista<T>::beszur(const T& dat) {
ListaElem *p; // futó pointer
for (p = elso; p->kov != NULL && hasonlit(p->adat, dat); p = p->kov);
ListaElem *uj = new ListaElem(*p); //régit másol
p->adat = dat; p->kov = uj; // adat beírása
}
template <class T> // tagfüggvénysablon
bool Lista<T>::kovetkezo(T& dat) { // következő elem
if (akt->kov == NULL) { akt = elso; return(false); }
dat = akt->adat; akt = akt->kov;
return(true);
}
#endif // GENERIKUS_LISTA_HPP
generikus_lista/main.cpp 0 → 100644
/**
*\file: main.cpp
*
* Főprogram az előadáson bemutatott generikus lista kipróbálásához
*/
#include <iostream>
#include <cstring>
#include "generikus_lista.hpp" // sablonok
using namespace std;
template<>
bool Lista<const char*>::hasonlit(const char* s1, const char*s2) {// spec.
return(strcmp(s1, s2) < 0);
}
int main()
{
Lista<int> L; // int lista
Lista<double> Ld; // double lista
Lista<const char*> Ls; // char* lista
L.beszur(1); L.beszur(19); L.beszur(-41);
Ls.beszur("Alma"); Ls.beszur("Hello"); Ls.beszur("Aladar");
int x;
while (L.kovetkezo(x))
cout << x << endl;
const char *s;
while (Ls.kovetkezo(s))
cout << s << endl;
return 0;
}
generikus_lista_iter/generikus_lista_iter.cbp 0 → 100644
<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
<CodeBlocks_project_file>
<FileVersion major="1" minor="6" />
<Project>
<Option title="lista_iter" />
<Option pch_mode="2" />
<Option compiler="gcc" />
<Build>
<Target title="Debug">
<Option output="bin/Debug/lanc" prefix_auto="1" extension_auto="1" />
<Option object_output="obj/Debug/" />
<Option type="1" />
<Option compiler="gcc" />
<Compiler>
<Add option="-g" />
</Compiler>
</Target>
<Target title="Release">
<Option output="bin/Release/lanc" prefix_auto="1" extension_auto="1" />
<Option object_output="obj/Release/" />
<Option type="1" />
<Option compiler="gcc" />
<Compiler>
<Add option="-O2" />
</Compiler>
<Linker>
<Add option="-s" />
</Linker>
</Target>
</Build>
<Compiler>
<Add option="-Wall" />
</Compiler>
<Unit filename="generikus_lista_iter.hpp" />
<Unit filename="main.cpp" />
<Extensions>
<code_completion />
<debugger />
<envvars />
</Extensions>
</Project>
</CodeBlocks_project_file>
generikus_lista_iter/generikus_lista_iter.hpp 0 → 100644
/**
* \file: generikus_lista_iter.cpp
*
* Előadáson bemutatott generikus lista iterátorral
*
*/
#include <stdexcept>
#ifndef GENERIKUS_LISTA_ITER_HPP
#define GENERIKUS_LISTA_ITER_HPP
template<class T>
class Lista {
struct ListaElem { // privát struktúra
T adat; // adat
ListaElem *kov; // pointer a következőre
ListaElem(ListaElem *p = NULL) :kov(p) {}
// kihasználjuk, hogy pointert másol a másoló
ListaElem& operator=(const ListaElem); // véletlenül se használjuk
};
ListaElem *elso; // pointer az elsőre
ListaElem *akt; // pointer az aktuálisra
Lista(const Lista&); // nem használható
Lista& operator=(const Lista&); // nem használható
bool hasonlit(const T d1, T d2) { return(d1<d2); }
public:
Lista() { akt = elso = new ListaElem;} // strázsa létrehozása
void beszur(const T& dat); // elem beszúrása
class iterator; // elődeklaráció
iterator begin() { // létrehoz egy iterátort és az elejére állítja
return(iterator(*this));
}
iterator end() { // létrehozza és az utolsó elem után állítja
return(iterator());
}
class iterator { // belső osztály, a publikus részek kilátszanak
ListaElem *akt; // mutató az aktuális elemre
public:
iterator() : akt(NULL) {}; // végére állítja az iterátort
iterator(const Lista& l) : akt(l.elso) { // elejére állítja
if (akt->kov == NULL)
akt = NULL; // strázsa miatti trükk
}
iterator& operator++() { // növeli az iterátort (pre)
if (akt != NULL) {
akt = akt->kov; // következőre
if (akt->kov == NULL)
akt = NULL; // strázsa miatti trükk
}
return(*this);
}
iterator operator++(int) { // növeli az iterátort (post)
iterator tmp = *this; // előző érték
operator++(); // növel
return(tmp); // előzővel kell visszatérni
}
bool operator!=(const iterator &i) const { // összehasonlít
return(akt != i.akt);
}
T& operator*() { // indirekció
if (akt != NULL ) return(akt->adat);
else throw std::out_of_range("Hibás");
}
T* operator->() { // indirekció
if (akt != NULL) return(&akt->adat);
else throw std::out_of_range("Hibás");
}
}; // iterator osztály vége
~Lista();
};
template <class T> // tagfüggvénysablon
Lista<T>::~Lista() {
ListaElem *p; // futó pointer
while ((p = elso) != NULL) {
elso = p->kov;
delete p;
}
}
template <class T> // tagfüggvénysablon
void Lista<T>::beszur(const T& dat) {
ListaElem *p; // futó pointer
for (p = elso; p->kov != NULL && hasonlit(p->adat, dat); p = p->kov);
ListaElem *uj = new ListaElem(*p); //régit másol
p->adat = dat; p->kov = uj; // adat beírása
}
#endif // GENERIKUS_LISTA_ITER_HPP
generikus_lista_iter/main.cpp 0 → 100644
/**
*\file: main.cpp
*
* Főprogram az előadáson bemutatott iterátoros generikus lista kipróbálásához
*/
#include <iostream>
#include <cstring>
#include <iomanip>
#include "generikus_lista_iter.hpp" // sablonok
using namespace std;
template<>
bool Lista<const char*>::hasonlit(const char* s1, const char*s2) {// spec.
return(strcmp(s1, s2) < 0);
}
/// generikus kiíró fv.
template<class Iter>
void printFv(Iter first, Iter last){
while (first != last)
std::cout << *first++ << ',';
std::cout << endl;
}
int main() {
int szamok[] = { 2, 6, 72, 12, 3, 50, 25, 100, 0 };
std::cout << "szamok a tombbol: ";
printFv(szamok, szamok+8);
Lista<int> li;
int *p = szamok;
while (*p != 0) li.beszur(*p++);
std::cout << "szamok a listabol: ";
printFv(li.begin(), li.end());
Lista<int>::iterator i1, i2;
for (i1 = li.begin(); i1 != li.end(); ++i1) {
std::cout << std::setw(3) << *i1 << " osztja a kovetkezoket:";
i2 = i1;
for (++i2; i2 != li.end(); ++i2)
if (*i2 % *i1 == 0)
std::cout << " " << *i2;
std::cout << std::endl;
}
Lista<const char*> ls; // const char* lista
ls.beszur("Alma"); ls.beszur("Hello"); ls.beszur("Aladar");
std::cout << "sztringek listabol: ";
printFv(ls.begin(), ls.end());
return(0);
}
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or sign in to comment