Zeiger auf Maximum

groovemaster

@Dai
Dein ursprünglicher Code war ja schon fast korrekt, bis auf die fehlende Indirektion.

float* max(float* array[], size_t n)
{
    assert(n != 0); // <cassert>
    float* tmp = array[0];
    for (size_t i = 1; i < n; ++i)
    {
        if (*array[i] > *tmp) // wichtig: kein Adress-Operator sondern eine Indirektion
            tmp = array[i];
    }
    return tmp;
}

Dai

groovemaster schrieb:

@Dai
Dein ursprünglicher Code war ja schon fast korrekt, bis auf die fehlende Indirektion.

float* max(float* array[], size_t n)
{
    assert(n != 0); // <cassert>
    float* tmp = array[0];
    for (size_t i = 1; i < n; ++i)
    {
        if (*array[i] > *tmp) // wichtig: kein Adress-Operator sondern eine Indirektion
            tmp = array[i];
    }
    return tmp;
}

Das musste ja passieren Nun danke ich Euch erstmal für eure Mühe, aber ich versteh immer weniger *g* was ist denn nun das hier ?

assert(n != 0); // <cassert>

Und für was steht denn nun das n wegen dem ich unsicher wurde...

Nanuq

Das n steht für die Anzahl der Elemente deines Arrays. Und die "assert"-Anweisung dient der Überprüfung, dass dein Array nicht aus 0 Elementen besteht.

Dai

Spitze ! genau das habe ich gebraucht (blödes n *g* ) vielen vielen Dank euch allen

Dai

Ich hab hier doch nochmal ein paar Fragen. Der Operator in der for-Schleife stimmt der so ++i oder gehört der doch i++. Denn mit ++i wird der Ausdruck doch vor der Verwendung inkrementiert oder ist das in dem Fall egal. Dann der Variablentyp size_t welcher ja das Ergebnis von einer sizeof Anweisung ist könnte man in dem Fall doch auch int i machen ? Zum Schluß überleg ich mir gerade ob die Funktion float* max überhaupt ein Zeiger sein muss ob da nicht auch float max(...) reichen würde. Falls nein wieso muss die Funktion auch ein Zeiger sein ?

float* max(float* array[], size_t n) 
{ 
    assert(n != 0); // <cassert> 
    float* tmp = array[0]; 
    for (size_t i = 1; i < n; ++i) 
    { 
        if (*array[i] > *tmp) // wichtig: kein Adress-Operator sondern eine Indirektion 
            tmp = array[i]; 
    } 
    return tmp; 
}

CStoll

Dai schrieb:

Der Operator in der for-Schleife stimmt der so ++i oder gehört der doch i++. Denn mit ++i wird der Ausdruck doch vor der Verwendung inkrementiert oder ist das in dem Fall egal.

In dem Fall ist es egal, da du den Wert des Ausdrucks nicht verwendest. Aber ++i ist häufig (zumindest bei eigenen Typen) schneller als i++.

Dann der Variablentyp size_t welcher ja das Ergebnis von einer sizeof Anweisung ist könnte man in dem Fall doch auch int i machen ?

size_t ist ein vorzeichenloser Ganzzahltyp - ob der wirklich gefahrlos in int umgewandelt werden kann, hängt vom Compiler ab (wenn, dann eher in unsigned int)

Zum Schluß überleg ich mir gerade ob die Funktion float* max überhaupt ein Zeiger sein muss ob da nicht auch float max(...) reichen würde. Falls nein wieso muss die Funktion auch ein Zeiger sein ?

Wenn dich nur der Wert deines Maximums interessiert, reicht ein float. Wenn dir auch wichtig ist, wo im Array dieses Maximum steht, benötigst du den Zeiger.

Dai

Ich hab mir das nochmal angeschaut, bin mir nun aber immer noch nicht sicher welche der Lösungen nun richtig ist: Kann mir da bitte jemand helfen

if( array[ i ] > *tmp )
         tmp = &array[ i ];

oder

if (*array[i] > *tmp) // wichtig: kein Adress-Operator sondern eine Indirektion
            tmp = array[i];

CStoll

Die erste Variante dürfte richtig sein (denk nochmal nach, was du tun willst, und vergleiche das mit deinen Ansätzen):

tmp = &array[ i ];

tmp bekommt die Adresse des i'ten Elements

tmp = array[i];

tmp bekommt den Inhalt des i'ten Elements

Dai

Also laut Vorgabe ...die einen Zeiger auf das Maximum der darin enthaltenen Werte zurückgibt.

Dai

Die if-Abfragen die sind ja auch beide unterschiedlich. Da stimmt dann wohl auch die 1. oder ?

if( array[ i ] > *tmp )

groovemaster

Dai schrieb:

Ich hab mir das nochmal angeschaut, bin mir nun aber immer noch nicht sicher welche der Lösungen nun richtig ist:

Beides ist für den jeweiligen Code korrekt, aber nur Version 2 für die Aufgabenstellung.

Schreiben Sie eine Funktion max, der ein Array von n Zeigern auf float-Variablen übergeben wird

float* max(float array[], size_t n)
{
    assert(n != 0); // <cassert>
    float* tmp = &array[0];
    for (size_t i = 1; i < n; ++i)
    {
        if (array[i] > *tmp) // wichtig: kein Adress-Operator sondern eine Indirektion
            tmp = &array[i];
    }
    return tmp;
}

Dies wäre eine typische Implementierung, das Problem ist nur, sie passt nicht zur Aufgabenstellung. Deshalb ist folgende Lösung korrekt.

float* max(float* array[], size_t n)
{
    assert(n != 0); // <cassert>
    float* tmp = array[0];
    for (size_t i = 1; i < n; ++i)
    {
        if (*array[i] > *tmp) // wichtig: kein Adress-Operator sondern eine Indirektion
            tmp = array[i];
    }
    return tmp;
}