Releasing virtual memory after class use in C++ VS 2015

Question

I am having some trouble with memory leak in a class I wrote. First, I measured the virtual memory used, then a run a test sequence and tried to release the memory.
PS.:The main purpose here is to avoid memory leak, so the virtual memory should be freed, but It is not happening.

The result of the test was:

VETOR mem: 7045873664 -> virtual memory used before operation

[1.0000000 2.0000000 3.0000000 4.0000000 ] [1.0000000 2.0000000 3.0000000 4.0000000 ] [2.0000000 4.0000000 6.0000000 8.0000000 ] [3.0000000 5.0000000 7.0000000 9.0000000 ] [0.0000000 0.0000000 0.0000000 0.0000000 ] [30.0000000 ]

VETOR mem: 7077228544 -> virtual memory used after operation

• this was done in VS2015 com. in Release Mode

The code of test was:

Vector A,B,C;
A = { 1, 2, 3, 4 };
B = A;
A.Print();
B.Print();

for (int i = 0; i < 500000; i++)
{
    C = A + B;
}



C.Print();
(C + 1.0).Print();
(A - B).Print();

(A*B.Transpose()).Print();

A.~Vector();
B.~Vector();
C.~Vector();

The class Vector is describe bellow:

class Vector
{

private:
int size;
long double *p;


public:
Vector()
{
    size = 0;
    p = NULL;
}

~Vector()
{
    if (p != NULL)
    {
        delete[] p;
        p = NULL;
    }
}

Vector(const int r)
{

    if (r > 0)
    {
        size = r;

        p = NULL;
        p = new long double[size];

        for (register int i = 0; i < size; i++)
        {
            //p[i] = new long double[1];
            p[i] = 0.;
        }
    }
}

// construtor cópia      
Vector(const Vector& v)
{
    size = v.size;

    p = NULL;
    p = new long double[size];

    for (register int i = 0; i < size; i++)
    {
        //p[i] = new long double[1];
        p[i] = v.p[i];
    }

}

// Initialize to array
Vector(const long double* a, int n)
{
    size = n;

    p = NULL;
    p = new long double[size];
    for (register int i = 0; i < size; i++)
    {
        //p[i] = new long double[1];
        p[i] = *a++;
    }
}

template <typename T, size_t n>
Vector(const  T(&a)[n])
{
    size = n;

    p = NULL;
    p = new long double[size];

    for (register int i = 0; i < size; i++)
    {
        p[i] = a[i];
    }
}

long double& operator()(const int r)
{
    if (p != NULL && r > 0 && r <= size)
    {
        return p[r - 1];
    }
    else
    {
        throw Exception("Subscript out of range");
    }
}

long double& operator()(const int r) const
{
    if (p != NULL && r > 0 && r <= size)
    {
        return p[r - 1];
    }
    else
    {
        throw Exception("Subscript out of range");
    }
}

// assignment operator

Vector& operator= (const Vector& v)
{
    try
    {
        if (p != NULL)
        {
            delete[] p;
            p = NULL;
        }

        size = v.size;

        if (p == NULL) p = new long double[v.size];

        for (register int i = 0; i < v.size; i++)
        {
            p[i] = v.p[i];
        }
    }
    catch (exception& e)
    {
        cout << "Vector operator=: Standard exception: " << e.what() << endl;
    }
    return *this;
}


template <typename T, size_t n>
Vector& operator= (const T(&a)[n])
{
    if (p != NULL)
    {
        delete[] p;
        p = NULL;
    }


    size = n;

    p = new long double[size];

    for (register int i = 0; i < size; i++)
    {
        p[i] = a[i];
    }

    return *this;
}


Vector& operator= (const long double& k)
{
    try
    {
        if (p != NULL)
        {
            delete[] p;
            p = NULL;
        }

        if (p == NULL)  p = new long double[size];

        for (register int i = 0; i < size; i++)
        {
            // copy the values from the vector v
            //p[i] = new long double[1];
            p[i] = k;
        }
    }
    catch (exception& e)
    {
        cout << "Vector operator=: Standard exception: " << e.what() << endl;
    }
    return *this;
}

friend Vector operator+(const Vector& a, const Vector& b)
{
    Vector Nulo(a.size);
    Nulo = 0.0;

    if (a.size == b.size)
    {
        Vector res(a.size);

        for (register int i = 0; i < a.size; i++)
        {
            res.p[i] = a.p[i] + b.p[i];
        }
        return res;
    }
    else
    {
        throw("Subscript out of range");
    }

    return Nulo;
}

// soma de escalar + vetor : somar a todos os elementos
friend Vector operator+(const long double& a, const Vector& b)
{
    Vector res(b.size);
    Vector Nulo(b.size);

    //res = Vector(b.size);
    //res.size = b.size;
    res = 0.0;

    for (register int i = 0; i < b.size; i++)
    {
        res.p[i] = a + b.p[i];
    }
    return res;
}

// soma de  vetor + escalar : somar a todos os elementos
friend Vector operator+(const Vector& b, const long double& a)
{
    Vector res, Nulo;

    res = Vector(b.size);
    res.size = b.size;
    res = 0.0;

    for (register int i = 0; i < b.size; i++)
    {
        res.p[i] = a + b.p[i];
    }
return res;
    }
}


class Exception
{
public:
    const char* msg;
    Exception(const char* arg)
        : msg(arg)
    {
    }
};