双重释放或损坏(输出）和中止(核心转储）错误

帮助，我是编程新手，也是这个网站的新手，请原谅我无组织的问题。 另外，我无法理解其他现有问题对相同错误的解释。我没有使用 malloc，也没有与其他人相同的情况。最后，这是我们的最终要求之一，我希望这样的问题对我们的教授有效。

#ifndef __VECTOR_H__
#define __VECTOR_H__
#include <iostream>
#include <fstream>
#include <vector>
#include <math.h>
using namespace std;
typedef unsigned int uint;
// Modified vector class to handle basic linear algebra operations.
template<typename T>
class Vector
{
public:
vector<T> elements;
uint size;
// Constructors
Vector();
Vector(uint);
Vector(vector<T>);
Vector(string);
// Print vector elements.
void print() const;
// Save vector to a text file with string filename as parameter.
void savetxt(string) const;
// Append element after the last entry.
void push_back(T value);
// Check if vector has same size to other vector.
bool has_equal_size(Vector<T>&) const;
// Retuns dot product.
double dot(Vector<T>&) const;
// Returns Euclidean norm.
double norm() const;
// Indexing operator.
T operator[] (uint);
// Comparison operator.
bool operator== (Vector<T>&);
// Destructor.
~Vector();
};
// Default constructor
template<typename T>
Vector<T>::Vector() {};
// Constructor for zero vector with size equal to the parameter num_elements.
template<typename T>
Vector<T>::Vector(uint num_elements){
for(uint i = 0; i <= num_elements; i++){
elements.push_back(0);
}
size = num_elements;
}
// Constructor with vector data as parameter.
template<typename T>
Vector<T>::Vector(vector<T> data){
for(uint i = 0; i <= data.size(); i++){
elements.push_back(data[i]);
}
size = data.size();
}
// Constructor with txt filename as parameter.
/*
template<typename T>
Vector<T>::Vector(string filename){
ifstream infile("filename.txt");
if(infile.is_open()){
while(infile >> value)
V.push_back(value);
}
else{
cout << "File does not exists!" << endl;
exit(0);
}
infile.close();
}
*/
// Print vector elements.
template<typename T>
void Vector<T>::print() const{
for(uint i = 0; i < size; i++){
cout << elements[i] << " ";
}
cout << endl;
}
// Save vector elements to a txt file.
template<typename T>
void Vector<T>::savetxt(string filename) const{
ofstream outfile("output.txt");
if (outfile.is_open())
{
for (int i=0; i < size; i++){
outfile << elements[i] << " ";
}
}
else{
cout << "File does not exists!" << endl;
exit(0);
}
outfile.close();
}
// Check if vector has the same size as other parameter vector.
template<typename T>
bool Vector<T>::has_equal_size(Vector<T>& V) const{
if(size == V.size)
return true;
else
return false;
}
// Dot product.
template<typename T>
double Vector<T>::dot(Vector<T>& V) const{
T dotproduct = 0;
T temp;
if (has_equal_size(V) == 0){
cout << "Vectors must have equal size! ";
return 0;
}
else{
for(uint i=0; i < size; i++){
temp = elements[i] * V.elements[i];
dotproduct += temp;
}
}
return dotproduct;
}
// Euclidean norm of vector.
template<typename T>
double Vector<T>::norm() const{
double temp2;
double sum;
for(int i=0; i < size; i++){
temp2 = elements[i]*elements[i];
sum += temp2;
}
return sqrt(sum);
}
// Indexing operator.
template<typename T>
T Vector<T>::operator[] (uint index){
return elements[index]; 
}
/*
Vector componentwise sum.
*/
template<typename T>
Vector<T> operator+ (Vector<T>& V, Vector<T>& W){
Vector<T> S(0);
double sum;
if (V.has_equal_size(W) == 0){
cout << "Vectors must have equal size! ";
}
else{
for(uint i=0; i < V.size; i++){
sum = V.elements[i] + W.elements[i];
S.push_back(sum);
}
}
return S;
}
template<typename T>
Vector<T> operator+ (Vector<T>& V, T scalar){
Vector<T> S(0);
double sum;
for(uint i=0; i < V.size; i++){
sum = V.elements[i] + scalar;
S.push_back(sum);
}
return S;
}
template<typename T>
Vector<T> operator+ (T scalar, Vector<T>& V){
Vector<T> S(0);
double sum;
for(uint i=0; i < V.size; i++){
sum = scalar + V.elements[i];
S.push_back(sum);
}
return S;
}
/*
Vector componentwise difference.
*/
template<typename T>
Vector<T> operator- (Vector<T>& V, Vector<T>& W){
Vector<T> D(0);
double diff;
if (V.has_equal_size(W) == 0){
cout << "Vectors must have equal size! ";
}
else{
for(uint i=0; i < V.size; i++){
diff = V.elements[i] - W.elements[i];
D.push_back(diff);
}
}
return D;
}
template<typename T>
Vector<T> operator- (Vector<T>& V, T scalar){
Vector<T> D(0);
double diff;
for(uint i=0; i < V.size; i++){
diff = V.elements[i] - scalar;
D.push_back(diff);
}
return D;
}
template<typename T>
Vector<T> operator- (T scalar, Vector<T>& V){
Vector<T> D(0);
double diff;
for(uint i=0; i < V.size; i++){
diff = scalar - V.elements[i];
D.push_back(diff);
}
return D;
}
/*
Vector componentwise multiplication.
*/
template<typename T>
Vector<T> operator* (Vector<T>& V, Vector<T>& W){
Vector<T> P(0);
double prod;
if (V.has_equal_size(W) == 0){
cout << "Vectors must have equal size! ";
}
else{
for(uint i=0; i < V.size; i++){
prod = V.elements[i] * W.elements[i];
P.push_back(prod);
}
}
return P;
}
template<typename T>
Vector<T> operator* (Vector<T>& V, T scalar){
Vector<T> P(0);
double prod;
for(uint i=0; i < V.size; i++){
prod = V.elements[i] * scalar;
P.push_back(prod);
}
return P;
}
template<typename T>
Vector<T> operator* (T scalar, Vector<T>& V){
Vector<T> P(0);
double prod;
for(uint i=0; i < V.size; i++){
prod = scalar * V.elements[i];
P.push_back(prod);
}
return P;
}
/*
Vector componentwise division.
*/
template<typename T>
Vector<T> operator/ (Vector<T>& V, Vector<T>& W){
Vector<T> Q(0);
double quot;
if (V.has_equal_size(W) == 0){
cout << "Vectors must have equal size! ";
}
else{
for(uint i=0; i < V.size; i++){
if(W.elements[i] = 0){
cout << "Vector division not applicable! There should be no component(s) with zero value in the second vector." << endl;
}
else{
quot = V.elements[i] / W.elements[i];
Q.push_back(quot);
}
}
}
return Q;
}
template<typename T>
Vector<T> operator/ (Vector<T>& V, T scalar){
Vector<T> Q(0);
double quot;
for(uint i=0; i < V.size; i++){
if(scalar = 0){
cout << "Vector division not applicable! Scalar value must not be equal to zero." << endl;
}
else{
quot = V.elements[i] / scalar;
Q.push_back(quot);
}
}
return Q;
}
template<typename T>
void operator/ (T scalar, Vector<T>& V){
cout << "nError: Operation not supported!" << endl;
}
// Vector push_back version.
template<typename T>
void Vector<T>::push_back(T value){
elements[size] = value;
size++;
}
// Comparison ovalue.;
template<typename T>
bool Vector<T>::operator== (Vector<T>& V){
uint truth;
if (has_equal_size(V) == 0){
return false;
}
else{
for(uint i=0; i < V.size; i++){
if(elements[i] == V.elements){
truth = 1;  
}
else{
return false;
break;
}
}
if(truth == 1)
return true;
else
return false;
}
}
// Default Destructor.
template<typename T>
Vector<T>::~Vector() {};
#endif