Schreiben Sie eine Funktion max, der ein Array von n Zeigern auf float-Variablen übergeben wird und die einen Zeiger auf das Maximum der darin enthaltenen Werte zurückgibt.

Nun hab ich da folgendes Quellcodefragment bezüglich der Aufgabenstellung dazu entwickelt, aber irgendwie werd ich das Gefühl nicht los das da was nicht stimmt...Kann sich das bitte mal jemand anschauen ? Danke

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

if(&array[i] > &temp)
    temp = array[i];

du vergleichst hier 2 addressen, was in dem fall wohl völliger blödsinn ist.

ausserdem gibst du einen zeiger auf ein globales objekt zurück, was bei zugriff auf selbiges mit viel glück funktioniert

float *max(float *array[])
{ float *temp=array[0];
   for (int i>(sizeof(array)\sizeof(float*) -1;i>0;i--)
    {if (*temp<*array[i])
      { temp = array[i];}
    }
  return temp;
}

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

Dann stimmt mein 1. Beispiel doch oder wie ?

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

Gruß

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

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

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

Gruß

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*

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 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!

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

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
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...

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

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.

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

oder

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

tmp = &array[ i ];

tmp bekommt die Adresse des i'ten Elements

tmp = array[i];

tmp bekommt den Inhalt des i'ten Elements

if( array[ i ] > *tmp )

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