Klassenproblem

henry m

Ich habe ein Problem mit meinem Klassenbeispiel: Ich weiss erstens nicht ob und wie ich hier das enum verwenden darf, ob ich im Konstruktor int startzustand nehmen darf, obwohl zustand vom datentyp enum ist und schon gar nicht ob die schleife so angewendet werden darf...Hab nur wenige Fehler, Problem ist ich weiss nicht was genau...

Hier mein Code und die zugehoerige Angabe:

Schreiben Sie eine Klasse, deren Objekte eine Ampel repräsentieren. Die Ampel hat die Zustände grün, grün blinkend, gelb, rot, rot+gelb in der üblichen Reihenfolge. Zusätzlich gibt es noch den Zustand gelb blinkend. Implementieren Sie zumindest die Methoden anschalten (versetzt die Ampel in den Zustand gelb blinkend), weiter (geht in den nächstfolgenden Zustand über; dabei ist der Folgezustand von gelb blinkend gleich rot) und print (gibt den aktuellen Zustand der Ampel aus).
Schreiben Sie

* die nötigen Konstruktoren, damit folgende Definitionen von Objekten möglich sind (unter der Annahme, dass die Klasse den Namen Ampel hat):
Ampel a; // erzeugt eine Ampel im Zustand gelb blinkend
Ampel b = AktZustand; // erzeugt eine Ampel in dem Zustand, der durch AktZustand vorgegeben wird
* Einen Operator ++, der das Fortschalten der Ampel bewirkt

Schreiben Sie ein Hauptprogramm, das mindestens zwei Instanzen Ihrer Klasse verwendet und die Verwendung der verschiedenen Methoden illustriert.
Anmerkung: Der Operator ++ kann in C++ sowohl in Postfix- (a++), als auch in Prefixform (++a) verwendet werden. Bei der Definition der Methoden zum Überladen des Operators ++ gibt es daher zwei verschiedene Möglichkeiten:
void operator++() definiert die Prefixform
void operator++(int) definiert die Postfixform
Der zusätzliche Parameter bei der Postfixform unterscheidet nur zwischen den beiden Möglichkeiten und hat sonst keinerlei Verwendung. Für die Lösung des Beispiels brauchen Sie nur eine der beiden Möglichkeiten zu implementieren. Statt void kann bei Bedarf natürlich auch ein passender Typ für das Ergebnis der Operation gewählt werden.

#include<iostream>
using namespace std;
class ampel
{
public:
int anschalten();
int weiter();
int print();

private:

enum zustand {gruen,gruen_blinkend,gelb,rot,rot_gelb,gelb_blinkend};
};

ampel::ampel(int startzustand)
{
startzustand=0;
zustand=startzustand;
}

int ampel::anschalten()
{

return zustand(5);
}

int ampel::weiter()
{
int i;
for(i=0,zustand=anschalten();i<1;i++,zustand++);
}

int ampel::print()
{
return zustand;
}

int main()
{
ampel a,b;
a.anschalten;
b.print;

return 0;
}

hardy

ich würde die klasse so aufbauen :

class ampel 
{ 
public:
//initialisieren im konstruktor, also quasi anschalten 
ampel(){akt_zustand=0;};
//hier einen zustand weitergehen und beim erreichen des letzten wieder vorne anfangen. dabei bedenke, dass eine ampel meist nicht auf gelb_blinkend schaltet ;)
void operator ++(){akt_zustand=2+(++akt_zustand-2)%4;};
ampel operator = (){return *this;};
//ausgabe des zustandes
int print(){std::cout<<"Ampelzustand : "<<akt_zustand<<std::endl;};
//der enum mit
enum zustand {gruen_blinkend=0,gelb_blinkend=1,gruen=2,gruen_gelb=3,rot=4,rot_gelb=5} akt_zustand; 
};

beispiele der verwendung wäre dann :

ampel a;
a++;
ampel b = a;
b.print();

hab das auch mal versucht

//****************************************************
// Ampel.h
//****************************************************
#ifndef _AMPEL_H_
#define _AMPEL_H_

//****************************************************

enum Zustaende
{
	AUS=0,
	GELB_BLINKEND=1,
	ROT=2,
	GELB=3,
	GRUEN_BLINKEND=4,
	GRUEN=5
};

//****************************************************

class CAmpel
{
private:
	Zustaende m_zustand;
public:
	CAmpel();
	CAmpel(Zustaende zustand);

	Zustaende anschalten();  
	Zustaende weiter();		

	Zustaende operator++();
	Zustaende operator++(int);

	CAmpel operator=(Zustaende zustand);

	void print();		
};

//****************************************************

#endif

//****************************************************
//****************************************************
//****************************************************

//****************************************************
// Ampel.cpp
//****************************************************
#include <iostream>
#include "Ampel.h"

using namespace std;

//****************************************************
// konstruktor
//****************************************************
CAmpel::CAmpel()
{
	m_zustand = AUS;
}

//****************************************************
// konstruktor
//****************************************************
CAmpel::CAmpel(Zustaende zustand)
{
	m_zustand = zustand;
}

//****************************************************
// auf gelb blinkend schalten
//****************************************************
Zustaende CAmpel::anschalten()
{
	m_zustand = GELB_BLINKEND;
	return m_zustand;
}

//****************************************************
// weiterschalten des zustands
//****************************************************
Zustaende CAmpel::weiter()
{
	switch(m_zustand)
	{
	case GRUEN:
	case GELB_BLINKEND:	m_zustand=ROT;
						break;
	case ROT:			m_zustand=GELB;
						break;
	case GELB:			m_zustand=GRUEN_BLINKEND;
						break;
	case GRUEN_BLINKEND:m_zustand=GRUEN;
						break;
	}
	return m_zustand;
}

//****************************************************
// ausgabe
//****************************************************
void CAmpel::print()
{
	switch(m_zustand)
	{
	case GELB_BLINKEND:	cout << "Gelb blinkend..." << endl;
						break;
	case ROT:			cout << "Rot............." << endl;
						break;
	case GELB:			cout << "Gelb............" << endl;
						break;
	case GRUEN_BLINKEND:cout << "Gruen blinkend.." << endl;
						break;
	case GRUEN:			cout << "Gruen..........." << endl;
						break;
	case AUS:			cout << "Ausgeschaltet..." << endl;
						break;
	}
}

//****************************************************
// prefix
//****************************************************
Zustaende CAmpel::operator++()
{
	return weiter();
}

//****************************************************
// postfix
//****************************************************
Zustaende CAmpel::operator++(int)
{
	Zustaende temp = m_zustand;
	weiter();
	return temp;
}

//****************************************************
// zuweisungsoperator
//****************************************************
CAmpel CAmpel::operator =(Zustaende zustand)
{
	m_zustand=zustand;
	return (*this);
}

//****************************************************
//****************************************************
//****************************************************

//****************************************************
// main.cpp
//****************************************************
#include <iostream>
#include <conio.h>
#include "Ampel.h"

//****************************************************

using namespace std;

void main()
{
	CAmpel ampel;
	ampel.print();

	ampel.anschalten();
	ampel.print();

	ampel++;
	ampel.print();

	++ampel;
	ampel.print();

	ampel.weiter();
	ampel.print();

	ampel.weiter();
	ampel.print();

	ampel.weiter();
	ampel.print();

	ampel = GELB;
	ampel.print();

	cout << "Returntaste zum Beenden druecken...";
	getch();
}

//****************************************************
//****************************************************
//****************************************************

enno-tyrant

http://www.cpp-tutor.de/cpp/le08/le08_02.htm#beispiel2