Skip to content

Prog2 / eloadas_peldak / ea_06

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

v0

parents
Showing with 1255 additions and 0 deletions
digit/callback.h 0 → 100644
/**
* \file callback.h
* Callback osztály deklarációja
*/
#ifndef CALLBACK_H
#define CALLBACK_H
/**
* Callback segédosztály
*/
struct Callback {
virtual void callback() = 0; ///< virtuális callback függvény
};
#endif // CALLBACK_H
digit/conn.h 0 → 100644
/**
* \file conn.h
* Conn osztály deklarációja
*/
#ifndef CONN_H
#define CONN_H
typedef unsigned int Pin;
class Obj;
/**
* Összekötésért felelős objektum
*/
class Conn {
Obj *obj; ///< ezen objektumhoz kapcsolódik
Pin n; ///< erre a pontjára
public:
Conn() :obj(NULL) {} ///< Kell a default konstruktor. Nem kapcsolódik sehova
/// Kapcsolat létrehozása
/// @param k - o (idegen) objektumnak ehhez a pontjához kapcsolódunk
/// @param o - objektum amihez kapcsolódunk
void setConn(Pin k, Obj &o) { n = k; obj = &o; }
/// Kapcsolat lekérdezése
/// @param k - o (idegen) objektumnak ehhez a pontjához kapcsolódunk
/// @return objektum amihez kapcsolódik
Obj *getConn(Pin &k) const { k = n; return(obj); }
};
#endif // CONN_H
digit/csp.cpp 0 → 100644
/**
* \file csp.cpp
* Csp osztály tagfüggvényinek megvalósítása
*/
#include "csp.h"
void Csp::set(Pin n, Message msg) {
if (veg[n] != msg) { // ha van változás,
veg[n] = msg; // akkor megjegyzi és
uzen((n+1)%3, msg); // továbbküldi,
uzen((n+2)%3, msg); // továbbküldi
}
}
digit/csp.h 0 → 100644
/**
* \file csp.h
* Csp osztály deklarációja
*/
#ifndef CSP_H
#define CSP_H
#include "obj.h"
/**
* Csomópont osztály.
* 3 kapcsolódási pontja van
* Az egyik ponton bejövő jelet változtatás nélkül kiküldi a másik kettőre.
*/
class Csp :public Obj {
protected:
Message veg[3]; ///< három vége van
public:
/// Ez a default konstruktor is
/// @param n - objektum neve (alapértelmezése "")
Csp(const char *n = "csp") : Obj(n, 3) {} // létrehoz egy 3 végű objektumot
/// Működést megvalósító virtuális függvény.
/// A beérkező üzenet és a saját állapota alapján ki kell számítania a választ.
/// @param k - kapcsolódási pontra üzenet érkezett
/// @param msg - beérkező üzenet
void set(Pin n, Message msg); ///< működést megvalósító függvény
};
#endif // CSP_H
digit/digit.cbp 0 → 100644
<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
<CodeBlocks_project_file>
<FileVersion major="1" minor="6" />
<Project>
<Option title="digit" />
<Option pch_mode="2" />
<Option compiler="gcc" />
<Build>
<Target title="Debug">
<Option output="bin/Debug/digit" prefix_auto="1" extension_auto="1" />
<Option object_output="obj/Debug/" />
<Option type="1" />
<Option compiler="gcc" />
<Compiler>
<Add option="-g" />
<Add option="-DMEMTRACE" />
<Add option="-DDEBUG" />
</Compiler>
</Target>
<Target title="Release">
<Option output="bin/Release/digit" 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="callback.h" />
<Unit filename="conn.h" />
<Unit filename="csp.cpp" />
<Unit filename="csp.h" />
<Unit filename="drot.cpp" />
<Unit filename="drot.h" />
<Unit filename="forras.h" />
<Unit filename="kapcsolo.cpp" />
<Unit filename="kapcsolo.h" />
<Unit filename="main.cpp" />
<Unit filename="memtrace.cpp" />
<Unit filename="memtrace.h" />
<Unit filename="message.cpp" />
<Unit filename="message.h" />
<Unit filename="nand.cpp" />
<Unit filename="nand.h" />
<Unit filename="obj.cpp" />
<Unit filename="obj.h" />
<Unit filename="r_s_ff.cpp" />
<Unit filename="r_s_ff.h" />
<Extensions>
<code_completion />
<debugger />
<envvars />
</Extensions>
</Project>
</CodeBlocks_project_file>
digit/digit.vcproj 0 → 100644
<?xml version="1.0" encoding="windows-1250"?>
<VisualStudioProject
ProjectType="Visual C++"
Version="9,00"
Name="digit"
ProjectGUID="{6A644679-5202-44FD-9557-9C980E330EFB}"
RootNamespace="digit"
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=".\csp.cpp"
>
</File>
<File
RelativePath=".\drot.cpp"
>
</File>
<File
RelativePath=".\kapcsolo.cpp"
>
</File>
<File
RelativePath=".\main.cpp"
>
</File>
<File
RelativePath=".\nand.cpp"
>
</File>
<File
RelativePath=".\obj.cpp"
>
</File>
<File
RelativePath=".\r_s_ff.cpp"
>
</File>
</Filter>
<Filter
Name="Header Files"
Filter="h;hpp;hxx;hm;inl;inc;xsd"
UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}"
>
<File
RelativePath=".\callback.h"
>
</File>
<File
RelativePath=".\conn.h"
>
</File>
<File
RelativePath=".\csp.h"
>
</File>
<File
RelativePath=".\drot.h"
>
</File>
<File
RelativePath=".\forras.h"
>
</File>
<File
RelativePath=".\kapcsolo.h"
>
</File>
<File
RelativePath=".\message.h"
>
</File>
<File
RelativePath=".\nand.h"
>
</File>
<File
RelativePath=".\obj.h"
>
</File>
<File
RelativePath=".\r_s_ff.h"
>
</File>
</Filter>
<Filter
Name="Resource Files"
Filter="rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav"
UniqueIdentifier="{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}"
>
</Filter>
</Files>
<Globals>
</Globals>
</VisualStudioProject>
digit/doxygen/doxyfile 0 → 100644
This source diff could not be displayed because it is too large. You can view the blob instead.
digit/drot.cpp 0 → 100644
/**
* \file drot.cpp
* Drot osztály tagfüggvényinek megvalósítása
*/
#include "drot.h"
void Drot::set(Pin n, Message msg) {
if (veg[n] != msg) { // ha változott
veg[n] = msg; // megjegyezzük, és
uzen(n^1, msg); // elküldjük a másik végére
}
}
digit/drot.h 0 → 100644
/**
* \file drot.h
* Drot osztály deklarációja
*/
#ifndef DROT_H
#define DROT_H
#include "obj.h"
/**
* Drót osztály.
* A két végpontja között vezet
* A végpontok protected védelemmel vannak, hogy használható legyen
* egy esetleges származtatásnál (kapcsoló)
*/
class Drot :public Obj {
protected: // védelel enyhítése
Message veg[2]; ///< két vége van
public:
/// Ez a default konstruktor is
/// @param n - objektum neve (alapértelmezése "")
Drot(const char *n = "drot") : Obj(n, 2) {} // létrehoz egy 2 végű objektumot
/// Allapot lekérdezése
/// két végen levő jel összegét adja
const Message get() { return(veg[0]+veg[1]);}
/// Működést megvalósító virtuális függvény.
/// A beérkező üzenet és a saját állapota alapján ki kell számítania a választ.
/// @param k - kapcsolódási pontra üzenet érkezett
/// @param msg - beérkező üzenet
void set(Pin n, Message msg); ///< működést megvalósító függvény
};
#endif // DROT_H
digit/forras.h 0 → 100644
/**
* \file forras.h
* Forras osztály deklarációja
*/
#ifndef FORRAS_H
#define FORRAS_H
#include "obj.h"
/**
* Forrás osztály.
* Jelforrás
* Konstruktor 2. paramétere a jel értéke
*/
class Forras :public Obj {
Message veg[1]; ///< egy vége van
bool J; ///
public:
/// Ez a default konstruktor is
/// @param n - objektum neve (alapértelmezése "")
/// @param j - jel (alapértelmezése true); lehetne 0 forrás is
Forras(const char *n = "f", bool j = true) : Obj(n, 1), J(j) {} // létrehoz egy 1 végű objektumot
/// Forrás "bekapcsolása"
/// A kezdeti "rúgást" a források adják
void init() { uzen(0, Message(Message::jel, J)); }
/// Működést megvalósító függvény
/// Ha üzenet érkezik, akkor az üzenettől függetlenül kiadjuk a forrás a jelét
void set(Pin n, Message msg) { uzen(0, Message(Message::jel, J)); }
};
#endif // FORRAS_H
digit/kapcsolo.cpp 0 → 100644
/**
* \file kapcsolo.cpp
* Kapcsolo osztály tagfüggvényinek megvalósítása
*/
#include "kapcsolo.h"
void Kapcsolo::set(Pin n, Message msg) {
if (on) // ha be van kapcsolva, akkor drótként viselkedik
Drot::set(n, msg); // hívja a Drot működtető függvényét
else
veg[n] = msg; // egyébként csak megjegyzi a bejövő jelet
}
/// Kikapcsolás
/// 0 jelet üzen mindkét végére
void Kapcsolo::ki() {
on = false ;
uzen(0, Message(Message::jel)); // 0-t üzen mindkét végére
uzen(1, Message(Message::jel));
}
/// Bekapcsolás
/// Drótként viselkedik
void Kapcsolo::be() {
on = true;
uzen(0, veg[1]);
uzen(1, veg[0]);
}
digit/kapcsolo.h 0 → 100644
/**
* \file kapcsolo.h
* Kapcsoló osztály deklarációja
*/
#ifndef KAPCSOLO_H
#define KAPCSOLO_H
#include "obj.h"
#include "callback.h"
#include "drot.h"
/**
* Kapcsoló osztály.
* Drot-ból és Callback-ból származtatott osztály
* Bekapcsolt állapotban Drot-ként viselkedik
* Kikapcsoláskor mindkét végére 0 jelszintet üzen
* Precízebb lenne nem definiált állapotot üzenni, de ezt az állapotot
* nem kezeli a többi elem.
*/
class Kapcsolo : public Drot, public Callback { // Drótból
bool on; ///< állapot
public:
/// Ez a default konstruktor is
/// @param n - objektum neve (alapértelmezése "")
Kapcsolo(const char *n = "k") : Drot(n), on(false) {} // létrehozza a Drótot, és kikapcsol
void set(Pin n, Message msg); ///< működést megvalósító függvény
/// Kikapcsolás
/// 0 jelet üzen mindkét végére
void ki();
/// Bekapcsolás
/// Drótként viselkedik
void be();
/// Callback függvény
/// Ki állapotból bekapcsol, Be állapotból kikapcsol
void callback() { if (on) ki(); else be(); } // callback
};
#endif // KAPCSOLO_H
digit/main.cpp 0 → 100644
/**
* \mainpage Digitális áramkörök modellezése
*
* \par Feladat:
* Digitális áramkör modellezése, szimulálása. Megvalósított objektumok:
* - Drót (Drot)
* - Csomópont (Csp)
* - Kapcsoló (Kapcsolo)
* - Forrás (Forras)
* - Nyomógomb (Gomb)
* - NAND kapu
* - Inverz bemenetű RS flip-flop (R_S_FF)
*
* \par Demostrációs cél:
* - öröklés és többszörös öröklés megvalósításának bemutatása
* - virtuális tagfüggvény bemutatása
* \par Hivatkozások
* - A program forrása letölthető <A href="https://git.ik.bme.hu/Prog2/eloadas_peldak/ea_06">innen.</a>
* - A megértést segíti a 6. előadás anyaga.
*
* \par Hiányosságok:
* - A jelkezelés nem használja a nem definiált állapotot
* - A kapcsolódási pontoknak (lábszámoknak) semmi köze a tényleges áramköri elem lábsorszámához
* - A lábakon megjelenő tároló lehetne a Conn objektumban is.
*
*/
#include <iostream>
#include "forras.h"
#include "kapcsolo.h"
#include "r_s_ff.h"
#include "nand.h"
using std::cerr;
using std::endl;
using std::cin;
/**
* Egyszerű tesztkapcsolás
* 2 forrás, 2 kapcsoló, RS flop-flop.
*
*/
int main()
{
Kapcsolo K1("K1"), K2("K2"); // kapcsolók
Forras F1("F1"), F2("F2"); // források
R_S_FF FF("FF"); // RS FF
try {
F1.setConn(0, K1, 0); // F1 láb 0 -> K1 láb 0
FF.setConn(0, K1, 1); // FF láb 0 -> K1 láb 1
F2.setConn(0, K2, 0); // F2 láb 0 -> K2 láb 0
FF.setConn(1, K2, 1); // FF láb 1 -> K1 láb 1
cerr << "\nInit:"; F1.init(); F2.init(); // Forrásokat "bekapcsoljuk"
cerr << "\n\nS_ R_ Q Q_";
#ifdef DEBUG
cerr << endl;
#endif // DEBUG
K1.be(); K2.be();
cerr << "\n" << FF.get(0).J << " " << FF.get(1).J << " " << FF.get(2).J << " " << FF.get(3).J;
cin.ignore(1);
K1.ki(); K2.be();
cerr << "\n" << FF.get(0).J << " " << FF.get(1).J << " " << FF.get(2).J << " " << FF.get(3).J;
cin.ignore(1);
K1.be(); K2.be();
cerr << "\n" << FF.get(0).J << " " << FF.get(1).J << " " << FF.get(2).J << " " << FF.get(3).J;
cin.ignore(1);
K1.be(); K2.ki();
cerr << "\n" << FF.get(0).J << " " << FF.get(1).J << " " << FF.get(2).J << " " << FF.get(3).J;
cin.ignore(1);
K1.ki(); K2.ki();
cerr << "\n" << FF.get(0).J << " " << FF.get(1).J << " " << FF.get(2).J << " " << FF.get(3).J;
cerr << "\nHurok kovetkezik:" << endl;
cin.ignore(1);
NAND Nx("Nx");
F1.setConn(0, Nx, 0);
Nx.setConn(2, Nx, 1); // saját magához kötöttük
F1.init(); // és belerúgunk
} catch (const char *s) {
cerr << "Elkaptuk: " << s << '\n';
}
return(0);
}
digit/memtrace.h 0 → 100644
/*********************************
Memoriaszivargas-detektor
Keszitette: Peregi Tamas, BME IIT, 2011
petamas@iit.bme.hu
Kanari: Szeberenyi Imre, 2013.,
VS 2012: Szeberényi Imre, 2015.,
mem_dump: 2016.
inclue-ok: 2017., 2018. 2019.
singleton: 2019.
*********************************/
#ifndef MEMTRACE_H
#define MEMTRACE_H
#if defined(MEMTRACE)
/*ha definiálva van, akkor a hibakat ebbe a fajlba írja, egyébkent stderr-re*/
/*#define MEMTRACE_ERRFILE MEMTRACE.ERR*/
/*ha definialva van, akkor futas kozben lancolt listat epit. Javasolt a hasznalata*/
#define MEMTRACE_TO_MEMORY
/*ha definialva van, akkor futas kozben fajlba irja a foglalasokat*/
/*ekkor nincs ellenorzes, csak naplozas*/
/*#define MEMTRACE_TO_FILE*/
/*ha definialva van, akkor a megallaskor automatikus riport keszul */
#define MEMTRACE_AUTO
/*ha definialva van, akkor malloc()/calloc()/realloc()/free() kovetve lesz*/
#define MEMTRACE_C
#ifdef MEMTRACE_C
/*ha definialva van, akkor free(NULL) nem okoz hibat*/
#define ALLOW_FREE_NULL
#endif
#ifdef __cplusplus
/*ha definialva van, akkor new/delete/new[]/delete[] kovetve lesz*/
#define MEMTRACE_CPP
#endif
#if defined(__cplusplus) && defined(MEMTRACE_TO_MEMORY)
/*ha definialva van, akkor atexit helyett objektumot hasznal*/
/*ajanlott bekapcsolni*/
#define USE_ATEXIT_OBJECT
#endif
/******************************************/
/* INNEN NE MODOSITSD */
/******************************************/
#ifdef NO_MEMTRACE_TO_FILE
#undef MEMTRACE_TO_FILE
#endif
#ifdef NO_MEMTRACE_TO_MEMORY
#undef MEMTRACE_TO_MEMORY
#endif
#ifndef MEMTRACE_AUTO
#undef USE_ATEXIT_OBJECT
#endif
#ifdef __cplusplus
#define START_NAMESPACE namespace memtrace {
#define END_NAMESPACE } /*namespace*/
#define TRACEC(func) memtrace::func
#include <new>
#else
#define START_NAMESPACE
#define END_NAMESPACE
#define TRACEC(func) func
#endif
// THROW deklaráció változatai
#if defined(_MSC_VER)
// VS rosszul kezeli az __cplusplus makrot
#if _MSC_VER < 1900
// * nem biztos, hogy jó így *
#define THROW_BADALLOC
#define THROW_NOTHING
#else
// C++11 vagy újabb
#define THROW_BADALLOC noexcept(false)
#define THROW_NOTHING noexcept
#endif
#else
#if __cplusplus < 201103L
// C++2003 vagy régebbi
#define THROW_BADALLOC throw (std::bad_alloc)
#define THROW_NOTHING throw ()
#else
// C++11 vagy újabb
#define THROW_BADALLOC noexcept(false)
#define THROW_NOTHING noexcept
#endif
#endif
START_NAMESPACE
int allocated_blocks();
END_NAMESPACE
#if defined(MEMTRACE_TO_MEMORY)
START_NAMESPACE
int mem_check(void);
END_NAMESPACE
#endif
#if defined(MEMTRACE_TO_MEMORY) && defined(USE_ATEXIT_OBJECT)
#include <cstdio>
START_NAMESPACE
class atexit_class {
private:
atexit_class() {
#if defined(CPORTA) && !defined(CPORTA_NOSETBUF)
setbuf(stdout, 0);
setbuf(stderr, 0);
#endif
}
public:
static atexit_class& get_atexit_obj() {
static atexit_class instance; // singleton példány
return instance;
}
int check() {
return mem_check();
}
~atexit_class() {
check();
}
};
/// A statikus referencia minden fordítási egységben keletkezik, de
/// mindegyik egyetlen példányra fog hivatkozni a singleton minta miatt
static atexit_class& atexit_obj = atexit_class::get_atexit_obj();
END_NAMESPACE
#endif/*MEMTRACE_TO_MEMORY && USE_ATEXIT_OBJECT*/
/*Innentol csak a "normal" include eseten kell, kulonben osszezavarja a mukodest*/
#ifndef FROM_MEMTRACE_CPP
#include <stdlib.h>
#ifdef __cplusplus
#include <iostream>
/* ide gyűjtjük a nemtrace-vel összeakadó headereket, hogy előbb legyenek */
#include <fstream> // VS 2013 headerjében van deleted definició
#include <sstream>
#include <vector>
#include <list>
#include <map>
#include <algorithm>
#include <functional>
#endif
#ifdef MEMTRACE_CPP
namespace std {
typedef void (*new_handler)();
}
#endif
#ifdef MEMTRACE_C
START_NAMESPACE
#undef malloc
#define malloc(size) TRACEC(traced_malloc)(size,#size,__LINE__,__FILE__)
void * traced_malloc(size_t size, const char *size_txt, int line, const char * file);
#undef calloc
#define calloc(count,size) TRACEC(traced_calloc)(count, size, #count","#size,__LINE__,__FILE__)
void * traced_calloc(size_t count, size_t size, const char *size_txt, int line, const char * file);
#undef free
#define free(p) TRACEC(traced_free)(p, #p,__LINE__,__FILE__)
void traced_free(void * p, const char *size_txt, int line, const char * file);
#undef realloc
#define realloc(old,size) TRACEC(traced_realloc)(old,size,#size,__LINE__,__FILE__)
void * traced_realloc(void * old, size_t size, const char *size_txt, int line, const char * file);
void mem_dump(void const *mem, size_t size, FILE* fp);
END_NAMESPACE
#endif/*MEMTRACE_C*/
#ifdef MEMTRACE_CPP
START_NAMESPACE
#undef set_new_handler
#define set_new_handler(f) TRACEC(_set_new_handler)(f)
void _set_new_handler(std::new_handler h);
void set_delete_call(int line, const char * file);
END_NAMESPACE
void * operator new(size_t size, int line, const char * file) THROW_BADALLOC;
void * operator new[](size_t size, int line, const char * file) THROW_BADALLOC;
void * operator new(size_t size) THROW_BADALLOC;
void * operator new[](size_t size) THROW_BADALLOC;
void operator delete(void * p) THROW_NOTHING;
void operator delete[](void * p) THROW_NOTHING;
/* Visual C++ 2012 miatt kell, mert háklis, hogy nincs megfelelő delete, bár senki sem használja */
void operator delete(void *p, int, const char *) THROW_NOTHING;
void operator delete[](void *p, int, const char *) THROW_NOTHING;
#define new new(__LINE__, __FILE__)
#define delete memtrace::set_delete_call(__LINE__, __FILE__),delete
#ifdef CPORTA
#define system(...) // system(__VA_ARGS__)
#endif
#endif /*MEMTRACE_CPP*/
#endif /*FROM_MEMTRACE_CPP*/
#endif /*MEMCHECK*/
#endif /*MEMTRACE_H*/
digit/message.cpp 0 → 100644
/**
* \file message.c
* Message osztály definíciója
*/
#include "message.h"
#ifdef DEBUG
std::ostream& operator<<(std::ostream& os, const Message& m) {
return os << "Jel:" << m.J << "." << m.c;
}
#endif
digit/message.h 0 → 100644
/**
* \file message.h
* Message osztály deklarációja
*/
#ifndef MESSAGE_H
#define MESSAGE_H
#include <iostream>
const int MaxIter = 20; ///< Maximális iterációszám
/**
* Üzenet (struktúra)
* Egy publikus osztály
*/
struct Message {
/// üzenet típusa
/// undef - jelenleg nem használt
/// jel - J jelszintnek megfeleő szint
enum msgt { undef, jel} typ;
bool J; ///< jelszint 0 v. 1
int c; ///< iterációs ciklusszámláló
/// Ez a default konstruktor is
/// @param t - üzenettípus (alapértelmezése undef)
/// @param j - jel szint(alapértelmezése 0)
/// @param n - maximális iterációs szám (alapértelmezése MaxIter)
Message(msgt t = undef, bool j = false, int n = MaxIter)
:typ(t), J(j), c(n) {}
/// Két üzenet összehasonlítása.
/// Akkor egyenlő, ha a típusa es a jelszintje is azonos
bool operator==(const Message &m) const { return(typ == m.typ && J == m.J); }
bool operator!=(const Message &m) const { return(!operator==(m)); } ///< == operátorra van visszavezetve
Message operator+(const Message &m) const {
return Message(std::max(typ, m.typ), (J+m.J)!=0, // ez az MSC miatt kell !
std::max(c, m.c));
}
/// Iterációs számláló csökkentése
/// Ha az iterációs szám kisebb lesz mint 1, akkor
/// "Sok Iteració" const char* hibát dob
Message &operator--() { if (--c <= 0) // iterációs számláló csökkentése
throw "Sok Iteracio!"; return(*this); }
};
#ifdef DEBUG
std::ostream& operator<<(std::ostream& os, const Message& m);
#endif
#endif // MESSAGE_H
digit/nand.cpp 0 → 100644
/**
* \file nand.cpp
* NAND osztály tagfüggvényinek megvalósítása
*/
#include "nand.h"
void NAND::set(Pin n, Message msg) {
if (n != 2 && veg[n] != msg) { // ha az input és változott,
veg[n] = msg; // akkor eltesszük
uzen(2, veg[2] = Message(Message::jel, // előállítjuk a kimenetet, és
!(veg[0].J * veg[1].J), msg.c)); // elküldjük a kimenetre azonos iterációs számmal
}
}
digit/nand.h 0 → 100644
/**
* \file nand.h
* NAND osztály deklarációja
*/
#ifndef NAND_H
#define NAND_H
#include "obj.h"
/**
* NAND Kapu.
* NAND kapu működését megvalósító osztály
* Három lába van:
* 0,1 - bemenetek
* 2 - kimenet
*/
class NAND :public Obj {
protected:
Message veg[3]; ///< három vége van
public:
/// Ez a default konstruktor is
/// @param n - objektum neve (alapértelmezése "")
NAND(const char *n = "nand") : Obj(n, 3) {} // létrehoz egy 3 végű objektumot
/// Adott láb állapotának lekérdezése
const Message& get(Pin n) {
return(veg[n%3]);} ///< be/kimenet lekérdezése (bemenet is lekérdezhető,
///< debug célokra)
/// Működést megvalósító virtuális függvény.
/// A beérkező üzenet és a saját állapota alapján ki kell számítania a választ.
/// @param k - kapcsolódási pontra üzenet érkezett
/// @param msg - beérkező üzenet
void set(Pin n, Message msg); ///< működést megvalósító függvény
};
#endif // NAND_H
digit/obj.cpp 0 → 100644
/**
* \file obj.cpp
* Obj osztály tagfüggvényinek megvalósítása
*/
#include <iostream>
#include "obj.h"
void Obj::setConn(Pin k, Obj &o, Pin ok) {
if (k >= nk || ok >= o.nk)
throw "Conn hiba!"; // hiba, nincs ilyen végpont
konn[k].setConn(ok, o); // kapcsolat beállítása
o.konn[ok].setConn(k, *this); // a kapcsolat reflektív a drót tulajdonságai miatt
}
void Obj::uzen(Pin k, Message msg) {
Pin n; // ide kerül a kapcsolódó obj kapcsolatsorszáma
if (k >= nk)
throw "Uzenet hiba"; // hiba, nincs ilyen végpont
if (Obj *o = konn[k].getConn(n)) {
#ifdef DEBUG
std::cout << nev << "." << k << "---> " << o->nev << "." << n << ": " << msg << std::endl;
#endif
o->set(n, --msg); // szomszéd működtető függvénye
}
}
digit/obj.h 0 → 100644
/**
* \file obj.h
* Obj osztály deklarációja
*/
#ifndef OBJ_H
#define OBJ_H
#include <string>
#include "memtrace.h"
#include "message.h"
#include "conn.h"
typedef std::string String;
/**
* Alapobjektum.
* Absztrakt objektum a további osztályok származtatásához.
* Konstruktor paramétere, hogy hány kapcsolódási pontja van.
* Értékadás és a másoló konstruktor levédve, mert nincs értelme.
*/
class Obj {
String nev; ///< objektum neve
Pin nk; ///< kapcsolódási pontok száma
Conn *konn; ///< kapcsolatok leírása
Obj(const Obj&); ///< hogy ne lehessen használni
Obj& operator=(const Obj&); ///< hogy ne lehessen használni
public:
/// Nincs default konstruktor
/// @param n - objektum neve
/// @param k - kapcsolodási pontok (lábak) száma
Obj(const char *n, Pin k) :nev(n) {
konn = new Conn[nk = k];
}
/// Destruktor
virtual ~Obj() { delete[] konn; } ///< felszabadítjuk a konn tömböt
/// Név beállítása
/// @param n - objektum neve
void setNev(const char *n) { nev = n; }
/// Kapcsolatok felépítése (minden kapcsolat reflektív)
/// @param k - kapcsolat saját oldali pontja
/// @param o - o objektumhoz kapcsolódunk
/// @param ok - o objektum ezen pontjához
/// Hiba esetén "Conn hiba" kivételt dob
void setConn(Pin k, Obj &o, Pin ok); // kapcsolatok felépítése
/// Uzenet küldése egy kapcsolatra
/// @param k - kapcsolat saját oldali pontja
/// @param msg - üzenet
void uzen(Pin k, Message msg); // üzen a szomszédnak
/// Működést megvalósító virtuális függvény.
/// A beérkező üzenet és a saját állapota alapján ki kell számítania a választ.
/// @param k - kapcsolódási pontra üzenet érkezett
/// @param msg - beérkező üzenet
virtual void set(Pin k, Message msg) = 0;
};
#endif // OBJ_H
digit/r_s_ff.cpp 0 → 100644
/**
* \file r_s_ff.cpp
* R_S_FF osztály tagfüggvényinek megvalósítása
*/
#include "r_s_ff.h"
void R_S_FF::set(Pin n, Message msg) {
if (n < 2 && veg[n] != msg) { // ha input és változott
veg[n] = msg; // megjegyezi és a
N[n].set(1, msg); // megfelelő bemenetre küldi
uzen(2, veg[2] = N[0].get(2)); // kimenetek szétküldése
uzen(3, veg[3] = N[1].get(2)); // kimenetek szétküldése
}
}
digit/r_s_ff.h 0 → 100644
/**
* \file r_s_ff.h
* R_S_FF osztály deklarációja
*/
#ifndef R_S_FF_H
#define R_S_FF_H
#include "nand.h"
/**
* Inverz bemenetű S-R tároló.
* Négy kapcsolódási pontja van:
* 0 - S negált
* 1 - R negált
* 2 - Q
* 3 - Q negált
*/
class R_S_FF :public Obj {
protected:
Message veg[4]; ///< négy vége van
NAND N[2]; ///< két kapu a megvalósításhoz
public:
/// Ez a default konstruktor is
/// @param n - objektum neve (alapértelmezése "")
R_S_FF(const char *n = "ff") : Obj(n, 4) { // létrehoz egy 4 végű objektumot
N[0].setNev("n0");
N[1].setNev("n1");
N[0].setConn(2, N[1], 0); // összekötések megvalósítása
N[1].setConn(2, N[0], 0); }
/// Adott láb állapotának lekérdezése
void set(Pin n, Message msg); ///< működést megvalósító függvény
/// Működést megvalósító virtuális függvény.
/// A beérkező üzenet és a saját állapota alapján ki kell számítania a választ.
/// @param k - kapcsolódási pontra üzenet érkezett
/// @param msg - beérkező üzenet
const Message& get(Pin n) {
return(veg[n%4]);} ///< be/kimenet lekérdezése (bemenet is lekérdezhető,
///< debug célokra)
};
#endif // R_S_FF_H
virt_destruktor2/printm.h 0 → 100644
#ifndef _PRINTM_H
#define _PRINTM_H
#include <iomanip>
/**
* \file printm.h
*
* Kiírást segítő makrók
*/
/**
* Kicsit trükkös makró ami végrehajtás előtt kommnetként kiírja a paramétereit.
*/
#define _(...) std::cout << " // " << #__VA_ARGS__ << std::endl; \
__VA_ARGS__; \
/**
* _() hívása után soremelést ír;
*/
#define __(...) _(__VA_ARGS__); std::cout << std::endl;
/**
* soremelést ír;
*/
#define ___ std::cout << std::endl;
#endif // _PRINTM_H
virt_destruktor2/virt_destruktor2.cbp 0 → 100644
<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
<CodeBlocks_project_file>
<FileVersion major="1" minor="6" />
<Project>
<Option title="virt_destruktor2" />
<Option pch_mode="2" />
<Option compiler="gcc" />
<Build>
<Target title="Debug">
<Option output="bin/Debug/virt_destruktor22" 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/virt_destruktor2" 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-errors" />
<Add option="-std=c++11" />
<Add option="-Wall" />
<Add option="-Werror" />
<Add option="-DMEMTRACE" />
</Compiler>
<Unit filename="printm.h" />
<Unit filename="virt_destruktor2.cpp" />
<Extensions>
<code_completion />
<envvars />
<debugger />
<lib_finder disable_auto="1" />
</Extensions>
</Project>
</CodeBlocks_project_file>
virt_destruktor2/virt_destruktor2.cpp 0 → 100644
/**
* \file virt_destruktor2.cpp
*
* \par Demonstrációs cél:
* Virtuális függvények és virt. destruktor különbözőségének bemutatása.
*
* Event destruktora virtuális, ezért Event1 destruktora indul be.
* Event1 destruktor lefutása után Event destruktora mindenképpen lefut,
* mivel ennek a feladata a takarítás.
*
* Show esetében csak a származtatott Show fut. Amennyiben ez nem hívja
* explicit az ős Show tagfüggvényét, akkor az nem fut le.
*
*/
#include <iostream>
#include "printm.h"
using std::cout;
using std::endl;
using std::cin;
void msg(const char *txt) {
cout << txt << endl;
}
struct Event {
Event() { msg("ctor: Event"); }
virtual void show() { msg("show: Event"); }
virtual ~Event() { msg("dtor: Event"); }
void f() { msg("f: Event"); }
};
class Event1 :public Event {
int *p;
public:
Event1(int s) {
msg("ctor: Event1");
p = new int[s];
}
void show() { msg("show: Event1"); }
void f() { msg("f: Event1"); }
~Event1() {
msg("dtor: Event1");
delete[] p;
}
};
int main() {
{ /// nyitunk egy blokkot
_( Event1 e1(2); )
_( e1.f(); )
_( e1.Event::f(); )
} /// blokk vége itt lefut a destruktor
cin.ignore(1);
_( Event *ep = new Event1(120); )
_( ep->show(); )
_( ep->f(); )
_( ep->Event::f(); )
_( delete ep; )
}
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