Zeiger auf Maximum

Du kannst das ganze etwas vereinfachen:

float* Max( float array[], int n )
{
  float* max = array;
  for( int i = 1; i < n; ++i )
     if( array[ i ] > *max )
         max = &array[ i ];

  return max;
}

Dai

Dann stimmt mein 1. Beispiel doch oder wie ?

FireFlow

Dai schrieb:

Dann stimmt mein 1. Beispiel doch oder wie ?

Nein da vergelich´st du die Adressen und nicht die Inhalte!

Gruß

Nanuq

bis auf den eigentlichen Vergleich:
du vergleichst die Adressen:

if(&array[i] > &temp)

solltest aber die Werte vergleichen:

if( array[ i ] > *max )

Du könntest dir übrigens die Variable n sparen:

float* maximum(float* aptr)
{
	float *max = aptr;
	while(*aptr)
	{
		if(*aptr > *max)
			max = aptr;
		aptr++;
	}
	return max;
}

FireFlow

Nanuq schrieb:

Du könntest dir übrigens die Variable n sparen:

Nein geht nicht, man müsste ja so das Array mit 0 abschließen!

Gruß

Dai

Hm nun weiß jeder wieder mehr

Hat jemand ein Beispiel, das 100 pro geht, damit ich dieses Beispiel abschliessen kann und versuchen kann es zu verstehen

Wäre echt spitze. Momentan seh ich nur noch mehr Quellcode und komm durcheinander *g*

FireFlow

blablubb schrieb:

Du kannst das ganze etwas vereinfachen:

float* Max( float array[], int n )
{
  float* max = array;
  for( int i = 1; i < n; ++i )
     if( array[ i ] > *max )
         max = &array[ i ]; // oder array + i

  return max;
}

Das hier!

Gruß

Nanuq

FireFlow schrieb:

Nanuq schrieb:

Du könntest dir übrigens die Variable n sparen:

Nein geht nicht, man müsste ja so das Array mit 0 abschließen!

Gruß

Sorry, du müsstest natürlich das letzte Array-Element als "Wächter" mit 0 initialisieren. Bietet allerdings auch wieder zusätzliches Fehlerpotential, vergiss es also
blablubb's Version funktioniert schon so!

Dai

FireFlow schrieb:

Nanuq schrieb:

Du könntest dir übrigens die Variable n sparen:

Nein geht nicht, man müsste ja so das Array mit 0 abschließen!

Gruß

Dann brauch ich n also doch ? Irgendwie versteh ich nun meinen eigenen Quellcode nicht mehr Das war eh das Problem wenn ich n brauche was stellt das denn dar ich mein ich habs einfach mal so reingeschrieben vom Gefühl her aber so ganz sicher weiss ich nicht was es macht daher der Thread hier im Forum
und auch die Unsicherheit

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;
}