integer-array sortieren!! Wie??

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

Warum es geht ist schon klar. Der Compiler ist ja schließlich nicht blöd und macht erst mit foo[7] rum, sondern rechnet sich gleich den offset aus.

Kann mir da keiner helfen....??

SirLant

Jester schrieb:

@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?
MfG Jester

Ich verstehe das Kernproblem schon, nur wird ja in den Speicher der uns nicht gehört ja nicht geschrieben, sondern nur die Adresse dieses Speicherbereiches, der uns nicht gehört ermittelt.
Das könnte doch nur BUMM machen, wenn diese Adresse außerhalb des Adressraumes liegen würde, oder?

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

SirLant

Jester schrieb:

@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?

MfG Jester

Ja das ist mir schon klar, dann werd ich in Zukunft einfach foo+size schreiben