Operator [ ] rundet Wert



  • @Finnegan
    Hi, danke für Deine Mühe,
    Das File fehlt, da schalt ich nur die Files der
    betreffenden Übung zu oder ab.

    Ich muss heute Abend mal checken ob ich evtl.
    versehentlich cout.precision irgendwo vorher in meiner main
    gesetzt hatte,
    habe nicht das ganze main-File gepostet, weil ich da noch
    andere Funktionen getestet habe -- und war der (offentsichlich falschen)
    Ansicht dass der Code nicht relevant ist --- Asche auf mein Haupt 😕

    Ich werde die komplette main heute Abend posten.

    Als Compiler verwende ich den Standard C++ Compiler von Visual Studio Code 2019.

    Grüsse



  • @0xFF sagte

    Beim Zugriff mittels Operator wird der Wert auf
    die erste Nachkommastelle gerundet

    Nein, wird er nicht.

    @0xFF sagte

    wenn ich p1 so ausgeben lasse

    Tust du nicht. Du verwendest to_sting.

    x = (double)x_;

    Was soll der Cast? Ein double wird nicht doubliger.



  • Hallo Manni,

    Danke für Deinen Input,
    Da hast Du recht in allen Punkten.

    MfG, Dirk



  • Guten Abend,
    also hier ist die vollständige main:

    // A_19_6_MAIN.cpp: Definiert den Einstiegspunkt für die Konsolenanwendung.
    //
    //#include "stdafx.h"
    
    #include "general_definitions.h"
    
    #if RUN_Uebung_19_6 == 1
    
    #include <iostream>
    #include <fstream>
    #include "19_6_class_Point_3D.hpp"
    void Test_InneresProdukt_2er_Punkte( void );
    void Test_Produkt_doubleZahl_x_Punkt( void);
    void Test_Punkt_1_minus_Punkt_2(      void);
    int main( void )
    {
    	Point3D p1, p2;                      // Auruf Deufault Konstruktor
    	Point3D p3(20, 40, 60), p4(4, 6, 8); // Auruf Konstruktor mit Para.
    
    	std::cout << "\n=============== Uebung 19.6 Operatoren ==============" << std::endl
    		<< "Es wurden 4 Punkte angelegt, ihre Werte lauten:" << std::endl
    		<< "p1: " << std::setprecision(2) << p1 << std::endl
    		<< "p2: " << std::setprecision(2) << p2 << std::endl
    		<< "p3: " << std::setprecision(2) << p3 << std::endl
    		<< "p4: " << std::setprecision(2) << p4 << std::endl;
    
    	//Test Setter
    	std::cout << "\n\nManipulieren mit Setter, p1 auf 4.456, 5.34, 68" << std::endl;
    	p1.Set_x(4.456); p1.Set_y(5.34); p1.Set_z(68);
    	std::cout << "p1: " << p1 << std::endl;
    
    	//Test operator -
    	std::cout << "\n\nOperator '-=' Test: \n   p1( 4.456, 5.34, 68 )"
    		<< " -= p2( 1.00, 2.34, 8.00 ) ergibt:" << std::endl;
    	p2.Set_x(1.00); p2.Set_y(2.34); p2.Set_z(8.00);
    	p1 -= p2;  // '-=' Operator wirkt hier
    	std::cout << "   p1" << p1 << std::endl;  //Funktioniert.
    
    	//Test Operator []  ... neu hinzu bei 19.6
    	p1.Set_x(4); p1.Set_y(4.5687); p1.Set_z(5.67);
    	std::cout << "\n\nOperator '[]' Test: \n   p1( 4; 4,5687; 5,67 )"
    	<< " Jetzt Ausgabe des y-Elementes von p1:" << std::endl;
    	std::cout << "   p1[1] = " << p1[1] << std::endl;
    
    	Test_InneresProdukt_2er_Punkte();   //19.6
    
    	Test_Produkt_doubleZahl_x_Punkt();  //19.6
    
    	Test_Punkt_1_minus_Punkt_2();       //19.6
    
    	system("pause");
    	return 0;
    }
    
    void Test_InneresProdukt_2er_Punkte(void)  //Test i.O. 2.2. 2020
    {
    	//1. Überladung Operator *   ... neu hinzu bei 19.6
    	Point3D p1(2.2, 3.3, 4.4),  p2(1.1, 1.2, 2.0);
    	std::cout << "\n\nTest des inneren Produktes aus 2 Punkten im 3D-Raum"
    		<< "\n    p1( 2.2, 3.3, 4,4 ) und p2( 1.1, 1.2, 2.0 )"
    		<< "\n    Das Ergebnis muss 2.42, 3.96, 8.8 lauten:"
    	    << "\n    p1 * p2 = " << p1 * p2 << std::endl;
    }
    void Test_Produkt_doubleZahl_x_Punkt(void)  //Test i.O. 2.2. 2020
    {
    	//2. Überladung Operator *   ... neu hinzu bei 19.6
    	Point3D p1(2.2, 3.3, 4.4);
    	double z; z = 1.3;
    	std::cout << "\n\nTest Produkt double-Zahl mit Punkt im 3D-Raum"
    		<< "\n    p1( 2.2, 3.3, 4.4 ) und double-Zahle = 1.30"
    		<< "\n    Das Ergebnis muss 2.86, 4.29, 5.72 lauten:"
    		<< "\n    p1 * 1.3 = " << p1 * z << std::endl;
    }
    void Test_Punkt_1_minus_Punkt_2(void)  //Test i.O. 2.2 2020
    {
    	//2. Überladung Operator -   ... neu hinzu bei 19.6
    	Point3D p1(2.2, 3.3, 4.4), p2(1.1, 2.2, 1.39);
    	// p2 muss fuer diese Überladung als Zeiger übergeben werden
    	std::cout << "\n\nTest Subtraktion 2er Punkte im 3D-Raum"
    		<< "\n    p1( 2.2, 3.3, 4.4 ) und p2( 1.1 , 2.2 , 1.39 )"
    		<< "\n    Das Ergebnis p1 - p2 muss 1.1, 1.1, 3.01 lauten:"
    		<< "\n    p1 - p2 = " << p1 - &p2 << std::endl;
    }       //p1 wird dabei nicht verändert, wenn man das Ergebnis
            //speichern will muss man in neuen Punkt schreiben oder 
            //in p1 schreiben: p1 = p1 - p2; das geht.
    #endif //if RUN_Uebung_19_6 == 1
    // EOF
    

    ... Und hier noch der Vollständigkeit halber
    das File mit den Define-Schaltern:

    #pragma once
    #ifndef general_definitions_H_   
    #define general_definitions_H_   
    //       Fuer Uebung zu Operatoren              //
    // Uebungsbuch: "C++ Das Übungsbuch" 3. Auflage //
    // Autoren Peter Prinz, Ulla Kirch-Prinz        //
    
    #define  RUN_Uebung_19_5   0  //Thema: Point 3D
    #define  RUN_Uebung_19_6   0  //Thema: Point 3D
    #define  RUN_Uebung_19_7   1  //Thema: Student Scores
    #define  RUN_Uebung_19_8   0  
    #define  RUN_Uebung_19_9   0
    #define  RUN_Uebung_19_10  0
    
    #if RUN_Uebung_19_5 + RUN_Uebung_19_6 + RUN_Uebung_19_7 \
      + RUN_Uebung_19_8 + RUN_Uebung_19_9 + RUN_Uebung_19_10 != 1
    #  error " You Have to Choose 1 Option! "
    #endif
    
    #endif //general_definitions_H_
    // EOF
    

    Schönen Abend euch ..



  • @manni66 sagte in Operator [] rundet Wert:

    Ein double wird nicht doubliger.

    😁



  • .. Ja den fand ich auch zum schmunzeln, recht hat er !



  • @0xFF Nur ein ganz kleiner Tipp. Nimm für die Übungen in der Konsole statt system("pause") zB

    void ready()
    {
    	std::cerr << "\nready_\n";
    	std::cin.sync();
    	std::cin.get();
    }
    

    Nur um das rauszuhaben plus auf Tastendruck warten



  • Jo, Danke für den Tip!



  • @0xFF std::setprecision(2) da ist doch der Übeltäter



  • @0xFF sagte in Operator [] rundet Wert:

    exit(1);

    lass das!



  • @Swordfish sagte in

    :

    @0xFF sagte in Operator [] rundet Wert:

    exit(1);

    lass das!

    Wichtiger wäre, die Fehlerausgabe wegzulassen. Es ist nicht der Job von operator[], den Benutzer zu belehren. Die Funktion sollte eine Vorbedingung, 0 <= index && index < 3, haben, dokumentieren, und mit assert abprüfen. Das genügt. Es liegt dann in der Verantwortung des Aufrufers, einen gültigen Index zu übergeben.



  • @Bashar
    Jup, das stimmt, war eben in der Übung so gefordert, sollte aber
    bei einem Professionellen Programm anders abgefangen werden,
    Danke für den Hinweis.
    @Schlangenmensch
    Ja, ich war der Meinung std::setprecision wirkt nur bis zum nächsten
    Aufruf von cout ...


Anmelden zum Antworten