Array an Funktion übergeben

Schunki

Hallo!

Ich habe ein kleines Problem bei der Übergabe eines Arrays an eine Funktion!

Die Funktion sieht so aus:

float g_mittel(float mess[], int x){
	float hilf1=0,y;
	int i;
	for (i=1;i<x;i++){
	hilf1=hilf1+mess[i];
	}
	y=pow(hilf1,1/(x-1));
	return y;
}

Der Aufruf der Funktion im Hauptprogramm lautet

float mess[20];
printf("\n\nGeometrisches Mittel: %3.f\n\n",g_mittel(mess,i));

Irgendwie wird mir aber nur der erste Wert des Arrays übergeben! Kann mir jemand sagen wo der Feheler liegt?

Ich bedank mich schon mal im voraus!

Gruß
Andreas

wx++

Du ignorierst die erste Stelle des Arrays, vergisst, dass Ganzzahldivision Nachkommastellen abschneidet und bildest die Summe statt dem Produkt.

double g_mittel(float mess[], int x){
    double produkt = 1;
    for (int i = 0;i < x;i++){
    produkt *= mess[i];
    }
    return pow(produkt, 1.0/(x - 1));
}

Sebastian Pizer

Schunki schrieb:

Hallo!

Tach auch!

Schunki schrieb:

Ich habe ein kleines Problem bei der Übergabe eines Arrays an eine Funktion!

Sach blos! Das geht vielen anderen auch so. Ich bin mir fast sicher, dass es dazu auch ein paar Einträge bzgl "Array-Übergabe", Arrays und Zeiger in der FAQ gibt.

Schunki schrieb:

Die Funktion sieht so aus:

float g_mittel(float mess[], int x){
	float hilf1=0,y;
	int i;
	for (i=1;i<x;i++){
	hilf1=hilf1+mess[i];
	}
	y=pow(hilf1,1/(x-1));
	return y;
}

Aha. Komische Funktion. Du fängst mit Index 1 an (das zweite Element) und machst da ne Ganzzahldivision. Soll das eine "geometrische Mittelung" werden? Probier mal folgendes:

float g_mittel(float const* zeiger, int elemente)
{
  float prod = 1.f;
  for (int k=0; k<elemente; ++k) {
    prod *= zeiger[k];
  }
  return std::pow(prod,1.f/elemente);
}

Schunki schrieb:

Der Aufruf der Funktion im Hauptprogramm lautet
float mess[20];
printf("\n\nGeometrisches Mittel: %3.f\n\n",g_mittel(mess,i));

Du musst in das Array auch schon etwas reinschreiben, wa?

float mess[] = {10,1000};
float gm = g_mittel(mess,2);

Kóyaánasqatsi

Dein Problem wurde ja schon gelöst, von daher mal ein Rat: Nutze std::vector.

Sebastian Pizer

Hatte gerade Lust, es generisch und mit std::accumulate zu probieren. Hier ist das Ergebnis:

#include <cmath>
#include <functional>
#include <iterator>
#include <algorithm>
#include <numeric>

#include <iostream>
#include <vector>

template<typename T> struct tag {};

template<typename Iter, typename Accumulator>
Accumulator geomean(Iter begin, Iter end, tag<Accumulator>)
{
   using std::pow;
   return pow(
      std::accumulate(
         begin, end, Accumulator(1),
         std::multiplies<Accumulator>()
      ),
      Accumulator(1)/std::distance(begin,end)
   );
}

template<typename Iter>
inline
typename std::iterator_traits<Iter>::value_type
geomean(Iter begin, Iter end)
{
   return geomean(begin,end,
      tag<typename std::iterator_traits<Iter>::value_type>());
}

int main()
{
  std::vector<float> dings;
  dings.push_back(10);
  dings.push_back(1000);
  float  gm1 = geomean(dings.begin(),dings.end());
  double gm2 = geomean(dings.begin(),dings.end(),tag<double>());
  std::cout << gm1 << ", " << gm2 << '\n';
}

Ja, ich weiß. Das ist totaler Overkill.