Es ist ein Programm zu erstellen, welches von denangesprochenen Datentypen
int, double, bool, char und string
je eine Größe von Tastatur einliest und diese am Bildschirm wieder ausgibt. Wählen Sie dabei für
jeden Typ geeignete Manipulatoren zur Darstellung der Ausgabe am Bildschirm.
Was passiert bei der Eingabe unzulässiger Zeichen?
Hinweis zur Gestaltung der Ausgabe:
Die Ausgabe einer Größe kann durch folgende Manipulatoren verbessert werden:
setw(int n) Die nächste auszugebende Größe wird in ein Feld der Breite (mindestens) n geschrieben
right Die auszugebende Größe wird in das Feld rechtsbündig geschrieben (default)
left Die auszugebende Größe wird in das Feld linksbündig geschrieben
setprecision(int n) Die auszugebende Gleitpunktzahl hat (maximal) n Stellen Genauigkeit
fixed Die auszugebende Gleitpunktzahl hat genau n Nachkommastellen (von setprecision)
endl Neue Zeile
Erforderlich ist hierfür die Direktive #include . Weitere Manipulatoren finden sich in der Literartur.
Die Manipulatoren müssen vor der auszugebenden Größe erscheinen.

Ein Testplan ist anzufertigen und vorzulegen, wo zu verschiedenen typischen Eingaben die
erwarteten Ergebnisse (=Ausgaben im gewählten Format) zu planen sind.

Hat jemand tipps wie ich hier vorgehen kann?

WIe kann ich z.b mit bool jetzt daten einlesen?

Mit int habe ich es so probiert:

int x;

cout << " Geben sie eine Zahl ein " ;

cin >> x;

Könnt mann das so machen?

Kurz und knapp: So kann man testen:

if(std::cin >> a)///Wenn die Eingabe erfolgreich ist, 
   //... (tu was mit der Variable a)
else
{
    std::cin.clear(); ///Fehlerstatus zurücksetzen
    std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');///Puffer leeren
    ///... (weitere Fehlerbehandlung)
}

Weil ich habe im moment überhaupt keine idee we ich vorgehen muss.

Weisst du wie ich irgendwie mit bool und string dateien lesen kann?

Weil ich habe im moment überhaupt keine idee we ich vorgehen muss.

???

Sab21 schrieb:

Weisst du wie ich irgendwie mit bool und string dateien lesen kann?

Du meinst wohl Daten.
Du kannst mit bool genauso verfahren.

bool b;
std::cin >> b;

bool kann aber nur true (1) oder false (0) sein. Dabei gilt: 0 ist false und alles andere ist true.

nun zu string:

std::string str;
std::cin >> str;    //vorsicht geboten! liest nur bis zum nächsten whitespace
getline(std::cin, str);   //liest bis zum nächsten newline \n

willst du nur ein wort einlesen, kannst du std::cin nehmen, willst du 2,3 oder mehrere durch whitespace getrennte Wörter einlesen, nimmst du getline.

BTW: lernst du mit einem Buch?

gruß
syntax

Ich wollt euch nochmal fragen .

In meinem skript steht das man string irgendwie so einliest.

#include <string>
#include<iostream>
using namespace std;
void main()
{
string str1,str2="dies ist ein Text";
cout<<"dies ist str1:"<<str1<<endl;
cout<<"dies ist str2:"<<str2<<endl;
}

Denn weg denn du mir vorgeschlagen hast , kann man damit auch string einlesen oder wie?

Ich fange gerade an daher stelle ich auch paar blöde fragen.

In meinem skript steht das man string irgendwie so einliest.

string str1,str2="dies ist ein Text";
cout<<"dies ist str1:"<<str1<<endl;
cout<<"dies ist str2:"<<str2<<endl;
}

So liest du keinen string ein.
Der Reihenfolge nach: du definierst 2 Variablen vom typ string. str1 ist leer, str2 initialisierst du. Das hat nichts mit einlesen zu tun. und dieses cout liest auch nichts ein, sondern macht das gegenteil, es gibt aus.

Literatur aus dem Internet ist meistens nicht das gelbe vom Ei.

EDIT: es muss int main() heißen und nicht void main.

gruß
syntax

