Use std::vector instead of new to allocate arrays

Author: RainerKuemmerle

g2o/core/block_solver.h

@@ -276,28 +276,29 @@ bool BlockSolver<Traits>::buildStructure(bool zeroBlocks) {
   numLandmarks_ = 0;
   sizePoses_ = 0;
   sizeLandmarks_ = 0;
-  int* blockPoseIndices = new int[optimizer_->indexMapping().size()];
-  int* blockLandmarkIndices = new int[optimizer_->indexMapping().size()];
 
-  for (auto* v : optimizer_->indexMapping()) {
-    int dim = v->dimension();
-    if (!v->marginalized()) {
-      v->setColInHessian(sizePoses_);
-      sizePoses_ += dim;
-      blockPoseIndices[numPoses_] = sizePoses_;
-      ++numPoses_;
-    } else {
-      v->setColInHessian(sizeLandmarks_);
-      sizeLandmarks_ += dim;
-      blockLandmarkIndices[numLandmarks_] = sizeLandmarks_;
-      ++numLandmarks_;
+  {
+    std::vector<int> blockPoseIndices(optimizer_->indexMapping().size());
+    std::vector<int> blockLandmarkIndices(optimizer_->indexMapping().size());
+
+    for (auto* v : optimizer_->indexMapping()) {
+      int dim = v->dimension();
+      if (!v->marginalized()) {
+        v->setColInHessian(sizePoses_);
+        sizePoses_ += dim;
+        blockPoseIndices[numPoses_] = sizePoses_;
+        ++numPoses_;
+      } else {
+        v->setColInHessian(sizeLandmarks_);
+        sizeLandmarks_ += dim;
+        blockLandmarkIndices[numLandmarks_] = sizeLandmarks_;
+        ++numLandmarks_;
+      }
+      sparseDim += dim;
     }
-    sparseDim += dim;
+    resize(blockPoseIndices.data(), numPoses_, blockLandmarkIndices.data(),
+           numLandmarks_, sparseDim);
   }
-  resize(blockPoseIndices, numPoses_, blockLandmarkIndices, numLandmarks_,
-         sparseDim);
-  delete[] blockLandmarkIndices;
-  delete[] blockPoseIndices;
 
   // allocate the diagonal on Hpp and Hll
   int poseIdx = 0;

g2o/solvers/csparse/csparse_wrapper.cpp

@@ -74,27 +74,21 @@ class CSparse::Impl {
       cs_nfree(numericCholesky);
       numericCholesky = nullptr;
     }
-    delete[] csWorkspace;
-    csWorkspace = nullptr;
-    delete[] csIntWorkspace;
-    csIntWorkspace = nullptr;
   }
 
   void prepareWorkspace() {
     // re-allocate the temporary workspace for cholesky
-    if (csWorkspaceSize < ccsA.n) {
-      csWorkspaceSize = csWorkspaceSize == 0 ? ccsA.n : 2 * ccsA.n;
-      delete[] csWorkspace;
-      csWorkspace = new double[csWorkspaceSize];
-      delete[] csIntWorkspace;
-      csIntWorkspace = new int[2L * csWorkspaceSize];
+    if (csWorkspace.size() < ccsA.n) {
+      const size_t desired_size = csWorkspace.empty() ? ccsA.n : 2 * ccsA.n;
+      csWorkspace.resize(desired_size);
+      csIntWorkspace.resize(2L * desired_size);
     }
   }
 
   css* symbolicDecomposition = nullptr;
   int csWorkspaceSize = 0;
-  double* csWorkspace = nullptr;
-  int* csIntWorkspace = nullptr;
+  std::vector<double> csWorkspace;
+  std::vector<int> csIntWorkspace;
   csn* numericCholesky = nullptr;
   CSparseExt ccsA;
 };
@@ -150,8 +144,8 @@ bool CSparse::solve(double* x, double* b) const {
 
   if (x != b) memcpy(x, b, pImpl_->ccsA.n * sizeof(double));
   const int ok = csparse_extension::cs_cholsolsymb(
-      &pImpl_->ccsA, x, pImpl_->symbolicDecomposition, pImpl_->csWorkspace,
-      pImpl_->csIntWorkspace);
+      &pImpl_->ccsA, x, pImpl_->symbolicDecomposition,
+      pImpl_->csWorkspace.data(), pImpl_->csIntWorkspace.data());
   return static_cast<bool>(ok);
 }
 
@@ -193,8 +187,8 @@ bool CSparse::factorize() {
   pImpl_->prepareWorkspace();
   freeFactor();
   pImpl_->numericCholesky = csparse_extension::cs_chol_workspace(
-      &pImpl_->ccsA, pImpl_->symbolicDecomposition, pImpl_->csIntWorkspace,
-      pImpl_->csWorkspace);
+      &pImpl_->ccsA, pImpl_->symbolicDecomposition,
+      pImpl_->csIntWorkspace.data(), pImpl_->csWorkspace.data());
 
   return pImpl_->numericCholesky != nullptr;
 }