[C++] Segmentation Fault anomala

[kierlo]

Ciao a tutti sto iniziando un programma abbastanza semplice e ho definito la classe dei vettori in R^2 con solo due operazioni: somma e moltiplicazione per numero reale.

Il problema è che appena uso uno dei due operatori ( + e * in questo caso) mi va in segmentation fault e non riesco a capire perchè. Posto i 3 codici, se qualcuno ha tempo di aiutarmi mi fa un grande favore. Grazie mille.

 file.h

#ifndef lumache_h
#define lumache_h

class Point
{
friend Point operator+ (const Point&,const Point&) ; //Somma fra vettori
friend Point operator* (const double &,const Point&)  ; // scalare per vettore

public:

//default ctor
Point (void);

//ctor
Point ( const double &x, const double &y);

//copy ctor
Point ( const Point & p);

//dtor
~Point();

//metodi:
void Read(); //legge

//operatori:
// Point& operator= (const Point & second) ;

private :
double x_;
double y_;
};
#endif

 FILE .cc


#include "lumache.h"
#include "iostream"
using namespace std;
//ctor
Point::Point()
{
	x_=0.;
	y_=0.;
}
//ctor a valori
Point::Point ( const double &x, const double &y) //ctor
{
	x_=x;
	y_=y;
}
// copy ctor
Point::Point( const Point & p) 
{
	x_=p.x_;
	y_=p.y_;
}
//dtor
Point::~Point()
{
	delete &x_;
	delete &y_;
}

// METODI:
void Point::Read() //legge e stampa a schermo
{
	cout << "Il punto ha coordinate : ("<< x_<<","
	<<y_<<"). \n";
}

/**** OPERATORI *****/
//operatore uguale
/*Point& Point::operator=(const Point &original)
{
x_=original.x_;
y_=original.y_;

return *this;
}
*/
// Somsma vettori
Point operator+ (const Point &first ,const Point &second)
{
	return Point( first.x_+second.x_, first.y_+second.y_);
}
Point operator* (const double &alfa, const Point &vector)
 // moltiplicazione scalare-vettore
{
return Point(vector.x_ * alfa, vector.y_ * alfa);
}

 FILE .cpp
#include<cstdlib>
#include<iostream>
#include"lumache.h"

using namespace std;

int main()
{
double x,y;

cout << "Inserisci coordinate punto : "<< endl;
cin >> x>> y;
Point r(x,y);
cout << "inserisci un numero : "<< endl;
double a;
cin >> a;
Point f(1,2);
Point g;
g = f+r;
g.Read();

exit(EXIT_SUCCESS) ;
}

Come vedete è abbastanza banale, ma non riesco a trovare l'errore. Ho seguito anche un libro di testo, ma ho problemi lo stesso.

[Torav]

Nel distruttore tenti di liberare memoria che non hai mai allocato dinamicamente.

[kierlo]

E come dovrei fare? Ci han sempre detto di fare così..
In ogni caso non dovrebbe esser la causa del problema , dato che va in segmentation fault se nel cpp metto g= f*a; mentre se non uso l'operatore * tutto va senza problemi..

[tuccio`]

hai bisogno di deallocare esplicitamente la memoria allocata quando la allochi dinamicamente (cioè utilizzando gli operatori new o new[]), e non è il tuo caso, in pratica non devi far niente, e va bene il distruttore di default

[Torav]

Originariamente inviato da kierlo

E come dovrei fare? Ci han sempre detto di fare così..
In ogni caso non dovrebbe esser la causa del problema , dato che va in segmentation fault se nel cpp metto g= f*a; mentre se non uso l'operatore * tutto va senza problemi..

Internamente viene creato un oggetto di tipo Point e viene copiato in g. Poi il distruttore viene chiamato e tenta di deallocare memoria mai allocata.