Деструктор класа, ошибка - C++ - Ответ 7779861

typedef class Vector
{
 
} Point;

Vector vec;

Point p;

#include <iostream>
using namespace std;
 
#include <math.h>
#define PI 3.14159265358979323846264338327950
 
typedef class Vector
{
    size_t n_elements;
    double* x;
 
public:
    template<class T> friend
    std::basic_ostream<T>&
        operator<<(::std::basic_ostream<T>& os, const Vector& obj )
        {
            for(size_t n = 0; n< obj.n_elements; ++n)
                os<< obj.x[n]<<", ";
            return os;
        }
    
public:
    Vector();
    Vector(const double x1, const double y1, const double z1);
    Vector(const size_t n_elem, const double n = 0);
    Vector(const Vector& rhs);
    Vector(Vector&& rhs);
 
   ~Vector() {delete[] x;}
 
    const Vector& operator=(const Vector& rhs);
    const Vector& operator=(Vector&& rhs);
    
    double& operator() (const size_t i);
    double& operator() (const size_t i) const {return x[i];}
 
    size_t Count() const;
 
    double Length() const;      
    Vector Normalize() const;   
} Point;
 
Vector::Vector()
    : n_elements(3)
    , x(new double[n_elements])
{
    for(size_t i = 0; i < n_elements; ++i)
        x[i] = 0;
}
 
Vector::Vector(const double x1, const double y1, const double z1)
    : n_elements(3)
    , x(new double[n_elements])
 
{ x[0] = x1; x[1] = y1; x[2] = z1; }
 
Vector::Vector(const size_t n_elem, const double n)
    : n_elements(n_elem)
    , x(new double[n_elements])
 
{
    for(size_t i = 0; i < n_elements; ++i)
        x[i] =  n;
}
 
Vector::Vector(const Vector& rhs)
    :n_elements(rhs.n_elements)
    ,x(new double[n_elements])
{
    for(size_t i = 0; i < n_elements; ++i)
        x[i] =  rhs.x[i];
}
 
Vector::Vector(Vector&& rhs)
    :n_elements(rhs.n_elements)
    ,x(new double[n_elements])
{
    rhs.n_elements = 0;
    rhs.x=nullptr;
}
 
const Vector& Vector::operator=(const Vector& rhs)
{
    delete[] x;
    n_elements = rhs.n_elements;
    x = new double[n_elements];
    
    for(size_t i = 0; i < n_elements; ++i)
        x[i] =  rhs.x[i];
    return *this;
}
 
const Vector& Vector::operator=(Vector&& rhs)
{
    delete[] x;
    n_elements = rhs.n_elements;
    x = rhs.x;
    
    rhs.n_elements = 0;
    rhs.x=nullptr;
    
    return *this;
}
 
 
double& Vector::operator() (const size_t i)
    { return x[i]; }
 
size_t Vector::Count() const
    { return n_elements; }
 
double Vector::Length() const
{
    double c = 0;
    for(size_t i = 0; i < n_elements; ++i)
        c += x[i]*x[i];
    return sqrt(c);
}
 
Vector Vector::Normalize() const
{
    Vector A = *this;
    for(size_t i = 0; i < n_elements; ++i)
        A.x[i] = A.x[i] / Length();
    return A;
}
 
 
int main()
{
    Point a(1,2,3);
    
    std::cout<<"point: "<< a << std::endl;
    
    a.Normalize();
    
    a = a.Normalize();
    
    Point b( Vector(4,5,6) );
    std::cout<<"point: "<< b << std::endl;
}