Problem mit Hausaufgabe OOP

Diese Seite verwendet Cookies. Durch die Nutzung unserer Seite erklären Sie sich damit einverstanden, dass wir Cookies setzen. Weitere Informationen

  • Problem mit Hausaufgabe OOP

    Hallo Leute,
    ich habe die Aufgabe, einen 4 Bit Synchronzähler in C++ zu programmieren. Dafür haben wir vom Prof Programmfragmente vorgegeben bekommen und sollen das fertig programmieren. Aber ich komm einfach nicht weiter und langsam wird die Zeit knapp. Ich hoffe mir kann jemand helfen.

    Mit dieser main

    Quellcode

    1. int main(int argc, char *argv[])
    2. {
    3. Schaltung zaehler;
    4. And x;
    5. zaehler.add (& x);
    6. zaehler.add (& x);
    7. zaehler.verbinde( &zaehler.s[0].ausgang.[0],& zaehler.s[1].eingang[0]); //Hierfür ist die Fehlermeldung
    8. system("PAUSE");
    9. return EXIT_SUCCESS;


    bekomme ich ich die Meldung
    ...Schaltung::s' is private within this context

    Dann habe ich das erst mal Public gemacht, obwohl das so in der Vorgabe nicht gedacht ist. (Ich weiß allerdings auch nicht wie ich sonst die Verbindungspunkte für die Schaltelemente angeben soll...) Jetzt bleibt noch die Felermeldung
    `ausgang' has not been declared
    Aber in der Klasse Schaltelement gibt es ja den Vektor ausgang (mit eingang natürlich das gleiche) Aber warum greift er darauf mit den angegebenen Parametern nicht zu? Und gibt es eine andere Möglichkeit, so dass ich die Vektoren wieder Private machen kann?

    Bin dankbar für jeden Tipp

    edit: Habe vergessen zu sagen dass ich Dev C++ benutze.

    Hier noch die zugehörigen Klassen: (Sind noch nicht richtig fertig und ich erwarte auch nicht dass sich jemand das alles durchliest, aber ich denke ohne die ist das wohl nicht nachvollziehbar...)

    Quellcode

    1. //Abstrakte Oberklasse zu Schaltnetz und Schaltwerk
    2. class Schaltelement
    3. {public:
    4. vector <int> ausgang; // fuer die Ausgaenge
    5. vector <int> eingang; // fuer die Eingaenge
    6. virtual void takt( ) = 0; // Funktion zum Takten der Schaltwerke
    7. virtual void logfkt( ) = 0; // Funktion zum Berechnen der Schaltnetze
    8. friend ostream& operator<< ( ostream&, Schaltelement* );
    10. class Verbindung // fuer die einzelne Verbindung
    11. { int *von, *zu;
    12. public:
    13. Verbindung ( int & v, int & z );
    14. // Konstruktor mit Initialisierungsliste
    15. void uebernehmen( );
    16. // Wert des Ausgangs von als Wert fuer den Eingang zu uebernehmen
    17. };
    19. Verbindung::Verbindung( int & v, int & z)
    20. {
    21. *von=v;
    22. *zu=z;
    23. }
    26. void Verbindung::uebernehmen()
    27. {
    28. // *z.eingang(0)=*v.ausgang(0);
    30. }
    32. //Abstrakte Oberklasse zu Schaltnetzen wie And, Or, Nand,
    33. //ALU, (De)Multiplexer usw.
    34. class Schaltnetz: public Schaltelement
    35. {protected:
    36. virtual void takt() { } // Keine Wirkung bei Schaltnetzen
    37. virtual void logfkt( )=0;
    38. public:
    39. Schaltnetz() { /*netztiefe++;*/ }
    40. };
    42. // Abstrakte Oberklasse zu getakteten Schaltwerken
    43. // wie Flipflop, Register, Zaehler
    44. class Schaltwerk: public Schaltelement
    45. {protected:
    46. virtual void takt()=0;
    47. virtual void logfkt( ) { } // Keine Wirkung bei Schaltwerken
    48. };
    50. // Von Schaltnetz abgeleitete konkrete Klasse And
    51. class And: public Schaltnetz // Fuer AND-Gatter mit n Eingaengen
    52. {public:
    53. And( int n=2 ) // Konstruktor, n = Anzahl der Eingaenge
    54. { for ( int i=0; i<n; i++ ) eingang.push_back( high ); // Alle Eingaenge=1
    55. ausgang.push_back( high );
    56. }
    57. void logfkt ( ) // Die Funktion des And-Gatters
    58. { int h = high;
    59. for ( int i=0; i<eingang.size(); i++ ) h = h && eingang[i];
    60. ausgang[0] = h;
    61. }
    62. };
    65. // Von Schaltwerk abgeleitete konkrete Klasse Flipflop
    66. class Flipflop: public Schaltwerk
    67. {
    68. public:
    69. Flipflop( ) // Konstruktor
    70. {
    71. eingang.push_back( low );
    72. eingang.push_back( low );
    73. eingang.push_back( low );
    74. ausgang.push_back( low );
    75. ausgang.push_back( high ); //komplementärer ausgang
    76. }
    77. void takt ( ) // Die Funktion des Flipflops
    78. {
    79. ausgang[0]=eingang[0]^ausgang[0];
    80. ausgang[1]=!ausgang[0];
    81. }
    82. };
    84. class Schaltung
    85. {public:
    86. vector <Verbindung> v; // Verbindungen von <-> zu
    87. vector <Schaltelement*> s; // Schaltelemente
    88. public:
    89. void add ( Schaltelement * se );
    90. void verbinde ( int & von, int & zu );
    91. // Erzeugt ein neues Verbindung-Objekt und fuegt es an v an.
    92. void berechne ( );
    93. // Ausgangswerte übernehmen
    94. // Schaltnetze wiederholt (bis zur Schaltnetztiefe) neu berechnen
    95. // Ausgangswerte übernehmen
    96. // Schaltwerke takten
    97. };
    99. void Schaltung::add (Schaltelement * se)
    100. {
    101. s.push_back (se);
    102. }
    104. void Schaltung::verbinde ( int & von, int & zu )
    105. {
    106. v.push_back (Verbindung(von,zu));
    107. }
    Alles anzeigen