das kann man sich nicht selbst beibringen und spaß dran haben.

hmm... ich schon

gruß
syntax

Wäre trotzdem dankbar wenn ihr mir ein weng helfen könnt.

Ich hab mal ein wenig probiert und das hier stehen:

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

int main()
{
string x;

x = " Ampel";
cout<< x << endl;

cin.get();
}

Aber irgendwie scheint mein programm da nchts auzugeben.

Ist das so falsch?

gruß
syntax

Danke

HAbe ich das für die Aufgabe entsprechend richtig gemacht?
Weil ich war mir bei dieser aufgabe auch nicht zu 100% sicher was gefragt war.

Wie müsste ich das mit char jetzt genau machen?

Wäre nett wenn du mir paar tips geben könntest.

int i;
cin >> i;   // hier wird eine benutzereingabe erwartet (tastatur)
cout << i;  // ausgabe

Char kann ein zeichen speichern ( siehe ASCII zeichesatz).

char ch = 'g';  // einzelnes zeichen
cout << ch;    // ausgabe g
cin >> ch;   // einlesen von tastatur
cout << ch;

Gruß
Syntax

Dann wäre das ja so:

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

int main()
{
string x;

x = " Ampel";
cout<< x << endl;

cin.get();

int i;
cin >> i;
cout << i;

}

Wäre das so in ordnung?

Ich bin mir hier nämlich nicht so sicher.

Weil ich war mir bei dieser aufgabe auch nicht zu 100% sicher was gefragt war.

Die Aufgabenstellung ist glasklar.

Sab21 schrieb:

Wie müsste ich das mit char jetzt genau machen?
[...]
Wäre nett wenn du mir paar tips geben könntest.

Mit Tipps alleine wird das nix. Habt ihr kein Skriptum bekommen? Hol dir ein Buch?

Sab21 schrieb:

Wäre das so in ordnung?

Die Aufgabenstellung ist damit nicht erfüllt, wenn du das meinst.

#include <limits>
#include <memory>
#include <vector>
#include <string>
#include <iostream>
#include <iomanip>

class basic_value_t
{
	friend std::istream& operator>>( std::istream &is, basic_value_t &value );
	friend std::ostream& operator<<( std::istream &os, basic_value_t const &value );

	public:
		virtual std::istream& read_from( std::istream &is ) = 0;
		virtual std::ostream& write_to( std::ostream &os ) const = 0;
};

std::istream& operator>>( std::istream &is, basic_value_t &value )
{
	return value.read_from( is );
}

std::ostream& operator<<( std::ostream &os, basic_value_t const &value )
{
	return value.write_to( os );
}

template< typename T >
class value_t : public basic_value_t
{
	T value;
	std::string const type;

	public:
		value_t( std::string const &type ) : type( type ) {}

		virtual std::istream& read_from( std::istream &is )
		{
			while( std::cout << "Please enter " << type << ": ", !( ( is >> value ) && is.peek() == '\n' ) ) {

				/* Was passiert bei der Eingabe unzulässiger Zeichen? */
				is.clear(); is.ignore( std::numeric_limits< std::streamsize >::max(), '\n' );
				std::cout << "Input error! Please try again.\n\n";
			}

			return is;
		}

		virtual std::ostream& write_to( std::ostream &os ) const
		{
			return os << std::setw( 12 ) << value << " is " << type << '\n';
		}
};

std::istream& value_t< bool >::read_from( std::istream &is )
{
	std::boolalpha( is );
	while( std::cout << "Please enter " << type << ": ", !( ( is >> value ) && is.peek() == '\n' ) ) {

		is.clear(); is.ignore( std::numeric_limits< std::streamsize >::max(), '\n' );
		std::cout << "Input error! Please try again.\n\n";
	}

	return is;
}

std::istream& value_t< std::string >::read_from( std::istream &is )
{
	std::cout << "Please enter " << type << ": ";

	if( is.peek() == '\n' ) is.get();
	std::getline( is, value );

	return is;
}

/* Wählen Sie dabei für jeden Typ geeignete Manipulatoren zur Darstellung der Ausgabe am Bildschirm. */
std::ostream& value_t< double >::write_to( std::ostream &os ) const
{
	return os << std::setw( 12 ) << std::setprecision( 11 ) << value << " is " << type << '\n';
}

