Files aufrufen



  • Hallo miteinander!

    Ich habe 8 gegebene Files, die ich in meinem main-source-code aufrufen und verwenden sollte.
    Die zwei aufgerufenen .hpp-files sind die folgenden (die sollten nicht mehr verändert werden):

    polarrose.hpp

    #ifndef POLARROSE_HPP
    #define POLARROSE_HPP
    
    #include <iostream>
    #include <vector>
    #include <utility>
    #include <cmath>
    #include <algorithm>
    #include <set>
    #include "point.hpp"
    
    class polarrose
    {
    
    private:
    	std::vector<point> _coordinates;
    
    public:
    	/** Computes the coordinates of the polar rose. */
    	void compute_coordinates();
    
    	/** Returns a reference to the coordinates, which are pairs of x/y values in [0,1]. If compute_coordinates() has not been called, the returned vector will be empty. */
        const std::vector<point>& get_coordinates() const;
    };
    
    #endif
    

    terminal_printer.hpp:

    #ifndef TERMINAL_PRINTER_HPP
    #define TERMINAL_PRINTER_HPP
    
    #include <vector>
    #include "point.hpp"
    
    class terminal_printer
    {
    
    private:
    	std::vector<point> _original_coordinates;
    	std::vector<point> _adjusted_coordinates;
    
    public:
    	/** Constructor. Sets the original coordinates, which should be displayed. */
        terminal_printer(const std::vector<point>& original_coordinates);
    
    	/** Adjusts the original coordinates for proper display on the terminal. */
    	void adjust_coordinates();
    
    	/** Displays the adjusted coordinates on the terminal. If adjust_coordinates() has not been called, the output will be empty. */
    	void print() const;
    };
    
    #endif
    

    Nun sollte ich - wie gesagt - die Funktionen, die dort definiert sind, in der main.cpp aufrufen und verwenden.
    Ich habe das wie folgt gemacht:

    #include "polarrose.hpp"
    #include "terminal_printer.hpp"
    #include <vector>
    
    int main()
    {
    	/* Include your code here. */
    	/* Both the classes polarrose and terminal_printer should be used. */
    
    	polarrose polarrose;
    	polarrose.compute_coordinates();
    	polarrose.get_coordinates();
    
    	terminal_printer printer;
    	printer.terminal_printer(const std::vector<point>& original_coordinates);
    	printer.adjust_coordinates();
    	printer.print();
    
    	return 0;
    }
    

    Ich denke, dass ich terminal_printer nicht richtig verwendet habe.
    Wie aber wäre es richtig?

    Liebe Grüsse, Thomas



  • Was ist denn deiner Meinung nach falsch, und warum?



  • Sollte das nicht eher so werden?

    int main() 
    { 
        /* Include your code here. */ 
        /* Both the classes polarrose and terminal_printer should be used. */ 
    
        polarrose rose; 
        rose.compute_coordinates(); 
        const std::vector<point> original_coordinates = rose.get_coordinates(); 
    
        terminal_printer printer(original_coordinates);
        printer.adjust_coordinates(); 
        printer.print(); 
    
        return 0; 
    }
    

    Edit: Copy & Paste ftw...



  • Die Eingabe mit dem Vektor scheint mir nicht korrekt zu sein.
    Dort hab ich auch einiges herumprobiert und herumgespielt, aber gekplappt hat's bisher leider noch nicht..



  • So sollte es richtig sein:

    #include "polarrose.hpp"
    #include "terminal_printer.hpp"
    
    int main()
    {
        /* Include your code here. */
        /* Both the classes polarrose and terminal_printer should be used. */
    
        polarrose rose;
        rose.compute_coordinates();
    
        terminal_printer printer(rose.get_coordinates());
        printer.adjust_coordinates();
        printer.print();
    
        return 0;
    }
    


  • @ inter2k3 machst du üblicherwesise gerne definitionen alla

    int int;
    double double;
    //etc?
    

    Und die Vereinfachung habe ich nur aus Versändnisgründen nicht gemacht, damit er mit dem Rückgabewert arbeiten muss...

    Was denkst du was der Compiler dir sagt, wenn du die Zeile myclass myclass nicht auskommentierst.

    class myclass{};
    
    int main() 
    { 
    	//myclass myclass; //Fehler...
    
    	myclass mycls1;
    	myclass mycls2;
    }
    


  • HighLigerBiMBam schrieb:

    @ inter2k3 machst du üblicherwesise gerne definitionen alla

    int int;
    double double;
    //etc?
    

    Öhm, nein nicht wirklich.
    Da ist c&p aus seinem code schuld 😛

    HighLigerBiMBam schrieb:

    Und die Vereinfachung habe ich nur aus Versändnisgründen nicht gemacht, damit er mit dem Rückgabewert arbeiten muss...

    Du rufst aber einen nicht existierenden default-constr. auf und danach eine nicht existierende member-funktion.



  • inter2k3 schrieb:

    Du rufst aber einen nicht existierenden default-constr. auf und danach eine nicht existierende member-funktion.

    Ach ****piep**** verflucht sei Copy&Paste 😃

    ich editiere es...



  • Vielen Dank euch beiden! 🙂

    Eigentlich erscheinen mir (jetzt, im Nachhinein) beide Codes logisch und nachvollziehbar. Besten Dank nochmals!



  • Ah, noch eine Frage.
    Das ist also wirklich falsch? :

    terminal_printer printer; 
        printer.terminal_printer(original_coordinates);
    


  • wie inter2k3 schon erwähnte hat diese Klasse keinen defaultkonstruktor und somit kann diese nicht so erstellt werden. Und die Methode Terminal_Printer existiert nicht.



  • Aber ist es nicht so, dass der default-Konstruktor "automatisch" erstellt wird?
    Oder ist das vom Editor-Programm abhängig?
    In Java ist es ja so, dass immer ein default-Konstruktor existiert.



  • Aber ist es nicht so, dass der default-Konstruktor "automatisch" erstellt wird?

    Nur wenn du keinen Konstruktor stellst. Sobald du einen hast, wird dieser nicht mehr erstellt. Das Gleiche gilt für den Kopierkonstruktor und Zuweisungsoperator.

    Es ist nicht unüblich, dass man dieses Verhalten nicht haben möchte man kann dafür eine Klasse Uncopyable erstellen, welche diese Funktionalitäten definieren aber nicht implementieren. Dies hat dann zur Folge, dass du schon beim Linken einen Fehler bei falscher Verwendung bekommst.

    class Uncopyable
    {
    protected:
    	Uncopyable(){}
    	~Uncopyable(){}
    
    private:
    	Uncopyable(const Uncopyable&);
    	Uncopyable& operator=(const Uncopyable&);
    };
    

    Eine Klasse die man nicht zuweisen, oder kopieren darf muss dann nur noch von dieser erben. Du kannst auch boost::noncopyable verwenden 😉



  • Ah stimmt.
    Bei Java ist das ja genau so.
    Vielen Dank!



  • ThomiC++ schrieb:

    Ah stimmt.
    Bei Java ist das ja genau so.
    Vielen Dank!

    Tu mir den Gefallen und vergleiche C++ nie wieder mit dem kotzigen Java.


Log in to reply