zahlen von klein nach groß sortieren

hallo

hab hier eine aufgabe, ich muss 3 zahlen die ich eingebe von klein nach groß sortieren. hab zwar ein fertiges programm mit if else funktion gemacht aber würde gern wissen, ob es auch mit for while schleife geht. hab es versucht aber nicht geschaft

# include <iostream>
using namespace std; 
void main ()

{
	int x,y,z;
	cin >> x >>y >>z;

	if (x>y && x>z)
	{ if (y>z)
	  cout << z<<y<<x;
	else 
		cout <<y<<z<<x; }
	else
		if (y>x && y>z)
		{ if (x>z)
		cout <<z<<x<<y;
		else 
			cout <<x<<z<<y; }
		else
		{	if (x>y)
			cout <<y<<x<<z;
		else 
			cout <<x<<y<<z; }
}

vielen dank

cooky451

Google nach "Sortieralgorithmen"

Falsch:

void main ()

Richtig:

int main ()

pyhax

#include <iostream>
#include <algorithm>

int main() {
    int zahlen[3];
    std::cin >> zahlen[0] >> zahlen[1] >> zahlen[2];
    std::sort(zahlen, zahlen+3);
    std::cout << zahlen[0] << " " << zahlen[1] << " " << zahlen[2] << "\n";
}

Swordfish

#include <iostream>
#include <algorithm>

const size_t max_input = 3;

int main( )
{
	int numbers[max_input] = {};
	for(size_t i(0); i < max_input; ++i) {

		do {
			std::cin.sync( );	
			std::cin.clear();

			std::cout << i << ": ";
			std::cin >> numbers[i];

			if( std::cin.rdbuf( )->in_avail( ) && std::cin.get( ) != '\n' ) {
				std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
				std::cin.setstate(std::ios_base::failbit);
			}
		} while(std::cin.fail());
	}

	std::sort(numbers, numbers + max_input);

	for(size_t i(0); i < max_input; ++i) {
		std::cout << i << ": " << numbers[i] << '\n';
	}
	std::cout << std::flush;
}

SeppJ

@Swordfish: Das ganze sync, ignore, avail Zeugs macht nicht das, was du denkst. Das funktioniert vielleicht unter gewissen Umständen, aber zum Beispiel nicht auf meinem System, wenn die Standardeingabe die Tastatur ist.

Swordfish

Hm, bei mir tut es, was es soll - auch mit Tastatur

SeppJ

Swordfish schrieb:

Hm, bei mir tut es, was es soll - auch mit Tastatur

Ja, das Verhalten ist eben Implementation defined. Das kann bei dir durchaus funktionieren, ist aber nicht portabel. Das entspricht ungefähr dem berüchtigten fflush(stdin), falls du abundzu mal C-Forum liest.

#include <algorithm>
#include <deque>
#include <iostream>
#include <iterator>
#include <stdexcept>

int ask_number() {
  int x;

  std::cin >> x;
  if(!std::cin) {
    throw std::invalid_argument("UBD");
  }

  return x;
}

int main() {
  std::deque<int> data;

  try {
    std::generate_n(std::back_inserter(data), 3, ask_number);
    std::sort(data.begin(), data.end());
    std::copy(data.begin(), data.end(),
              std::ostream_iterator<int>(std::cout, " "));
    std::cout << '\n';
  } catch(std::invalid_argument const &) {
    std::cout << "Nur Zahlen, du Hirni.\n";
    return -1;
  }
}

Swordfish

SeppJ schrieb:

Swordfish schrieb:

Hm, bei mir tut es, was es soll - auch mit Tastatur

Ja, das Verhalten ist eben Implementation defined.

Ok. Gibt's dann einen portablen, standardkonformen Weg, cin nach fail() zu restaurieren?

SeppJ schrieb:

Das entspricht ungefähr dem berüchtigten fflush(stdin), [...]

Daaas kenn ich

Swordfish schrieb:

Ok. Gibt's dann einen portablen, standardkonformen Weg, cin nach fail() zu restaurieren?

cin.clear();

@ manni66

ja aber wenn ich int main () schreibe, dann bekomm ich ein fehler. nur wenn ich void main schreibe, ist der fehler weg.

@ pyhax
vielen dank für diesen einfachen programm. den kan man auch ganz leicht auf 5 zahlen oder mehr erweitern.

Swordfish

Gugelmoser schrieb:

