integer-array sortieren!! Wie??

SirLant

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

int main ()
{
    int foo[7] = {3,6,1,9,4,2,0};

    sort (&foo[0], &foo[7]);

    for (int i = 0; i < 7; ++i)
        cout << foo[i] << endl;

}

Edit:
Hab müll geschrieben

dioe ausgabe geht so nicht.

Und wie muss ich es dann ausgeben lassen??

kira

phlox81

kira schrieb:

dioe ausgabe geht so nicht.

Und wie muss ich es dann ausgeben lassen??

kira

Du musst jedes element von array ausgeben lassen.
Mit cout << array gibst du nur die Adresse des ersten Elementes aus.

Devil

Jester

Hat SirLant doch schon gepostet, alternativ so:

#include <algorithm>
#include <iostream>
#include <iterator>
using namespace std;

int main ()
{
    int foo[7] = {3,6,1,9,4,2,0};

    sort (foo, foo+7);
    copy(foo, foo+7, ostream_iterator<int>(cout, " "));
}

MfG Jester

KPC

kira schrieb:

dioe ausgabe geht so nicht.

Und wie muss ich es dann ausgeben lassen??

kira

Das hast du doch schon in deinem ersten Beitrag richtig gemacht?!

Kennste die Makros: min und max? Das sind echt feine Dinger!

SirLant

nix da schrieb:

Kennste die Makros: min und max? Das sind echt feine Dinger!

Worauf willst du hinaus?

Shade Of Mine

SirLant schrieb:

sort (&foo[0], &foo[7]);

Bumm
denn foo[7] gehört dir nicht

volkard

Shade Of Mine schrieb:

SirLant schrieb:

sort (&foo[0], &foo[7]);

Bumm
denn foo[7] gehört dir nicht

und? macht es wirklich "Bumm"? ich glaube nicht.

Ich auch nicht, sonst würde end() auch BOOOM machen. Das wäre ein bisschen unintuitiv.

Shade Of Mine

volkard schrieb:

und? macht es wirklich "Bumm"? ich glaube nicht.

OK, ersetzen wir BUMM durch Undefiniertes Verhalten. Ist das besser?

Natürlich macht es nicht Bumm, weil der Compiler die Dereferenzierung wegoptimiert. Aber weshalb hier UB in kauf nehmen, auch wenn es auf 99% der Palttformen läuft, wenn man mit arr+7 das gleiche ohne UB und weniger Zeichen erreichen kann?

Spätestens wenn arr eine Klasse wird, kann das arr[7] zu einem Bumm führen - denn dann könnte man ja Rangechecking (natürlich mit assert) einbauen, und das fliegt einem um die Ohren.

@OPtimizer:
*vec.end() ist IIRC auch verboten...

Oder habe ich mich gerade blamiert?

*vec.end() ist natürlich verboten. Aber der sort geht ja nur bis 1 vor dem letzten, oder täusch ich mich da jetzt?

Shade Of Mine

Optimizer schrieb:

*vec.end() ist natürlich verboten. Aber der sort geht ja nur bis 1 vor dem letzten, oder täusch ich mich da jetzt?

Wenn ich mich jetzt nicht total blödsinn quatsche:

&foo[7]
das ist die Adresse von foo[7]
Und um die Adresse von foo[7] zu bekommen, braucht man erstmal foo[7]
Aber foo[7] gibt es nicht. Deswegen denke ich, dass es UB ist.

Der Code funktioniert aber trotzdem, weil der Compiler nicht dumm ist und aus &foo[7] einfach foo+7 macht - was er bei builtins ja kann. Aber bei einem vector müsste es IMHO nen Fehler geben, weil er eben kein 8. Element hat.

Stimmt, mit der Adresse ist das natürlich nochmal eine andere Situation. Hab ich nicht aufgepasst.
Ich check grad sowieso nicht, warum hier überhaupt mit dem Adressoperator gearbeitet wird.

SirLant schrieb:

nix da schrieb:

Kennste die Makros: min und max? Das sind echt feine Dinger!

Worauf willst du hinaus?

Kleiner Tipp, da er ja sehr warscheinlich das Array nach Größeneinheiten sortieren will, sind diese Makros am besten dafür zu handhaben.

Dafür muss man nicht fragen worauf ich hinaus will, das weiß man mit 5 sec. nachdenken.

Ich weiss es immer noch nicht.

SirLant

Ich würde sagen es macht hier nicht BUMM, ganz einfach, weil das nen Iterator ist und
der über ++ und -- inkrementiert und dekrementiert werden kann in diesem Fall ist &foo[7], ganz einfach 28Bytes hinter der Adresse von foo.
Das gleiche macht man bei den Iteratoren von Klassen ja ebenfalls.

Sort geht soweit bis der erste Parameter auf dem zweiten liegt, was ja passiert wenn
zum 8.mal Inkrementiert wurde, dann wird auf eine Adresse gezeigt die uns nicht gehört, aber mit
dieser wird ja nie gearbeitet.

Edit:

Um mal nen Beispiel zu bringen:

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

void waste_cpu_time (int *Anf, int *End)
{
	while (Anf != End)
	{
		*Anf = 12;
		Anf++;
	}
}

int main (void)
{
	int foo[] = {3,3,3,3};

	copy(foo, foo+4, ostream_iterator<int>(cout, " "));

	waste_cpu_time (&foo[0], &foo[4]);

	copy(foo, foo+4, ostream_iterator<int>(cout, " "));

}

SirLant

Optimizer schrieb:

Ich weiss es immer noch nicht.

ich ebenso

Jester

@SirLant:

Das ist schon korrekt, und es wird wohl auch nicht BUMM machen, aber es könnte:

&foo[7] wird folgendermaßen ausgewertet:

&(foo[7]), zunächst wird der innere Ausdruck ausgewertet: foo[7] und das ist nicht legal, denn das gibt es nicht. Was danach passiert ist eigentlich dann uninteressant. Das ist ungefähr so, als würdest Du sagen: Ja, ich teile jetzt erstmal durch 0, das darf man zwar nicht, aber ich nehm ja nachher wieder mit 0 mal und dann kann ich es rauskürzen...
Jetzt klarer?

Was allerdings diese min, max Geschichte soll ist mir völlig unklar.

MfG Jester

Ich muss zugeben, ich bin jetzt wohl etwas verwirrt.... aber es hat in meinem Beispielprogramm ja funktioniert!

Allerdings musste ich das Prog etwas abändern, es sieht jetzt ungefähr so aus:

#include <iostream> 
#include <algorithm> 

using namespace std; 

int main() 
{
    int y=0;
    char b[5];

    do
    {
        cout<<"Buchstabe: ";
        cin>>b[y];
        y++;
    }
    while(y<5);

    for(int a=0;a<5;a++) 
    { 
        int array[5]={0};

        if(b[a]=='a')array[a]=9;
        if(b[a]=='b')array[a]=3;
        if(b[a]=='c')array[a]=14;
        if(b[a]=='d')array[a]=1;
        if(b[a]=='e')array[a]=16;

        cout<<array[a]<<endl; 
    } 

    return 0; 
}

array[a] muss ich jetzt sortieren und ich habe wieder ernsthafte Probleme damit! Die Frage ist auch, ob innerhalb oder außerhalb der for-Schleife sortiert wird! Weiß also jemand von euch WIE und WO sortieren?? Das wäre echt wichtig....Schonmal Danke!

kira