funktion , quadratisches mittel



  • ich möchte das quadratische mittel berechnen..kann mir jmd sagen wo mein Fehler liegt

    #include <iostream>
    #include <cmath>
    using namespace std;
    
    float quadratischesmittel(int n)
    {
        int i;
        float mittel, sum;
        sum = 0;
      
        for(i=0; i<n; i++)
           {
              sum = sum + (i*i);
           }
    
        mittel=sqrt(sum/n);
    
        return mittel;
    }
    
    int main()
    {
        int n;
        
        cout << "Anzahl der Werte: " << endl;
        cin >> n;
    
        float mittel=0;
        
        float x[n];
        
        for(int i=0; i<n; i++)
        {
            cout << i << " Wert: " << endl;
            cin >> x[i];
            
            mittel=quadratischesmittel(x[i]);
        }
        
        cout << "Quadratisches Mittel: " << mittel << endl;
        
        return 0;
    }
    


  • habs nur flüchtig überflogen:

    • läufte deine summe über? (was ist dein input)
    • was ist denn "falsch" (fehlermeldung, falsche werte)?


  • @5cript wenn ich für n 5 eingebe und dann 5 beliebige Zahlen wird mir mein Ergebnis nicht richtig ausgerechnet



  • wieso bildest du die quadrate vom index?

    du müsstest ein array, oder container übergeben an die funktion.



  • @5cript wie würde das gehen?



  • Ich habe ein paar Anpassungen gemacht, damit solltest du das zu deinem code wiedererkennen.
    Ich will damit sagen, das geht hübscher.

    #include <iostream>
    #include <cmath>
    #include <vector>
    using namespace std;
    
    float quadratischesmittel(std::vector <float> const& values)
    {
        float sum = 0.f;
    
        for(std::size_t i=0; i < values.size(); i++)
        {
            // quadriere die werte, nicht die indizes
            sum = sum + (values[i]*values[i]);
        }
    
        // mittle variable rausgenommen, weil nicht notwendigt
        return sqrt(sum/values.size());
    }
    
    int main()
    {
        int n;
    
        cout << "Anzahl der Werte: " << endl;
        cin >> n;
        float mittel=0.f;
    
        // vector, weil variable-length-arrays sind pfui imho. 
        std::vector <float> x;
        x.resize(n);
    
        for(int i=0; i<n; i++)
        {
            cout << i << " Wert: " << endl;
            cin >> x[i];
        }
        // einmal berechnen reicht.
        mittel=quadratischesmittel(x);
    
        cout << "Quadratisches Mittel: " << mittel << endl;
    
        return 0;
    }
    


  • @5cript danke dir



  • @5cript Aber warum nicht einfach push_back? Gerade bei Zahlen ist es doch sehr einfach die Eingabe zu terminieren. Außerdem, braucht man wirklich einen vector? Klar, Trennung von I/O und Verarbeitung... Aber eigentlich kannst doch direkt die Summe bilden beim Einlesen, bei so einem kleinen Programm.



  • This post is deleted!


  • @HarteWare Grundsätzlich: Wenn man die größe des vectors von anfang an kennt, dann in der größe erstellen oder resizen. Es tut nicht weh das immer zu machen.
    (EDIT: Zu allgemein formuliert, korrektur weiter unten)

    Denn push_back bedeutet potentiell mehrere Vergrößerungen, sprich reallokationen.

    Aber eigentlich kannst doch direkt die Summe bilden beim Einlesen, bei so einem kleinen Programm.

    Für das Beispiel? Ja kann man.
    Aber:

    • Ich hab mir 2 Minuten genommen hierfür
    • Ich wollte seine struktur erhalten, damit er im Vergleich den Unterschied sehen kann.


  • @5cript sagte in funktion , quadratisches mittel:

    @HarteWare Grundsätzlich: Wenn man die größe des vectors von anfang an kennt, dann in der größe erstellen oder resizen. Es tut nicht weh das immer zu machen.
    Denn push_back bedeutet potentiell mehrere Vergrößerungen, sprich reallokationen.

    Als allgemeiner Rat ist das denke ich schlecht. push_back ist schön doof und einfach, da kann man wenig falsch machen. Vorher Grösse ausrechnen und dann reinschreiben ist potentiell fehleranfällig, da man die Grösse dann an zwei Stellen im Code dupliziert hat. Und wenn die nicht zusammenstimmen ist aua. Wenn schon würde ich eher reserve + push_back empfehlen. Aber halt auch nur wenn es sich auszahlt an der Stelle überhaupt etwas zu optimieren.



  • @5cript sagte in funktion , quadratisches mittel:

    Denn push_back bedeutet potentiell mehrere Vergrößerungen, sprich reallokationen.

    Es existiert ja auch noch reserve, so dass man bei push_back mit deutlich weniger Allokationen auskommen kann.



  • reserve + push_back

    Ja kann man auch machen.
    Aber ich nutze reserve immer dann wenn ich genau NICHT weiß wie viel es wird, aber ich es erahnen kann.
    Also zum Beispiel um die 10k elemente, also reservier ich ~11k.

    Beispiel: Messdaten aufnehmen.

    Aber "ist weniger fehleranfällig" ist für mich schon fast leicht paranoid. "Könnte ja potentiell segfaulten". Diese Herangehensweise teil ich nicht.
    EDIT: Vorausgesetzt man alloziiert nicht an einer Stelle und befüllt an einer anderen zu anderer Zeit. Ich meinte explizit: Wenn man GANZ GENAU an DER STELLE weiß wie groß der vector wird und er direkt dort befüllt wird.
    Aber das ist hier wieder ein Punkt den ich nicht verteidigen muss. Wenn jemand lieber mit reserve arbeitet, dann ist das für mich völlig ok und würde ich nicht kritisieren.

    Man kann reserve auch einfach in existierenden code klatschen im gegensatz zu nem resize. Und potentiell Performance gewinnen



  • @5cript sagte in funktion , quadratisches mittel:

    Ich meinte explizit: Wenn man GANZ GENAU an DER STELLE weiß wie groß der vector wird und er direkt dort befüllt wird.

    Sowas ist OK (nur mMn. sinnlos):

    static const size_t N = 123;
    vec.resize(N);
    for (size_t i = 0; i < N; i++)
        vec[i] = ...;
    

    U.u. fragwürdig aber vermutlich OK:

    vec2.resize(KONSTANTE_DIE_WO_ANDERS_DEFINIERT_IST);
    for (size_t i = 0; i < KONSTANTE_DIE_WO_ANDERS_DEFINIERT_IST; i++)
        vec2[i] = ...;
    

    Sowas nicht:

    vec.resize(8);
    vec[0] = ...;
    vec[1] = ...;
    vec[2] = ...;
    vec[3] = ...;
    vec[4] = ...;
    vec[5] = ...;
    vec[6] = ...;
    vec[7] = ...;
    
    vec2.resize(123);
    for (size_t i = 0; i < 123; i++)
        vec2[i] = ...;
    

    Mache ich aber normalerweise alles wie gesagt nicht. Weil ich es für einen sinnlose Optimierung halte die vermutlich nichtmal immer eine ist.

    Kleine konstante Anzahl = initializer_list
    Spezialfall genaue oder ungefähre Anzahl bekannt und die Stelle sollte optimiert werden = reserve + push_back bzw. reserve + emplace_back
    Ansonsten = Einfach push_back/emplace_back



  • @hustbaer

    ich verstehe deinen Standpunkt nicht.
    Folgendes kommt sogar oft vor:

    std::vector <T> v(n);
    // std::copy from to
    // std::fill
    // for from to (<- das gleiche nur zu fuß)
    // ...
    

    Defensives Programmieren sehe ich viel gefährlicher. Beim Programmieren "Angst" zu haben ist keine gute Einstellung.
    Was ist so schlimm daran ein vector der korreten größe zu erzeugen und direkt zu initialisieren?



  • @5cript sagte in funktion , quadratisches mittel:

    Folgendes kommt sogar oft vor:
    std::vector <T> v(n);

    Moeglicherweise brauchst du dort keinen vector, sondern ein auto v = std::make_unique<T[]>(n) wäre ausreichend.



  • @wob sagte in funktion , quadratisches mittel:

    @5cript sagte in funktion , quadratisches mittel:

    Folgendes kommt sogar oft vor:
    std::vector <T> v(n);

    Moeglicherweise brauchst du dort keinen vector, sondern ein auto v = std::make_unique<T[]>(n) wäre ausreichend.

    ?
    Und was ist bitte der Vorteil davon?
    Man verliert doch dann das komplette interface.
    .size(), ...

    Was für ein merkwürdiger Vorschlag???
    Ich verstehe dieses Forum einfach nicht mehr.



  • @5cript sagte in funktion , quadratisches mittel:

    @hustbaer

    ich verstehe deinen Standpunkt nicht.
    Folgendes kommt sogar oft vor:

    std::vector <T> v(n);
    // std::copy from to
    // std::fill
    // for from to (<- das gleiche nur zu fuß)
    // ...
    

    Der Schnippsel unterschlägt leider den relevanten Teil.

    Defensives Programmieren sehe ich viel gefährlicher. Beim Programmieren "Angst" zu haben ist keine gute Einstellung.

    Was hat die Vermeidung von Duplizierung einer Konstante/eines Ausdrucks mit defensiv Programmieren zu tun? Ernst gemeinte Frage, ich erwarte eine ernst gemeinte Antwort wenn du darüber noch weiter diskutieren willst.

    Was ist so schlimm daran ein vector der korreten größe zu erzeugen und direkt zu initialisieren?

    Wenn man es richtig macht: nichts. Wieso zeigst du nicht mal ein Beispiel wo nicht die wichtigen Teile fehlen?



  • @hustbaer sagte in funktion , quadratisches mittel:

    Der Schnippsel unterschlägt leider den relevanten Teil.

    welcher ist?

    @hustbaer sagte in funktion , quadratisches mittel:

    Was hat die Vermeidung von Duplizierung einer Konstante/eines Ausdrucks mit defensiv Programmieren zu tun? Ernst gemeinte Frage, ich erwarte eine ernst gemeinte Antwort wenn du darüber noch weiter diskutieren willst.

    Welche Duplizierung? Wir scheinen komplett aneinander vorbei zu reden. weil was ich bisher laß war.
    "nicht resize oder den size constructor verwenden, sonder reserve, weil es könnte Fehler produzieren, wenn man danach versehentlich über die grenzen schreibt".



  • @5cript sagte in funktion , quadratisches mittel:

    @hustbaer sagte in funktion , quadratisches mittel:

    Der Schnippsel unterschlägt leider den relevanten Teil.

    welcher ist?

    Die Teile wo eingefügt (bzw. bei deiner Variante zugewiesen) wird. Von denen ist es schliesslich abhängig wie anfällig das ganze dafür ist bei Modifikationen kaputtzugehen.


Log in to reply