Swordfish schrieb:

Ok. Gibt's dann einen portablen, standardkonformen Weg, cin nach fail() zu restaurieren?
cin.clear();

cin.clear() leert aber den puffer IMHO nicht...

Bashar

Mohamedyarub schrieb:

ja aber wenn ich int main () schreibe, dann bekomm ich ein fehler. nur wenn ich void main schreibe, ist der fehler weg.

Was denn für einen Fehler?

SeppJ

Swordfish schrieb:

Ok. Gibt's dann einen portablen, standardkonformen Weg, cin nach fail() zu restaurieren?

Na, clear(). Wobei du dann aber wahrscheinlich noch Zeichen verwerfen willst. Dann kommt's drauf an, wieviele du verwerfen möchtest. Ich verwerfe ja gerne nur das nächste Zeichen, andere eine ganze Zeile. Aber auf jeden Fall nicht rdbuf()->in_avail() viele und auch nicht sync(). Denn in_avail() gibt die Anzahl der Zeichen, die noch mindestens im Stream sind. Ein standardkonformes Verhalten (welches auch durchaus sehr oft anzutreffen ist, da technisch gar nicht anders möglich) ist 0. Ähnlich bei sync(), welches eigentlich eher für ostreams gedacht ist. In der Windowskonsole trifft es sich eben, dass sync gerade so funktioniert wie du es dir denkst, aber standardkonform und durchaus nicht unüblich ist ebenfalls, dass einfach nix passiert. Willst du eine ganze Zeile verwerfen, macht man daher clear() und dann ignore(std::limitsstd::streamsize::max(), '\n'). Das funktioniert garantiert und mehr ist gar nicht nötig. Daher wundert mich auch dein Programm ein bisschen, denn diese Elemente hast du schon drin und mir ist nicht ganz klar, wozu die ganzen Zusätze überhaupt gut sein sollen.

std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');

Das ist Implementation defined SeppJ

SeppJ

Gugelmoser schrieb:

std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
Das ist Implementation defined SeppJ

Nein, das sync() und in_avail(). Wobei implementation defined nicht exakt ausgedrückt ist. Im Standard steht ein vorgebenes Verhalten (siehe mein vorheriger Beitrag), aber dieses Verhalten entspricht nicht unbedingt dem das Swordfish für sein Programm benutzt.

Deine Analyse von sync() ist nicht ganz korrekt, aber sync() ist im Standard auch nicht besonders hilfreich definiert. std::basic_ostream hat keine Methode sync(), sondern stattdessen flush(). std::basic_istream::sync() und std::basic_ostream::flush() sind so definiert, dass sie rdbuf()->pubsync() aufrufen, und std::basic_streambuf::pubsync() ruft seinerseits std::basic_streambuf::sync() auf (NVI).

Bei std::basic_streambuf::sync() handelt es sich um eine virtuelle Funktion, die vom Benutzer in abgelittenen Klassen überschrieben werden kann, und wenn er das tut, erhält std::basic_istream::sync() einen Sinn. Allerdings überschreiben alle Standard-Streambuffer std::basic_streambuf::sync() in einer Art und Weise, die nur für Ausgabeströme Sinn ergibt; sofern man also std::cin nicht vorher einen eigenen Streambuffer andreht, der sync() in passender Weise redefiniert, ist das Verhalten von std::cin.sync() nicht definiert.

pyhax

http://www.daniweb.com/software-development/cpp/tutorials/90228

Swordfish

SeppJ schrieb:

[...] Daher wundert mich auch dein Programm ein bisschen, denn diese Elemente hast du schon drin und mir ist nicht ganz klar, wozu die ganzen Zusätze überhaupt gut sein sollen.

Bei einer Eingabe von Hausnummer "4a" für einen Integer liefert cin die 4 und das 'a' bleibt im Puffer, das failbit bleibt ungesetzt. Ich wollte in if( std::cin.rdbuf( )->in_avail( ) && std::cin.get( ) != '\n' ) { (falls noch irgendwas außer einem '\n' im Puffer) das failbit manuell setzen und den Puffer - an dieser Stelle offenbar standardkonform - leeren.
Daß std::cin.rdbuf()->in_avail() "nur" die Anzahl der mindestens im Puffer vorhandenen Zeichen liefert, habe ich nicht gewusst.

pyhax

Gibt es eigentlich in C++11 irgendetwas um dieses Problem zu umgehen?