mit bool auf true prüfen

hi.

also ich hab eine klasse auto geschrieben die private eigenschaften enthält (siehe quellcode).
der zugriff usw klappt auch wunderbar. nur jetzt soll ich methoden schreiben die das verhalten des autos beschreiben.
also z.b Motor starten
Kann ich das mit bool machen?
z.b

class Auto
{
private:
        bool MotorStarten;

public:
        void SetMotorStarten(bool = true);
	bool GetMotorStarten(void);
};

//Methodenbeschreibung

void Auto::SetMotorStarten(bool wert)
{
	true = eingabeMotor;
}
bool Auto::GetMotorStarten(void) {return true;}

Auto Auto1;

int main()
{
	bool = eingabeMotor; 

	cout<<"Soll der Motor gestartet werden(ja=1 / nein=0)?";
	cin>>eingabeMotor;
	Auto1.SetMotorStarten(eingabeMotor);

	if(Auto1.GetMotorStarten() == true)
	{
		cout<<"Der Motor wird gestartet";	
	}
	else
	{
		cout<<"Der Motor wurde nicht gestartet";
	}
}

oder wäre das ein falscher ansatz?

hier mal der ganze code der bisher funktioniert (ohne MotorStarten)

#include <iostream>
#include <stdlib.h>
#include <string.h>

using namespace std;

//Maximalwerte der Arrays
#define HMAX 10 //Hersteller MAX
#define TMAX 10 //Typ MAX
#define FMAX 10 //Farbe MAX

//Klassendeklaration
class Auto
{
private:
	char Hersteller[HMAX];
	char Typ[TMAX];
	char Farbe[FMAX];
	int Hubraum;
	int PS;

public:
	void SetHersteller(char *str);
	char *GetHersteller(void);
	void SetTyp(char *str);
	char *GetTyp(void);
	void SetFarbe(char *str);
	char *GetFarbe(void);
	void SetHubraum(int ccm);
	int GetHubraum(void);
	void SetPS(int ps);
	int GetPS(void);
};

//Methodenbeschreibung
void Auto::SetHersteller(char *str)
{
	strcpy (Hersteller, str);
}
char *Auto::GetHersteller(void) {return Hersteller;}

void Auto::SetTyp(char *str)
{
	strcpy (Typ, str);
}
char *Auto::GetTyp(void) {return Typ;}

void Auto::SetFarbe(char *str)
{
	strcpy (Farbe, str);
}
char *Auto::GetFarbe(void) {return Farbe;}

void Auto::SetHubraum(int ccm)
{
	Hubraum = ccm;
}
int Auto::GetHubraum(void) {return Hubraum;}

void Auto::SetPS(int ps)
{
	PS = ps;
}
int Auto::GetPS(void) {return PS;}

///////////
Auto Auto1;
///////////

int main()
{
	//lokale Variablen
	char hersteller[HMAX];
	char typ[TMAX];
	char farbe[FMAX];
	int ccm;
	int ps;

	//Setzen der Eigenschaften
	cout<<"Eingabe des Herstellers: ";
	cin>>hersteller;
	Auto1.SetHersteller(hersteller);

	cout<<"Eingabe des Typs: ";
	cin>>typ;
	Auto1.SetTyp(typ);

	cout<<"Eingabe der Farbe: ";
	cin>>farbe;
	Auto1.SetFarbe(farbe);

	cout<<"Eingabe des Hubraums: ";
	cin>>ccm;
	Auto1.SetHubraum(ccm);

	cout<<"Eingabe der PS: ";
	cin>>ps;
	Auto1.SetPS(ps);

	//Lesen der Eigenschaften
	cout<<endl;
	cout<<"Ausgabe des Herstellers: "<<Auto1.GetHersteller()<<endl;
	cout<<"Ausgabe des Typs: "<<Auto1.GetTyp()<<endl;
	cout<<"Ausgabe der Farbe: "<<Auto1.GetFarbe()<<endl;
	cout<<"Ausgabe des Hubraums: "<<Auto1.GetHubraum()<<endl;
	cout<<"Ausgabe der PS: "<<Auto1.GetPS()<<endl;
}

Danke

GPC

Mach doch folgendes:

class Auto {
private:
  bool motorAn;
public:
  void startMotor();
  void stopMotor();
  bool isMotorOn() const;
};

void Auto::startMotor() { motorAn = true; }
void Auto::stopMotor() { motorAn = false; }
bool Auto::isMotorOn() const { return motorAn; }

DEvent

was soll die sch*****:

void Auto::SetMotorStarten(bool wert) 
{ 
    true = eingabeMotor; 
} 
bool Auto::GetMotorStarten(void) { return true; }

wie wärs mit:

void Auto::SetMotorStarten(bool wert) 
{ 
    MotorStarten = wert; 
} 
bool Auto::GetMotorStarten(void) { return MotorStarten; }

und was soll das ??

bool = eingabeMotor;

du programmierst momentan C/C++. beschäftige dich lieber mit C++. ist einfacher.

okay habs:

#include <iostream>
#include <stdlib.h>
#include <string.h>

using namespace std;

//Maximalwerte der Arrays
#define HMAX 10 //Hersteller MAX
#define TMAX 10 //Typ MAX
#define FMAX 10 //Farbe MAX

//Klassendeklaration
class Auto
{
private:
	char Hersteller[HMAX];
	char Typ[TMAX];
	char Farbe[FMAX];
	int Hubraum;
	int PS;
	bool MotorStarten;

public:
	void SetHersteller(char *str);
	char *GetHersteller(void);
	void SetTyp(char *str);
	char *GetTyp(void);
	void SetFarbe(char *str);
	char *GetFarbe(void);
	void SetHubraum(int ccm);
	int GetHubraum(void);
	void SetPS(int ps);
	int GetPS(void);
	void SetMotorStarten(bool wert);
	bool GetMotorStarten(void);
};

//Methodenbeschreibung
void Auto::SetHersteller(char *str)
{
	strcpy (Hersteller, str);
}
char *Auto::GetHersteller(void) {return Hersteller;}

void Auto::SetTyp(char *str)
{
	strcpy (Typ, str);
}
char *Auto::GetTyp(void) {return Typ;}

void Auto::SetFarbe(char *str)
{
	strcpy (Farbe, str);
}
char *Auto::GetFarbe(void) {return Farbe;}

void Auto::SetHubraum(int ccm)
{
	Hubraum = ccm;
}
int Auto::GetHubraum(void) {return Hubraum;}

void Auto::SetPS(int ps)
{
	PS = ps;
}
int Auto::GetPS(void) {return PS;}

void Auto::SetMotorStarten(bool wert)
{
	MotorStarten = wert;
}
bool Auto::GetMotorStarten(void) {return MotorStarten;}

///////////
Auto Auto1;
///////////

int main()
{
	//lokale Variablen
	char hersteller[HMAX];
	char typ[TMAX];
	char farbe[FMAX];
	int ccm;
	int ps;
	bool eingabeMotor;

	//Setzen der Eigenschaften
	cout<<"Eingabe des Herstellers: ";
	cin>>hersteller;
	Auto1.SetHersteller(hersteller);

	cout<<"Eingabe des Typs: ";
	cin>>typ;
	Auto1.SetTyp(typ);

	cout<<"Eingabe der Farbe: ";
	cin>>farbe;
	Auto1.SetFarbe(farbe);

	cout<<"Eingabe des Hubraums: ";
	cin>>ccm;
	Auto1.SetHubraum(ccm);

	cout<<"Eingabe der PS: ";
	cin>>ps;
	Auto1.SetPS(ps);

	cout<<"Soll der Motor gestartet werden(ja=1)?";
	cin>>eingabeMotor;
	Auto1.SetMotorStarten(eingabeMotor);

	//Lesen der Eigenschaften
	cout<<endl;
	cout<<"Ausgabe des Herstellers: "<<Auto1.GetHersteller()<<endl;
	cout<<"Ausgabe des Typs: "<<Auto1.GetTyp()<<endl;
	cout<<"Ausgabe der Farbe: "<<Auto1.GetFarbe()<<endl;
	cout<<"Ausgabe des Hubraums: "<<Auto1.GetHubraum()<<endl;
	cout<<"Ausgabe der PS: "<<Auto1.GetPS()<<endl;

	if(Auto1.GetMotorStarten() == true)
	{
		cout<<"Der Motor wird gestartet"<<endl;	
	}
	else
	{
		cout<<"Der Motor wurde nicht gestartet"<<endl;
	}

}

danke

ist eignt. sonst was auszusetzen?

Ich persönlich halte nichts von Klassen die nur aus Variablen bestehen und für jede Variable ne Set+Get-Methode, aber wenigstens verwendest du kein Deutsch-Englisch-Mix wie einige hier in ihren Beispielen (Get+Set vor nem Namen lass ich durchgehen).

