Pagina 1 di 3 1 2 3 ultimoultimo
Visualizzazione dei risultati da 1 a 10 su 30
  1. #1

    [C++] Classe POINT

    Volevo chiedere agli esperti...cosa ne pensate della mia classe Point? Manca qualcosa? C'è qualcosa da modificare?

    Comunque ho un problemino. Vorrei fornire assieme alla classe alcune funzioni di utilità non appartenenti ad essa. Ma così come le ho messe mi danno errore! (non-member function 'double getDistance(const Point&)' cannot have cv-qualifier). Che errore è? Che errore faccio io?
    Le funzioni servono a calcolare la distanza tra due oggetti qualsiasi della classe e quindi ovviamente non possono fare parte della classe stessa! (Lo so che è una complicazione ma mi sembra più "elegante" calcolare la distanza tra due punti piuttosto che la distanza tra un punto e un'altro, anche se alla fine il risultato è lo stesso).
    Non avete capito niente?xD
    Rispiego: preferisco fare come sto tentando di fare piuttosto che creare una funzione del tipo

    double getDistance(const Point &P2) const
    {
    return sqrt(pow(x - P2.x, 2) + pow(y - P2.y, 2));
    }

    Lo trovo più "elegante". Sto facendo una cazzata?!xD.

    codice:
    #ifndef POINT_H
    #define POINT_H
    
    #include <iostream>
    using std::ostream;
    using std::istream;
    
    class Point
    {
    	friend ostream &operator<<(ostream &, const Point &);
    	friend istream &operator>>(istream &, Point &);
    	
    public:
    	Point();
    	Point(const double &, const double &);
    	~Point();
    	
    	void setX(const double &);
    	void setY(const double &);
    	double getX() const;
    	double getY() const;
    	
    private:
    	double x;
    	double y;
    };
    
    double getDistance(const Point &) const;
    double getDistance(const Point &, const Point &) const;
    
    #endif
    codice:
    #include "point.h"
    
    #include <iostream>
    using std::endl;
    using std::ostream;
    using std::istream;
    
    #include <cmath>
    using std::pow;
    using std::sqrt;
    
    ostream &operator<<(ostream &output, const Point &point)
    {
    	output << point.x << ' ' << point.y;
    	
    	return output;
    }
    
    istream &operator>>(istream &input, Point &point)
    {
    	input >> point.x;
    	input.ignore();
    	input >> point.y;
    	
    	return input;
    }
    
    Point::Point()
    {
    	setX(0);
    	setY(0);
    }
    
    Point::Point(const double &X, const double &Y)
    {
    	setX(X);
    	setY(Y);
    }
    
    Point::~Point()
    {
    	;
    }
    
    void Point::setX(const double &X)
    {
    	x = X;
    }
    
    void Point::setY(const double &Y)
    {
    	y = Y;
    }
    
    double Point::getX() const
    {
    	return x;
    }
    
    double Point::getY() const
    {
    	return y;
    }
    
    double getDistance(const Point &P1) const
    {
    	return sqrt(pow(P1.getX(), 2) + pow(P1.getY(), 2));
    }
    
    double getDistance(const Point &P1, const Point &P2) const
    {
    	return sqrt(pow(P1.getX() - P2.getX(), 2) + pow(P1.getY() - P2.getY(), 2));
    }

  2. #2
    Utente di HTML.it
    Registrato dal
    Mar 2001
    Messaggi
    117
    Perché getDistance ha un const alla fine della sua firma se non fa parte di nessuna classe?

  3. #3
    Utente di HTML.it
    Registrato dal
    May 2008
    Messaggi
    475
    codice:
    double getDistance(const Point &P1) const
    {
    	return sqrt(pow(P1.getX(), 2) + pow(P1.getY(), 2));
    }
    
    double getDistance(const Point &P1, const Point &P2) const
    {
    	return sqrt(pow(P1.getX() - P2.getX(), 2) + pow(P1.getY() - P2.getY(), 2));
    }
    Queste due funzioni le puoi trasformare in una sola, facendo così:

    codice:
    static Point Point::Zero()
    {
        return Point(0,0);
    }
    
    double getDistance(const Point &P1, const Point &P2 = Point::Zero) const
    {
    	return sqrt(pow(P1.getX() - P2.getX(), 2) + pow(P1.getY() - P2.getY(), 2));
    }
    In questo modo se non specifichi il secondo punto va in default all'origine, e quindi ti da il risultato della prima.

    In più, dovresti aggiungere virtual al distruttore: se non metti virtual succede panico e morte quando derivi la classe.
    "Let him who has understanding reckon the number of the beast, for it is a human number.
    Its number is rw-rw-rw-."

  4. #4
    Originariamente inviato da Cell
    Perché getDistance ha un const alla fine della sua firma se non fa parte di nessuna classe?
    Perché sono uno stupido!

  5. #5
    Originariamente inviato da Ippo343
    codice:
    double getDistance(const Point &P1) const
    {
    	return sqrt(pow(P1.getX(), 2) + pow(P1.getY(), 2));
    }
    
    double getDistance(const Point &P1, const Point &P2) const
    {
    	return sqrt(pow(P1.getX() - P2.getX(), 2) + pow(P1.getY() - P2.getY(), 2));
    }
    Queste due funzioni le puoi trasformare in una sola, facendo così:

    codice:
    static Point Point::Zero()
    {
        return Point(0,0);
    }
    
    double getDistance(const Point &P1, const Point &P2 = Point::Zero) const
    {
    	return sqrt(pow(P1.getX() - P2.getX(), 2) + pow(P1.getY() - P2.getY(), 2));
    }
    In questo modo se non specifichi il secondo punto va in default all'origine, e quindi ti da il risultato della prima.

    In più, dovresti aggiungere virtual al distruttore: se non metti virtual succede panico e morte quando derivi la classe.
    È meglio come hai proposto tu invece che fare un overloading delle funzioni? Come mai?

    Comunque le classi virtuali non le ho ancora studiate...! Però da quello che mi ricordo se una classe contiene funzioni virtuali non può creare oggetti: serve solo a creare delle classi derivate. Giusto? Ma io ho bisogno di creare degli oggetti Point...!

  6. #6
    Ho migliorato ulteriormente la classe Point.

    Così è una classe ben fatta? Ci sono errori grossolani? Manca qualche funzione importante?! Si può ancora migliorare?
    Grazie per i preziosi consigli! =).

    codice:
    #ifndef POINT_H
    #define POINT_H
    
    #include <iostream>
    using std::ostream;
    using std::istream;
    
    class Point
    {
    	friend ostream &operator<<(ostream &, const Point &);
    	friend istream &operator>>(istream &, Point &);
    	
    public:
    	Point operator+=(const Point &);
    	Point operator-=(const Point &);
    	bool operator==(const Point &) const;
    	bool operator!=(const Point &) const;
    	
    	Point();
    	Point(const double &, const double &);
    	~Point();
    	
    	void setX(const double &);
    	void setY(const double &);
    	void setXY(const double &, const double &);
    	double getX() const;
    	double getY() const;
    	void move(const double &, const double &);
    	
    private:
    	double x;
    	double y;
    };
    
    double getDistance(const Point &);
    double getDistance(const Point &, const Point &);
    
    #endif
    codice:
    #include "point.h"
    
    #include <iostream>
    using std::endl;
    using std::ostream;
    using std::istream;
    
    #include <cmath>
    using std::pow;
    using std::sqrt;
    
    ostream &operator<<(ostream &output, const Point &point)
    {
    	output << point.x << ' ' << point.y;
    	
    	return output;
    }
    
    istream &operator>>(istream &input, Point &point)
    {
    	input >> point.x;
    	input.ignore();
    	input >> point.y;
    	
    	return input;
    }
    
    Point Point::operator+=(const Point &P2)
    {
    	return Point(x + P2.x, y + P2.y);
    }
    
    Point Point::operator-=(const Point &P2)
    {
    	return Point(x - P2.x, y - P2.y);
    }
    
    bool Point::operator==(const Point &P2) const
    {
    	if (x == P2.x and y == P2.y) 
    	{
    		return true;
    	}
    	
    	return false;
    }
    
    bool Point::operator!=(const Point &P2) const
    {
    	if (x != P2.x or y != P2.y) 
    	{
    		return true;
    	}
    	
    	return false;
    }
    
    Point::Point()
    {
    	setX(0);
    	setY(0);
    }
    
    Point::Point(const double &X, const double &Y)
    {
    	setX(X);
    	setY(Y);
    }
    
    Point::~Point()
    {
    }
    
    void Point::setX(const double &X)
    {
    	x = X;
    }
    
    void Point::setY(const double &Y)
    {
    	y = Y;
    }
    
    void Point::setXY(const double &X, const double &Y)
    {
    	x = X;
    	y = Y;
    }
    
    double Point::getX() const
    {
    	return x;
    }
    
    double Point::getY() const
    {
    	return y;
    }
    
    void Point::move(const double &X, const double &Y)
    {
    	setX(x + X);
    	setY(y + Y);
    }
    
    double getDistance(const Point &P1)
    {
    	return sqrt(pow(P1.getX(), 2) + pow(P1.getY(), 2));
    }
    
    double getDistance(const Point &P1, const Point &P2)
    {
    	return sqrt(pow(P1.getX() - P2.getX(), 2) + pow(P1.getY() - P2.getY(), 2));
    }

  7. #7
    Utente di HTML.it L'avatar di shodan
    Registrato dal
    Jun 2001
    Messaggi
    2,381
    Volendo puoi implementare i vari operatori matematici: +, - , * , / ;
    operatori relazionali: <, <=, >, >=
    This code and information is provided "as is" without warranty of any kind, either expressed
    or implied, including but not limited to the implied warranties of merchantability and/or
    fitness for a particular purpose.

  8. #8
    Originariamente inviato da shodan
    Volendo puoi implementare i vari operatori matematici: +, - , * , / ;
    operatori relazionali: <, <=, >, >=
    Giusto! +, -, * e / li implemento subito!xD.

    Quanto a quelli relazionali... Che significa "un punto è maggiore di un altro"? Devo tener conto delle cordinate x, delle coordinate y, di tutte e due o matematicamente non hanno senso?!

  9. #9
    Utente di HTML.it L'avatar di shodan
    Registrato dal
    Jun 2001
    Messaggi
    2,381
    E' passato parecchio tempo da quando ho finito le scuole, quindi non so se in effetti abbia senso. Però potresti aver bisogno di sapere se il punto X,Y, si trovi internamente al punto A,B e questo si verifica quando:
    X < A && Y < B.
    (In realtà sarà: X < A || !(A <X) && Y < B per via dello strict weak ordering).
    Nota che non è un operatore campato in aria. Se in futuro userai una std::map per avere una mappa di punti, questo operatore è richiesto.
    vedi: http://forum.html.it/forum/showthrea...readid=1440225 per i dettagli.
    This code and information is provided "as is" without warranty of any kind, either expressed
    or implied, including but not limited to the implied warranties of merchantability and/or
    fitness for a particular purpose.

  10. #10
    Originariamente inviato da shodan
    E' passato parecchio tempo da quando ho finito le scuole, quindi non so se in effetti abbia senso. Però potresti aver bisogno di sapere se il punto X,Y, si trovi internamente al punto A,B e questo si verifica quando:
    X < A && Y < B.
    (In realtà sarà: X < A || !(A <X) && Y < B per via dello strict weak ordering).
    Nota che non è un operatore campato in aria. Se in futuro userai una std::map per avere una mappa di punti, questo operatore è richiesto.
    vedi: http://forum.html.it/forum/showthrea...readid=1440225 per i dettagli.
    Si, ha senso solo cercare se un punto è interno. Lo terrò presente ma per ora lo lascio via perché a me non serve.

    Ho implementato i miei operatori nel seguente modo, ma sembra funzionare solo l'operatore +. E inoltre a questo punto mi sembrano inutili gli operatori += e -=, sbaglio?

    codice:
    ostream &operator<<(ostream &output, const Point &point)
    {
    	output << point.x << ' ' << point.y;
    	
    	return output;
    }
    
    istream &operator>>(istream &input, Point &point)
    {
    	input >> point.x;
    	input.ignore();
    	input >> point.y;
    	
    	return input;
    }
    
    const Point &Point::operator=(const Point &P1)
    {
    	x = P1.x;
    	y = P1.y;
    	
    	return *this;
    }
    
    const Point &Point::operator+(const Point &P1)
    {
    	x += P1.x;
    	y += P1.y;
    	
    	return *this;
    }
    
    const Point &Point::operator-(const Point &P1)
    {
    	x -= P1.x;
    	y -= P1.y;
    	
    	return *this;
    }
    
    const Point &Point::operator*(const Point &P1)
    {
    	x *= P1.x;
    	y *= P1.y;
    	
    	return *this;
    }
    
    const Point &Point::operator/(const Point &P1)
    {
    	x /= P1.x;
    	y /= P1.y;
    	
    	return *this;
    }
    
    Point Point::operator+=(const Point &P2)
    {
    	return Point(x + P2.x, y + P2.y);
    }
    
    Point Point::operator-=(const Point &P2)
    {
    	return Point(x - P2.x, y - P2.y);
    }
    
    bool Point::operator==(const Point &P2) const
    {
    	if (x == P2.x and y == P2.y) 
    	{
    		return true;
    	}
    	
    	return false;
    }
    
    bool Point::operator!=(const Point &P2) const
    {
    	if (x != P2.x or y != P2.y) 
    	{
    		return true;
    	}
    	
    	return false;
    }

Permessi di invio

  • Non puoi inserire discussioni
  • Non puoi inserire repliche
  • Non puoi inserire allegati
  • Non puoi modificare i tuoi messaggi
  •  
Powered by vBulletin® Version 4.2.1
Copyright © 2024 vBulletin Solutions, Inc. All rights reserved.