Herzlich Willkommen, lieber Gast!
  Sie befinden sich hier:

  Forum » C / C++ (ANSI-Standard) » HILFE....Ampel Programm

Forum | Hilfe | Team | Links | Impressum | > Suche < | Mitglieder | Registrieren | Einloggen
  Quicklinks: MSDN-Online || STL || clib Reference Grundlagen || Literatur || E-Books || Zubehör || > F.A.Q. < || Downloads   

Autor Thread - Seiten: > 1 <
000
30.04.2004, 08:46 Uhr
Andi



Hi, ich habe ein Problem!
Ich muss für die schule ein Ampel Programm schreiben, wo man einfach eine Ampel sieht, die die 3 Phasen durchschaltet (von Rot nach grün ). Und muss dieses am 3.05.2004 abgeben. Da ich aber überhaupt keine Ahnung davon habe, und mir auch keiner Wirklich helfen kann, habe ich ein echtes Problem. Darum Wende ich mich an euch, ob ihr mir evtl. helfen könnt!


MFG

Andi
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
001
30.04.2004, 11:45 Uhr
virtual
Sexiest Bit alive
(Operator)


Dein Ansatz?
--
Gruß, virtual
Quote of the Month
Ich eß' nur was ein Gesicht hat (Creme 21)
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
002
30.04.2004, 12:04 Uhr
Windalf
Der wo fast so viele Posts wie FloSoft...
(Operator)


@virtual
Ich hoffe du nimmst es mir nicht übel aber ich werd ihm mal ein ansatz geben...


@Andi
übrigens eine ampel hat 4 Phasen

grün nach gelb nach rot nach rot-gelb usw...