Aber ansonsten ist das soweit ok, du könntest die globale Variable Auto1 in main() packen und statt #define const size_t verwenden.

groovemaster

schüler18 schrieb:

ist eignt. sonst was auszusetzen?

Jo, nimm keine Makros für Konstanten und achte auf const-correctness.

Ja ich habe noch was auszusetzen

warum to hell includest du

string.h ???

wo benutzt du das denn?

gar nicht.

und warum nicht? warum tust du dir char mit strcpy an?

das mit dem const correcness ist gar nicht so verkehrt

schreib lieba

SetHersteller(const char *str);
SetMotorStarten(const bool wert);

die varibalen namen sind auch nicht so der bringer

z.b.

// statt
bool MotorStarten;

// lieber

bool bMotorgestartet

// oder "noch besser"

bool m_bMotorGestartet;

bei

int PS;

// lieber 

unsigned int PS;

// so kann niemand dein PS negativ setzen ;)

dein

"//Setzen der Eigenschaften"
könntest du in einer fkt packen und dein

"/Lesen der Eigenschaften"
ist vielmehr ein

Ausgeben der Eigenschaften würd ich auch in einer extra fkt packen, dann ist das main gleich viel "schlanker"

viel spass sonst noch beim programmieren, ich glaub du bist auf dem richtigen weg

Richie_Gecco

Hi!

Kopfscchüttl kannst Du mir den Sinn von

SetMotorStarten(const bool wert);

erklären?

Und wenn wir schon bei constcorrectness wären, sollte man so etwas nicht vergessen:

const char *Auto::GetHersteller(void) const {return Hersteller;}

Jetzt vllt. noch mit mehr Ausführung für schüler18.

In Funktionsparameter benutzt Du konnst, wenn Du Zeiger oder Referenzen übergibst, aber das übergebende Objekt nicht geändert wird.

Zum Beispiel:

void setFarbe(const Color& farbe);

Get-Funktionen und alle Funktionen, die das Objekt nicht verändern sollten als const Deklariert werden.

Zum Beispiel:

int GetHubraum() const;

Wenn Du Objekte zurückgibst, die Membervariablen sind, dann solltest Du überlegen konstante Referenzen zurückzugeben. Das ist in den meisten Fällen performanter.

Zum Beispiel:

const Color& getFarbe() const {return m_colFarbe;}

Das gleiche gilt für Zeiger, wenn Du einen Zeiger zurückgibst, sollte der als const deklariert werden. (s.o. GetHersteller). Wenn Du das nicht machst, kann ein Anwender Deiner Klasse die Datenkappselung umgehen (auch wenn das ein sehr schlechter Prog-Sitl ist).

Ich hoffe, dass ich ein bißchen licht in das Dunkel des const-Dschungels gebracht habe, lasse mich aber gerne vom const bool Parameter überraschen.

Vllt. wieder für Schüler:
Ein Funktion mit dem Parameter const bool macht nicht soviel Sinn, da Du ein Kopie von dem bool als const deklarierst. Prinzipiell kann Dir es egal sein, ob die Funktion die Kopie verändert. Ein const bool& ist auch nicht so optimal, da es kein Gewinn bringt (Speicher- oder Zeitgewinn).

Grüße
Richie

SetMotorStarten(const bool wert);

soll nur zeigen, das ein wert übergeben wird der nicht verändert wird in der fkt.

klar kann man weglassen, aber wenn ich schon alle fkt. durchgehe und das const setze ( wenn nicht verändert werden soll ) dann zieh ich das durch. ein fremder kann kann gleich auf einem blick sehen, das nur übergeben wird.

auserdem stellt du so sicher das der wert nicht verändert wird ( auch wenn jemand dann doch innnerhalb der fkt "unfug2 treiben sollte.

ups

vergiss einfach absatz 2 und 3

der erste kann man gelten lassen

groovemaster

kopfschüttl schrieb:

das mit dem const correcness ist gar nicht so verkehrt

schreib lieba
SetHersteller(const char *str);
SetMotorStarten(const bool wert);

Funktion 1 ist ok, Funktion 2 ist Unsinn. Da beide Werte by-value übergeben werden, können die ursprünglichen Werte sowieso nicht verändert werden. Denn auch wenn es so aussieht, der Wert in Funktion 1 ist nicht const.