SHARE
TWEET

Untitled

a guest Apr 24th, 2019 105 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. Main:
  2.  
  3. #include <cstdio>
  4. #include <cstdlib>
  5. #include <string.h>
  6. #include <cstring>
  7. #include "schnittstelle.h"
  8. #include "baustein.h"
  9. #include "oder2.h"
  10. #include "und2.h"
  11. #include "xor2.h"
  12. #include "halbaddierer.h"
  13. #include "Volladdierer.h"
  14.  
  15.  
  16. void test2(Baustein* b) {
  17.  
  18.     b->eingang[0]->setPegel(0);
  19.     b->eingang[1]->setPegel(1);
  20.     b->update;
  21.     b->print;
  22.  
  23.     b->eingang[0]->setPegel(1);
  24.     b->eingang[1]->setPegel(0);
  25.     b->update;
  26.     b->print;
  27.  
  28.     b->eingang[0]->setPegel(1);
  29.     b->eingang[1]->setPegel(1);
  30.     b->update;
  31.     b->print;
  32.  
  33.     b->eingang[0]->setPegel(0);
  34.     b->eingang[1]->setPegel(0);
  35.     b->update;
  36.     b->print;
  37.  
  38.  
  39. }
  40.  
  41. int main() {
  42.  
  43.     Schnittstelle* e0 = new Schnittstelle;
  44.     Schnittstelle* e1 = new Schnittstelle;
  45.     Schnittstelle* e2 = new Schnittstelle;
  46.     Schnittstelle* a0 = new Schnittstelle;
  47.     Schnittstelle* a1 = new Schnittstelle;
  48.  
  49.     Baustein* test = new Und2(e0, e1, a0);
  50.  
  51.     test2(test);
  52.  
  53.     Halbaddierer* testHA = new Halbaddierer(e0, e1, a0, a1);
  54.  
  55.     test2(testHA);
  56.  
  57.     getchar();
  58.     getchar();
  59.  
  60.     return 0;
  61. }
  62.  
  63.  
  64. Volladdierer:
  65. #pragma once
  66. #include <cstdio>
  67. #include <cstdlib>
  68. #include <iostream>
  69. #include <cstring>
  70. #include <vector>
  71. #include "schnittstelle.h"
  72. #include "oder2.h"
  73. #include "und2.h"
  74. #include "schaltung.h"
  75. #include "halbaddierer.h"
  76.  
  77. class Volladdierer : public Schaltung {
  78.  
  79. public:
  80.  
  81.     Volladdierer(Schnittstelle* e0, Schnittstelle* e1, Schnittstelle* e2, Schnittstelle* a0, Schnittstelle* a1) {
  82.  
  83.         addEingang(e0); //Funktion zum einfügen in einen eingangsvektor, warum??
  84.         addEingang(e1);
  85.         addEingang(e2);
  86.         addAusgang(a0);
  87.         addAusgang(a1);
  88.  
  89.         Schnittstelle* i0 = new Schnittstelle;
  90.         Schnittstelle* i1 = new Schnittstelle;
  91.         Schnittstelle* i2 = new Schnittstelle;
  92.  
  93.         intern.push_back(i0);
  94.         intern.push_back(i1);
  95.         intern.push_back(i2);
  96.  
  97.         Halbaddierer* HA0 = new Halbaddierer(e0, e1, i0, i1);
  98.         Halbaddierer* HA1 = new Halbaddierer(i1, e2, i2, a0);
  99.  
  100.         Oder2* oder2 = new Oder2(i0, i2, a1);
  101.  
  102.         bausteine.push_back(HA0);
  103.         bausteine.push_back(HA1);
  104.         bausteine.push_back(oder2);
  105.                      
  106.         name = "Volladdierer";
  107.     }
  108.  
  109.     void update() {
  110.  
  111.         for (int x = 0; x < bausteine.size; x++) {
  112.             bausteine[x]->update;
  113.         }
  114.     }
  115. };
  116.  
  117. Halbaddierer:
  118.  
  119. #pragma once
  120. #include <cstdio>
  121. #include <cstdlib>
  122. #include <iostream>
  123. #include <cstring>
  124. #include "schnittstelle.h"
  125. #include "und2.h"
  126. #include "xor2.h"
  127. #include "schaltung.h"
  128.  
  129. class Halbaddierer : public Schaltung {
  130.  
  131. public:
  132.  
  133.     Halbaddierer(Schnittstelle* e0, Schnittstelle* e1, Schnittstelle* a0, Schnittstelle* a1) {
  134.  
  135.         addEingang(e0); //Funktion zum einfügen in einen eingangsvektor, warum??
  136.         addEingang(e1);
  137.         addAusgang(a0);
  138.         addAusgang(a1);
  139.  
  140.         Xor2* xor2 = new Xor2(e0, e1, a0);
  141.  
  142.         bausteine.push_back(xor2);
  143.  
  144.  
  145.         Und2* und2 = new Und2(e0, e1, a1);
  146.  
  147.         bausteine.push_back(und2);
  148.  
  149.         name = "Halbaddierer";
  150.     }
  151.  
  152.  
  153.     void update() {
  154.  
  155.         for (int x = 0; x < bausteine.size; x++) {
  156.             bausteine[x]->update;
  157.         }
  158.     }
  159. };
  160.  
  161.  
  162. Schaltung:
  163.  
  164. #pragma once
  165. #include <cstdio>
  166. #include <cstdlib>
  167. #include <iostream>
  168. #include <string.h>
  169. #include <cstring>
  170. #include "schnittstelle.h"
  171. #include "baustein.h"
  172.  
  173. using namespace std;
  174. class Schaltung : public Baustein {
  175.  
  176. protected:
  177.     vector <Schnittstelle*> intern;
  178.     vector <Baustein*> bausteine;
  179. };
  180.  
  181.  
  182. Baustein:
  183.  
  184. #pragma once
  185.  
  186. #include <cstdio>
  187. #include <cstdlib>
  188. #include <iostream>
  189. #include <string>
  190. #include <cstring>
  191. #include <vector>
  192. #include "schnittstelle.h"
  193.  
  194. using namespace std;
  195.  
  196. class Baustein {
  197.  
  198. protected:
  199.  
  200.     string name;
  201.     vector <Schnittstelle*> eingang;
  202.     vector <Schnittstelle*> ausgang;
  203.  
  204. public:
  205.  
  206.     void addEingang(Schnittstelle* schnittstelle) {
  207.         eingang.push_back(schnittstelle);
  208.     }
  209.  
  210.     void addAusgang(Schnittstelle* schnittstelle) {
  211.         ausgang.push_back(schnittstelle);
  212.     }
  213.  
  214.     virtual void print() {
  215.  
  216.         cout << "Baustein: " << name << endl;
  217.  
  218.         for (int i = 0; i < eingang.size(); i++) {
  219.             cout << "Eingang " << i << ":" << "Pegel = " << eingang[i]->getPegel << endl;
  220.         }
  221.  
  222.         for (int i = 0; i < ausgang.size(); i++) {
  223.             cout << "Ausgang " << i << ":" << "Pegel = " << ausgang[i]->getPegel << endl;
  224.         }
  225.     }
  226.  
  227.     virtual void update() = 0;
  228.     friend void test2(Baustein* b);
  229. };
  230.  
  231.  
  232. xor2:
  233.  
  234. #pragma once
  235.  
  236. #include <cstdio>
  237. #include <cstdlib>
  238. #include <iostream>
  239. #include <cstring>
  240. #include "schnittstelle.h"
  241. #include "baustein.h"
  242.  
  243.  
  244.  
  245. using namespace std;
  246.  
  247. class Xor2 : public Baustein {
  248.  
  249. public:
  250.  
  251.     Xor2(Schnittstelle* e0, Schnittstelle* e1, Schnittstelle* a0) {
  252.  
  253.         name = "Xor2";
  254.         addEingang(e0);
  255.         addEingang(e1);
  256.         addAusgang(a0);
  257.  
  258.     }
  259.  
  260.  
  261.     void update() {
  262.  
  263.         if (eingang[0]->getPegel == Schnittstelle::LOW && eingang[1]->getPegel == Schnittstelle::LOW || eingang[0]->getPegel==      Schnittstelle::HIGH && eingang[1]->getPegel == Schnittstelle::HIGH) {
  264.             ausgang[0]->setPegel(Schnittstelle::LOW);
  265.         }
  266.         else if (eingang[0]->getPegel == Schnittstelle::HIGH && eingang[1]->getPegel == Schnittstelle::LOW || eingang[0]->getPegel == Schnittstelle::LOW && eingang[1]->getPegel == Schnittstelle::HIGH) {
  267.             ausgang[0]->setPegel(Schnittstelle::HIGH);
  268.         }
  269.         else if (eingang[0]->getPegel == Schnittstelle::UNDEFINED || eingang[1]->getPegel == Schnittstelle::UNDEFINED) {
  270.             ausgang[0]->setPegel(Schnittstelle::UNDEFINED);
  271.         }
  272.     }
  273. };
  274.  
  275.  
  276. Und2:
  277.  
  278. #pragma once
  279.  
  280. #include <cstdio>
  281. #include <cstdlib>
  282. #include <iostream>
  283. #include <cstring>
  284. #include "schnittstelle.h"
  285. #include "baustein.h"
  286.  
  287.  
  288. using namespace std;
  289.  
  290. class Und2 : public Baustein {
  291.  
  292. public:
  293.  
  294.     Und2(Schnittstelle* e0, Schnittstelle* e1, Schnittstelle* a0) {
  295.  
  296.         name = "Und2";
  297.         addEingang(e0);
  298.         addEingang(e1);
  299.         addAusgang(a0);
  300.  
  301.     }
  302.  
  303.     void update() {
  304.  
  305.         if (eingang[0]->getPegel == Schnittstelle::LOW && eingang[1]->getPegel == Schnittstelle::LOW || eingang[0]->getPegel == Schnittstelle::HIGH && eingang[1]->getPegel == Schnittstelle::LOW || eingang[0]->getPegel == Schnittstelle::LOW && eingang[1]->getPegel == Schnittstelle::HIGH) {
  306.             ausgang[0]->setPegel(Schnittstelle::LOW);
  307.         }
  308.         else if (eingang[0]->getPegel == Schnittstelle::HIGH && eingang[1]->getPegel == Schnittstelle::HIGH) {
  309.             ausgang[0]->setPegel(Schnittstelle::HIGH);
  310.         }
  311.         else if (eingang[0]->getPegel == Schnittstelle::UNDEFINED || eingang[1]->getPegel == Schnittstelle::UNDEFINED) {
  312.             ausgang[0]->setPegel(Schnittstelle::UNDEFINED);
  313.         }
  314.     }
  315. };
  316.  
  317.  
  318. Oder2:
  319.  
  320. #pragma once
  321. #include <cstdio>
  322. #include <cstdlib>
  323. #include <iostream>
  324. #include <cstring>
  325. #include "schnittstelle.h"
  326. #include "baustein.h"
  327.  
  328.  
  329. using namespace std;
  330.  
  331. class Oder2: public Baustein {
  332.  
  333. public:
  334.  
  335.     Oder2(Schnittstelle* e0, Schnittstelle* e1, Schnittstelle* a0) {
  336.  
  337.         name = "Oder2";
  338.         addEingang(e0);
  339.         addEingang(e1);
  340.         addAusgang(a0);
  341.  
  342.     }
  343.  
  344.     void update() {
  345.  
  346.         if (eingang[0]->getPegel == Schnittstelle::LOW && eingang[1]->getPegel == Schnittstelle::LOW) {
  347.             ausgang[0]->setPegel(Schnittstelle::LOW);
  348.         }
  349.         else if (eingang[0]->getPegel == Schnittstelle::HIGH && eingang[1]->getPegel == Schnittstelle::LOW || eingang[0]->getPegel == Schnittstelle::LOW && eingang[1]->getPegel == Schnittstelle::HIGH || eingang[0]->getPegel == Schnittstelle::HIGH && eingang[1]->getPegel == Schnittstelle::HIGH) {
  350.             ausgang[0]->setPegel(Schnittstelle::HIGH);
  351.         }
  352.         else if (eingang[0]->getPegel == Schnittstelle::UNDEFINED || eingang[1]->getPegel == Schnittstelle::UNDEFINED) {
  353.             ausgang[0]->setPegel(Schnittstelle::UNDEFINED);
  354.         }
  355.     }
  356. };
  357.  
  358.  
  359. Schnittstelle:
  360.  
  361. #pragma once
  362.  
  363.  
  364. #include <cstdio>
  365. #include <cstdlib>
  366. #include <cstring>
  367.  
  368.  
  369. using namespace std;
  370.  
  371. class Schnittstelle {
  372.  
  373.  
  374. private:
  375.  
  376.     short pegel = 0;
  377.  
  378.  
  379. public:
  380.  
  381.     const static short HIGH = 1;
  382.     const static short LOW = 0;
  383.     const static short UNDEFINED = -1;
  384.  
  385.  
  386.  
  387.     short getPegel() {
  388.         return pegel;
  389.     }
  390.  
  391.     bool setPegel(short a) {
  392.  
  393.         if (a == HIGH || a == LOW) {
  394.             pegel = a;
  395.             return true;
  396.         } else {
  397.             a = UNDEFINED;
  398.             return false;
  399.         }
  400.     }
  401. };
RAW Paste Data
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy. OK, I Understand
 
Top