std::ostream& value_t< bool >::write_to( std::ostream &os ) const
{
	return os << std::setw( 12 ) << std::boolalpha << value << " is " << type << '\n';
}

std::ostream& value_t< std::string >::write_to( std::ostream &os ) const
{
	return os << '\"' << value << "\" is " << type << '\n';
}

int main( )
{
	/* Es ist ein Programm zu erstellen, welches von den angesprochenen Datentypen
	int, double, bool, char und string */

	std::vector< std::unique_ptr< basic_value_t > > values;
	values.push_back( std::unique_ptr< basic_value_t >( new value_t< int >( "an integer" ) ) );
	values.push_back( std::unique_ptr< basic_value_t >( new value_t< double >( "a real number" ) ) );
	values.push_back( std::unique_ptr< basic_value_t >( new value_t< bool >( "a boolean value" ) ) );
	values.push_back( std::unique_ptr< basic_value_t >( new value_t< char >( "a single character" ) ) );
	values.push_back( std::unique_ptr< basic_value_t >( new value_t< std::string >( "a string" ) ) );

	/* je eine Größe von Tastatur einliest */
	for( auto i = values.begin(); i != values.end(); ++i ) {

		std::cin >> **i;
	}

	/* und diese am Bildschirm wieder ausgibt. */
	for( auto i = values.begin(); i != values.end(); ++i ) {

		std::cout << **i;
	}
}

/*
Ein Testplan ist anzufertigen und vorzulegen, wo zu verschiedenen typischen Eingaben die
erwarteten Ergebnisse (=Ausgaben im gewählten Format) zu planen sind.

Eingabe 1:
123
123.456
false
a
zeichenkette

Ausgabe:
         123 is an integer
     123.456 is a real number
       false is a boolean
           a is a single character
"zeichenkette" is a string

Eingabe 2:
12345678
1234567.890123
true
b
zeichenkette

Ausgabe:
    12345678 is an integer
1234567.8901 is a real number
        true is a boolean
           b is a single character
"zeichenkette" is a string

*/

// edit: tagsoup
// edit: eloganter

@Sab21
Nein das hättest Du nicht machen müssen. Das ist eine total überzogene "Lösung" die mit Atomwaffen auf Spatzen schießt.

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

int main()
{
	int i;
	double d;
	string str;
	bool b;
	char c;

	cout << "Bitte geben Sie eine ganze Zahl ein: " << endl;
	cin >> i;
	cout << "Bitte geben Sie eine Dezimalzahl ein: " << endl;
	cin >> d;
	cout << "Bitte geben Sie eine/n Zeichenkette/Satz ein: " << endl;
	getline(cin, str);
	cout << "Bitte geben Sie einen booleschen Wert (0 oder 1) ein: " << endl;
	cin >> b;
	cout << "Bitte geben Sie ein Zeichen ein: " << endl;
	cin >> c;
	cout.precision(5);
	cout << "Ihre Eingaben waren:" << endl
	<< "fuer die ganze Zahl: " << i << endl << fixed
	<< "fuer die Dezimalzahl: " << d << endl
	<< "fuer die Zeichenkette: " << str << endl
	<< "fuer die boolsche Zahl: " << b << endl
	<< "fuer das Zeichen: " << c << "." << endl;

	cin.get();
	return 0;

Manipulatoren hab ich jetzt größtenteils weggelassen.
Eine Frage habe ich jedoch: Warum kann ich bei mir keinen string eingelesen? Ist irgendetwas falsch an:

#include<string>
        using namespace std;
        string str;
        cout << "Bitte geben Sie eine/n Zeichenkette/Satz ein: " << endl;
	getline(cin, str);

? Ich sehe da keinen Fehler

Für Verbesserungsvorschläge immer offen.

EDIT: Ich selbst arbeite mit dem Buch "Breymann - Der C++ Programmierer", welches ich (bin selber Laie, also habt Erbarmen mit meinem Buchtipp) dir, Sab21, nur empfehlen kann.

Warum kann ich bei mir keinen string eingelesen?

Wahrscheinlich steht noch ein \n in cin . getline() schnappt sich's und weiter geht's