Klassen so o.k.?

Ist der Entwurf so o.k.?

#include <iostream>
using namespace std;

class Lampe
{   
    private:
        bool ist_eingeschaltet_;
        int helligkeit_;

    public:
        Lampe() : ist_eingeschaltet_(false), helligkeit_(0){}

        void setEin(bool wert)    
        {
            ist_eingeschaltet_ = wert;
        }    

        void dimmen(int wert)
        {
            helligkeit_ = wert;
        }

        bool getEin() const {return ist_eingeschaltet_;}
        int  getHelligkeit() const {return helligkeit_;}
};

class Schalter
{   
    private:
        bool ein_;

    public:
        Schalter() : ein_(false){}    
        void schalten()    
        {
            ein_ = !ein_;
        }
        bool getEin() const {return ein_;}  
};

class Beleuchtung
{
    private:
        Schalter s_;
        Lampe l_;

    public:
        Beleuchtung(Schalter s, Lampe l) : s_(s),l_(l){}

        void schalten()
        {
            s_.schalten();
            if(s_.getEin())
            {
                  l_.setEin(true);
                  l_.dimmen(100);
            }    
            else 
            {
                  l_.setEin(false);                                           
                  l_.dimmen(0);
            }    
        }

        void status() const
        {
            cout << "Schalter: "   << (s_.getEin()?"an ":"aus") << "  " 
                 << "Lampe: "      << (l_.getEin()?"an ":"aus") << " "
                 << "Helligkeit: " << l_.getHelligkeit() << endl;      
        }    
};    

int main()
{
    Lampe l1;
    Schalter s1;
    Beleuchtung b1(s1,l1);
    for(int i=0; i<10; ++i)
    {
        b1.status();
        b1.schalten();
    }    
}

CarstenJ

Hallo,

naja, irgendwie versteh ich den Zusammenhang nicht so ganz. Da ist ein Schalter, eine Lampe und die Beleuchtung.

Ich würde erstmal vorschlagen, dass die Lampe einen Schalter hat. Und Beleuchtung würde ich nicht als Klasse implementieren, sondern eher Leuchten nennen und als Methode von Lampe implementieren.

Aber jetzt muss ich erstmal auf Kirmes...

Eine Beleuchtung z.B. eines Raumes kann aus mehreren Lampen bestehen. Diese Lampen können von 1 ... n Schalter geschaltet werden (Ein/Aus, Wechselschaltung, Kreuzschaltung, später noch Dimmer). Daher dieser erste Ansatz.

Ist das mit der Komposition so richtig? Besser andere Variante (Zeiger, Referenz)?

otze

du willst den schalter dazu benutzen, eine lampe an oder aus zu machen, daran is erstmal nichts auszusetzen.
das problem fängt an der stelle an, wo du der lampe nich nur an/aus spendierst, sondern zustzlich auch noch dimmen.
ein schalter dimmt die lampe, nicht die lampe selber.
dh du musst dimmen in schalter implementieren, was aber auch nur geht, wenn schalter ein dimmer ist, und ein dimmer kann kein an /aus haben.

und deshalb ist schalter ausserhalb besser untergebracht, da der schalter die lampe verändert, und nicht umgekehrt(in dem fall könnte man schon sagen: der schalter hat eine lampe, aber das hört sich komisch an^^)

Im einfachsten Fall hat eine Lampe einen Schalter, es können aber auch mehrere sein (Wechselschaltung: 2, Kreuzschaltung: >2). Ein Schalter kann evtl. auch mehrere Lampen schalten. Eine Beleuchtung z.B. eines Raumes kann aus 1 ... n Lampen sowie 1 ... n Schalter bestehen, die verschieden miteinander wechselwirken können. Das mit dem Dimmen ist kein Problem, da kann man bool ist_eingeschaltet_ auch völlig streichen und nur int helligkeit_ verwenden. Bei 0 ist dann die Lampe aus, dann gibt es einen Schwellenwert für die Dimmung und der Endwert ist einfach 100 (%).

Wie würdet ihr den Zusammenhang Lampe und Schalter bilden eine Beleuchtung darstellen? Innerhalb Beleuchtung als member, zeiger, referenz? ... oder ganz anders?

elise

ein wenig erscheint es mir sehr statisch.

beleuchtung hängt von einem schalter und von einer lampe ab.

wie wärs mit einer dynamischeren variante? ein größenmäßig dynamisch hergestelltes array von schaltern und lampen (konstanten in der initialisierungsliste mit wert belegen) und im konstruktor die jeweiligen lampen und schalter auf dem freispeicher allozieren?
aber ich kenne micht in beleuchtungsfragen nicht sonderlich aus...
/me schaut grad etwas mitleidig auf ihre hüllenlose nachttischlampe neben dem schreibtisch...

Ich habe mal eine Komposition aus einer Lampe und zwei Wechselschaltern (als vector) gebaut:

#include <iostream>
#include <vector>
using namespace std;

class Lampe
{   
    private:
        int helligkeit_;

    public:
        Lampe() : helligkeit_(0){}

        void dimmen(int wert)
        {
            helligkeit_ = wert;
        }

        bool getEin() const {return getHelligkeit();}
        int  getHelligkeit() const {return helligkeit_;}
};

class Schalter
{   
    private:
        bool ein_;

    public:
        Schalter() : ein_(false){}    
        void schalten()    
        {
            ein_ = !ein_;
        }
        bool getEin() const {return ein_;}  
};