wie man unschwer erkennt brauch man 4 zustände. du musst dir also nur eine variable nehmen die 4 verschiedene zustände speichern kann (und da kommt so ziemlich alles (von bool mal abgesehen) in frage.

du könntest z.b. definieren


C++:
int ampelstatus; //0 ist grün 1 ,ist gelb 2 ist rot und 3 ist rot-gelb



jetzt musst du nur noch die zustände nacheinander durchschalten.
du willst ja das er von 0 nach 1 geht dann nach 2 dann nach 3 und dann wieder nach null.... dies kannst du mittels einer modulooperation erreichen

du musst also bei jedem schritt nur die variable um 1 erhöhen und dann ein modulo 4 drauf machen....

so wenn du jetzt noch hilfe willst bring mal ein eigenes stück code oder frag mal konkreter was dein problem ist, die komplette lösung schieben wir dir nicht in den arsch... und das wochenende ist ja lang genug das du das hinbekommen solltest.
--
...fleißig wie zwei Weißbrote
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
003
30.04.2004, 15:58 Uhr
Spacelord
Hoffnungsloser Fall


Hi,
hier ist ne Java Lösung.


Code:

import java.awt.*;
import java.awt.event.*;
import java.util.*;

///////////////////////Event Klasse//////////////////////////////
class AmpelEvent extends EventObject
{
     public AmpelEvent(Object source)
     {
         super(source);
     }
}

/////////////////Ampel Listener Schnittstelle ////////////////////
interface AmpelListener extends EventListener
{
public void gruen(AmpelEvent e);
public void gelb(AmpelEvent e);
public void rot(AmpelEvent e);
public void rot_gelb(AmpelEvent e);
}


//Hauptklasse
public class Ampelsteuerung extends Frame
{
private int schaltung;//speichert den Status und wird in der
                       //paint Methode zum neuzeichnen benoetigt

/////////////////////Ampelklasse///////////////////////////////
class Ampel extends Canvas implements  AmpelListener
{
    

  /////////////Implementierung von AmpelListener//////////////////
  public void gruen(AmpelEvent e)
  {
    schaltung=0;
     paint(getGraphics());
  }
  public void gelb(AmpelEvent e)
  {
     schaltung=1;
    paint(getGraphics());
  }
  public void rot(AmpelEvent e)
  {
    schaltung=2;
    paint(getGraphics());
  }
  public void rot_gelb(AmpelEvent e)
  {
    schaltung=3;
    paint(getGraphics());
  }
//////////////////////////////////////////////////////////////////

  Ampel()
  {
      schaltung= -1;//Ampel aus
      this.setSize(150,280);
  }
  public void ampelAus(Graphics g)
  {
    g.setColor(Color.gray);
       g.drawRoundRect(50,20,50,50,90,90);
     g.fillRoundRect(50,20,50,50,90,90);
     g.drawRoundRect(50,75,50,50,90,90);
    g.fillRoundRect(50,75,50,50,90,90);
     g.drawRoundRect(50,130,50,50,90,90);
     g.fillRoundRect(50,130,50,50,90,90);
  }
  
  //Zum Neuzeichnen noetig
  public void paint(Graphics g)
  {
      switch(schaltung)
      {
          case -1:
             ampelAus(g);
             break;
          case 0:   //Ampel gruen
              ampelAus(g);
              g.setColor(Color.green);
             g.fillRoundRect(50,130,50,50,90,90);
             break;
         case 1:   //Ampel gelb
            ampelAus(g);
              g.setColor(Color.yellow);
             g.fillRoundRect(50,75,50,50,90,90);
             break;
         case 2:  //Ampel rot
             ampelAus(g);
              g.setColor(Color.red);
             g.fillRoundRect(50,20,50,50,90,90);
             break;
         case 3 : //Ampel gelb-rot
             ampelAus(g);
              g.setColor(Color.red);
             g.fillRoundRect(50,20,50,50,90,90);
             g.setColor(Color.yellow);
            g.fillRoundRect(50,75,50,50,90,90);
             break;
         default:{}
     }
  }
}

///////////////////////Ampelzustandsklasse///////////////////////
class Ampelzustand extends Button
{
     private Vector myAmpelListeners;
     private int state=1;
     private int nextState()
     {
         state=(state+1)%4;
         switch (state)
         {
             case 0: fireRot(new AmpelEvent(this));
                     break;
             case 1: fireRot_Gelb(new AmpelEvent(this));
                     break;
             case 2: fireGruen(new AmpelEvent(this));
                     break;
             case 3: fireGelb(new AmpelEvent(this));
                     break;
             default:{}
         }
           return state;
    }
    public synchronized void addAmpelListener(AmpelListener l)
    {
      Vector v=myAmpelListeners==null?new Vector(2):
             (Vector)myAmpelListeners.clone();
      if(!v.contains(l))
      {
          v.addElement(l);
          myAmpelListeners=v;
      }
     }
    
     public synchronized void removeAmpelListener(AmpelListener l)
     {
         if(myAmpelListeners!=null&&myAmpelListeners.contains(l))
         {
             Vector v=(Vector)myAmpelListeners.clone();
             v.removeElement(l);
             myAmpelListeners=v;
         }
      }

      protected void fireRot(AmpelEvent e)
      {
          if(myAmpelListeners!=null)
          {
              Vector listeners =myAmpelListeners;
              int count=listeners.size();
              for(int i=0;i<count;i++)
              {
                ((AmpelListener)listeners.elementAt(i)).rot(e);
              }
        }
       }

       protected void fireRot_Gelb(AmpelEvent e)
      {
          if(myAmpelListeners!=null)
          {
              Vector listeners =myAmpelListeners;
              int count=listeners.size();
              for(int i=0;i<count;i++)
              {
               ((AmpelListener)listeners.elementAt(i)).rot_gelb(e);
              }
        }
       }
      
       protected void fireGruen(AmpelEvent e)
      {
          if(myAmpelListeners!=null)
          {
              Vector listeners =myAmpelListeners;
              int count=listeners.size();
              for(int i=0;i<count;i++)
              {
                ((AmpelListener)listeners.elementAt(i)).gruen(e);
              }
        }
       }
      
       protected void fireGelb(AmpelEvent e)
      {
          if(myAmpelListeners!=null)
          {
              Vector listeners =myAmpelListeners;
              int count=listeners.size();
              for(int i=0;i<count;i++)
              {
                ((AmpelListener)listeners.elementAt(i)).gelb(e);
              }
        }
       }

     Ampelzustand()
     {
         super("Weiterschalten");
     }
}

//////////////////////////////////////////////////////////////////
private Ampel ampel;
private Ampelzustand zustand;
private Panel amPanel;
private Panel zuPanel;

Ampelsteuerung()
{
     super("Ampel");
     amPanel=new Panel(new FlowLayout());
     zuPanel=new Panel(new FlowLayout());
     ampel = new Ampel();
     amPanel.add(ampel);
     zustand= new Ampelzustand();
     zuPanel.add(zustand);
    zustand.addActionListener(new ActionListener()
    {
        public void actionPerformed(ActionEvent e)
        {
          Ampelzustand temp=(Ampelzustand)e.getSource();
          temp.state=temp.nextState();
        }
    });
    zustand.addAmpelListener(ampel);
     this.setSize(150,300);
     this.setLayout(new BorderLayout());
     this.add(amPanel,BorderLayout.CENTER);
    this.add(zuPanel,BorderLayout.SOUTH);
}

//////////////////////////Main//////////////////////////////////
public static void main(String[] argv)
{
     Ampelsteuerung steuer=new Ampelsteuerung();
     steuer.addWindowListener(new WindowAdapter()
     {
         public void windowClosing(WindowEvent e)
         {
             System.exit(0);
         }
    });
    steuer.setVisible(true);
}
}






Musst du nur noch schnell nach C++ portieren.

MfG Spacelord
--
.....Ich mach jetzt nämlich mein Jodeldiplom.Dann hab ich endlich was Eigenes.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
004
30.04.2004, 16:00 Uhr
Windalf
Der wo fast so viele Posts wie FloSoft...
(Operator)


@Spacelord
jetzt kannst du nur hoffen das er nicht ausversehen ins c++ forum gepostet hat aber java meinte, das hast du dir selber in Arsch geschossen
--
...fleißig wie zwei Weißbrote
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
005
30.04.2004, 16:46 Uhr
ao

(Operator)


Sorry, wir machen hier nicht deine Hausaufgaben.

Hast du konkrete Fragen, dann frag.

Wenn du eine Idee brauchst, ich würde so anfangen:


Code:
// Initialisierung
Rot an
Gelb aus
Grün aus

// endlos wiederholen
while (1)
{
    30 Sekunden warten
    Gelb an
  
    2 Sekunden warten
    Rot aus
    Gelb aus
    Grün an

    30 Sekunden warten
    Grün aus
    Gelb an

    2 Sekunden warten
    Gelb aus
    Rot an
}



ao
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
006
30.04.2004, 16:48 Uhr
Windalf
Der wo fast so viele Posts wie FloSoft...
(Operator)


@ao
wobei wenn man jetzt das von uns beiden gesagte zusammenschmeisst hat man ja schon die lösung fertig...
--
...fleißig wie zwei Weißbrote
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
007
30.04.2004, 20:42 Uhr
Andi



danke Jungs ihr habt mir schon sehr geholfen!


thx Andi
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
008
05.12.2004, 15:06 Uhr
~PlusFlor
Gast


Jo, oder nimmt einfach das in C++

C++:
#include <iostream.h>

//Simulation einer Ampelschaltung

class Ampel {

public:
    Ampel();
    Ampel(int zust);
    void weiter();
    void anschalten();
    int print();
    int zustand;
};


Ampel::Ampel() {

    zustand=6;
}

Ampel::Ampel(int zust) {

    zustand=zust;
}

void Ampel::anschalten(){

    zustand=6;

}

void Ampel::weiter(){

    if(zustand==6) {zustand=3;}
    else if (zustand==4) {zustand=0;}
    else {zustand++;}

}

int Ampel::print(){

    switch(zustand) {
    case 0: cout<<"Die Ampel ist gruen"<<endl;break;
    case 1: cout<<"Die Ampel ist gruen blinkend"<<endl;break;
    case 2: cout<<"Die Ampel ist gelb"<<endl;break;
    case 3: cout<<"Die Ampel ist rot"<<endl;break;
    case 4: cout<<"Die Ampel ist rot und gelb"<<endl;break;
    case 6: cout<<"Die Ampel ist gelb blinkend"<<endl;break;
    default: cout<<"Fehler"<<endl;
    }

return 0;}

int afunkt() {
      int a;
      Ampel A;
    
    A.print();

       do{
         cout<<endl<<"Die Ampel weiterschalten(1)"<<endl;
         cout<<"Die Ampel ausschalten = auf gelb blinkend stellen(2)"<<endl;
         cout<<"Den Zustand der Ampel zeigen(3)"<<endl;
         cout<<"Ins Hauptmenue(4)"<<endl;
             cin>>a;
     switch(a){
     case 1:A.weiter();cout<<endl;break;
     case 2:A.anschalten();cout<<endl;break;
     case 3:A.print();cout<<endl;break;
    }

    }while (a!=4);

       return A.print();
}

int nfunkt(){

     int ant,a,zust;

   cout<<endl<<"Sie wollen also eine neue Ampel erstellen:"<<endl<<endl;
   cout<<"Sie haben 2 Moeglichkeiten:"<<endl;
   cout<<"Eine Ampel im Zustand gelb blinkend erstellen (1)"<<endl;
   cout<<"Einen konkreten Zustand fuer die neue Ampel angeben (2)"<<endl;

        cin>>ant;cout<<endl;

   if (ant==1) {

      Ampel C; C.print();
         do{
            cout<<endl<<"Die Ampel weiterschalten(1)"<<endl;
            cout<<"Die Ampel ausschalten = auf gelb blinkend stellen(2)"<<endl;
            cout<<"Den Zustand der Ampel zeigen(3)"<<endl;
            cout<<"Ins Hauptmenue(4)"<<endl;
                    cin>>a;

        switch(a){
           case 1:C.weiter();cout<<endl;break;
           case 2:C.anschalten();cout<<endl;break;
           case 3:C.print();cout<<endl;break;
    }

         }while (a!=4);
         return C.print();
   }

   else if(ant==2) {
        
        cout<<"Geben Sie die Zahl fuer den jeweiligen Zustand ein:"<<endl<<endl;
        cout<<"0 = gruen"<<endl;
        cout<<"1 = gruen blinkend"<<endl;
        cout<<"2 = gelb"<<endl;
        cout<<"3 = rot"<<endl;
        cout<<"4 = rot+gelb"<<endl;
        cout<<"6 = gelb blinkend"<<endl;
        cout<<"Eingabe:";  
        cin>>zust;

        Ampel C(zust);
        
        cout<<endl; C.print();
    do{
        cout<<endl<<"Die Ampel weiterschalten(1)"<<endl;
        cout<<"Die Ampel ausschalten = auf gelb blinkend stellen(2)"<<endl;
        cout<<"Den Zustand der Ampel zeigen(3)"<<endl;
        cout<<"Ins Hauptmenue(4)"<<endl;
             cin>>a;

    switch(a){
      case 1:C.weiter();cout<<endl;break;
      case 2:C.anschalten();cout<<endl;break;
      case 3:C.print();cout<<endl;break;
    }

    }while (a!=4);
         return C.print();}
}



int main(){

    char amp;

    while(amp!='e'){
    
    cout<<"\n";
    cout<<"***Hauptmenue***"<<endl;
    cout<<"Ampel A bearbeiten (a)"<<endl;
    cout<<"Eine neue Ampel erstellen(n)"<<endl;
    cout<<"Exit (e)"<<endl;
    cin>>amp;
    
    cout<<"\n";
    
    if(amp=='a'||amp=='A') {afunkt();}
    else if (amp=='n'||amp=='N') {nfunkt();}
    }

    return 0;
}




Bearbeitung von typecast:
cpp-Tags gesetzt

Dieser Post wurde am 05.12.2004 um 15:35 Uhr von typecast editiert.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
009
05.12.2004, 15:40 Uhr
Spacelord
Hoffnungsloser Fall


@PlusFlor:
Ich glaube der damalige Fragesteller braucht keine Lösung mehr .
Desweiteren ist der Header iostream.h veraltet.
Und was deine Klasse angeht wäre es vielleicht eine Überlegung für dich diese zu verfeinern.
Für eine konkrete Ampel mag deine Klasse ausreichend sein aber im Regelfall ist eine Ampel ja nur eine von vielen an einer Kreuzung.
Soll heißen,alle Ampeln reagieren auf eine Zustandsänderung,ebenso die Autos die vor den Ampeln stehen usw.. Also wäre es eventuell als Übung interessant dein Modell dahingehend zu erweitern dass die Klassen(Ampel,Auto,Fussgaenger etc.) von einer abstrakten Oberklasse abgeleitet sind und ein Interface implementieren dass eine "globale" Zustandsänderung verarbeitet.Dann hättest du eine Klasse(sagen wir mal Kreuzungssteuerung) bei der sich alle Objekte die sich für die Zustandsänderung interessieren anmelden und dann bei einer Zustandsänderung über diese informiert werden.
Mal angenommen die Oberklasse würde die Methode weiter() enthalten die jede davon abgeleitete Klasse implementieren müsste,dann könnte die Ampel ihren Zustand weiter zählen und den neuen Zustand anzeigen,das Auto seinen Zustand ändern und so z.B. vom Zustand fahren auf anhalten wechseln usw. usw.

MfG Spacelord
--
.....Ich mach jetzt nämlich mein Jodeldiplom.Dann hab ich endlich was Eigenes.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
Seiten: > 1 <     [ C / C++ (ANSI-Standard) ]  


ThWBoard 2.73 FloSoft-Edition
© by Paul Baecher & Felix Gonschorek (www.thwboard.de)

Anpassungen des Forums
© by Flo-Soft (www.flo-soft.de)

Sie sind Besucher: