From 9b17656fb75c7d20609c799d31223e5e36711051 Mon Sep 17 00:00:00 2001
From: Ted Turocy <ted.turocy@gmail.com>
Date: Tue, 16 Apr 2024 11:04:31 +0100
Subject: [PATCH] Add missing DVector<T>::operator=.

DVector<T> was missing the assignment operator with RHS of another DVector<T>.
As a result, the default operator was being used, which resulted in an incorrect copying
of the pointers to the internally-allocated storage, and therefore a memory leak.
---
 src/core/dvector.h   | 22 ++++++++++++++++++++--
 src/core/dvector.imp | 16 +++++++++-------
 2 files changed, 29 insertions(+), 9 deletions(-)

diff --git a/src/core/dvector.h b/src/core/dvector.h
index b061fde0c..de52deed2 100644
--- a/src/core/dvector.h
+++ b/src/core/dvector.h
@@ -36,14 +36,32 @@ template <class T> class DVector : public PVector<T>  {
   Array<int> dvlen, dvidx;
 
 public:
-  explicit DVector(const PVector<int> &sig);
+  explicit DVector(const PVector<int> &shape);
   DVector(const DVector<T> &v);
   ~DVector() override;
 
   T &operator()(int a, int b, int c);
   const T &operator()(int a, int b, int c) const;
 
-  DVector<T> &operator=(T c);
+  DVector<T> &operator=(const DVector<T> &v)
+  {
+    if (this == &v) {
+      return *this;
+    }
+    if (dvlen != v.dvlen || dvidx != v.dvidx) {
+      throw DimensionException();
+    }
+    static_cast<Vector<T> &>(*this) = static_cast<const Vector<T> &>(v);
+    return *this;
+  }
+
+  DVector<T> &operator=(const Vector<T> &v)
+  {
+    static_cast<Vector<T> &>(*this) = v;
+    return *this;
+  }
+
+  DVector<T> &operator=(const T &c);
 };
 
 } // end namespace Gambit
diff --git a/src/core/dvector.imp b/src/core/dvector.imp
index 1bf790e29..d033d9c6f 100644
--- a/src/core/dvector.imp
+++ b/src/core/dvector.imp
@@ -31,7 +31,7 @@ namespace Gambit {
 template <class T> void DVector<T>::setindex()
 {
   int index = 1;
-  
+
   for (int i = 1; i <= dvlen.Length(); i++)  {
     dvptr[i] = this->svptr + index - 1;
     dvidx[i] = index;
@@ -43,15 +43,17 @@ template <class T> void DVector<T>::setindex()
 //    DVector<T>: Constructors, destructor, and constructive operators
 //--------------------------------------------------------------------------
 
-template <class T> DVector<T>::DVector(const PVector<int> &sig)
-  : PVector<T>((Array<int>)sig), dvlen(sig.Lengths().Length()),
-    dvidx(sig.Lengths().Length())
+template <class T>
+DVector<T>::DVector(const PVector<int> &shape)
+  : PVector<T>(static_cast<const Array<int> &>(shape)),
+    dvlen(shape.Lengths().Length()), dvidx(shape.Lengths().Length())
 {
   dvptr = new T **[dvlen.Length()];
   dvptr -= 1;
 
-  for (int i = 1; i <= dvlen.Length(); i++)
-    dvlen[i] = sig.Lengths()[i];
+  for (int i = 1; i <= dvlen.Length(); i++) {
+    dvlen[i] = shape.Lengths()[i];
+  }
 
   setindex();
 }
@@ -70,7 +72,7 @@ template <class T> DVector<T>::~DVector()
   if (dvptr)  delete [] (dvptr + 1);
 }
 
-template <class T> DVector<T> &DVector<T>::operator=(T c)
+template <class T> DVector<T> &DVector<T>::operator=(const T &c)
 {
   PVector<T>::operator=(c);
   return *this;