class Beleuchtung
{
    private:
        vector<Schalter> v_;
        Lampe l_;

    public:
        Beleuchtung( vector<Schalter> v, Lampe l ) : v_(v),l_(l){}

        void schalten(int i)
        {
            v_[i].schalten();
            if(v_[0].getEin() != v_[1].getEin()  )
                l_.dimmen(100);
            else 
                l_.dimmen(0);
        }

        void status() const
        {
            cout << "Schalter1: "   << (v_[0].getEin()?"an ":"aus") << "  " 
                 << "Schalter2: "   << (v_[1].getEin()?"an ":"aus") << "  "
                 << "Lampe: "      << (l_.getEin()?"an ":"aus") << " "
                 << "Helligkeit: " << l_.getHelligkeit() << endl;      
        }    
};    

int main()
{
    Lampe l1;
    Schalter s1,s2;
    vector<Schalter> v;
    v.push_back(s1);
    v.push_back(s2); 
    Beleuchtung b1(v,l1);
    for(int i=0; i<3; ++i)
    {
        b1.status();
        b1.schalten(0);
        b1.status();
        b1.schalten(1);
    }    
}

Erhard Henkes

http://www.b.shuttle.de/b/humboldt-os/hst/unter/mathnat/tun/tun_html_2002/tun_ri/schueler/wechselschaltung.html

daher korrekter:

if(v_[0].getEin() == v_[1].getEin()  )

for(int i=0; i<3; ++i)
    {
        b1.schalten(0);
        b1.status();
        b1.schalten(1);
        b1.status();
    }

Hier würde auch ein statisches Array gehen.

Für die Kreuzschaltung könnte man es wie folgt realisieren (2 Wechselschalter mit einem Kreuzschalter in der Mitte, mehr als 3 macht keinen Sinn, dann Relaisschaltung):

//...

class Beleuchtung // 2 Wechsel-, ein Kruezschalter
{
    private:
        vector<Schalter> v_;
        Lampe l_;

    public:
        Beleuchtung( vector<Schalter> v, Lampe l ) : v_(v),l_(l){}

        void schalten(int i)
        {
            v_[i].schalten();
            if( 
                (  v_[0].getEin() &&  v_[1].getEin() &&  v_[2].getEin() )   ||
                (  v_[0].getEin() && !v_[1].getEin() && !v_[2].getEin() )   ||
                ( !v_[0].getEin() &&  v_[1].getEin() && !v_[2].getEin() )   ||
                ( !v_[0].getEin() && !v_[1].getEin() &&  v_[2].getEin() )   
              )
                l_.dimmen(100);
            else 
                l_.dimmen(0);
        }

        void status() const
        {
            cout << "S1: "   << (v_[0].getEin()?"an ":"aus") << "  " 
                 << "S2: "   << (v_[1].getEin()?"gerade  ":"gekreuzt") << "  "
                 << "S3: "   << (v_[2].getEin()?"an ":"aus") << "  " 
                 << "Lampe: "      << (l_.getEin()?"an ":"aus") << " "
                 << "Helligkeit: " << l_.getHelligkeit() << endl;      
        }    
};    

int main()
{
    Lampe l1;
    Schalter s1,s2,s3;
    vector<Schalter> v;
    v.push_back(s1);
    v.push_back(s2); 
    v.push_back(s3); 
    Beleuchtung b1(v,l1);
    for(int i=0; i<3; ++i)
    {
        b1.schalten(0);
        b1.status();
        b1.schalten(1);
        b1.status();
        b1.schalten(2);
        b1.status();
    }    
}

Hier bietet sich evtl. auch an zwei Typen von Schaltern zu schaffen: Wechsel- und Kreuzschalter. Interessantes Thema. Ist das bisher nirgends als C++-Beispiel verarbeitet?

CarstenJ

otze schrieb:

ein schalter dimmt die lampe, nicht die lampe selber.

Versteh ich nicht.

otze

CarstenJ schrieb:

otze schrieb:

ein schalter dimmt die lampe, nicht die lampe selber.

Versteh ich nicht.

packn dimmer ans lampenkabel und dreh ihn, der dimmer erhöht den wiederstand, die lampe leuchtet nicht mehr so stark.
physik 6. klasse wenn ich mich recht entsinne^^

der dimmer erhöht den wiederstand, die lampe leuchtet nicht mehr so stark.

Bei einem einfachen regelbaren Widerstand (nicht: wiederstand !!!) würde die Leistung, die der Lampe nicht zugeführt wird, am Widerstand unnütz verbraucht werden und außerdem zu einer sehr starken Erzitzung führen. Um dies zu verhindern, wird beim Dimmen die Last (hier: Lampe) blitzschnell an- und ausgeschaltet. Das Verhältnis der Einschaltdauer zur Ausschaltdauer bestimmt die Ausgangsspannung bzw. die Lampenhelligkeit. Durch das Schalten entstehen nahezu keine Verluste mehr im Dimmer.

Bei der Phasenanschnitt-Technik werden als Leistungsschalter Triacs oder Thyristoren verwendet.

Bei der Phasenabschnitt-Technik werden als Leistungsschalter Transistoren oder IGBTs verwendet.

Eher Oberstufe!

otze

ich hatte vor kurzem nochn schönen dimmer nach dem alten prinzip in der Hand^^

CarstenJ

physik 6. klasse wenn ich mich recht entsinne^^

Das ist bei mir leider schon nen Weilchen her. Außerdem fand ich nur deine Formulierung seltsam. Mittlerweile kam aber Licht. :p