[PPL-devel] [GIT] ppl/ppl(sparse_matrices): CO_Tree: use new/delete instead of malloc/ free.

[Marco Poletti]

Module: ppl/ppl
Branch: sparse_matrices
Commit: f60831af32063af3c27545f290406252cc41ba98
URL:    http://www.cs.unipr.it/git/gitweb.cgi?p=ppl/ppl.git;a=commit;h=f60831af32063af3c27545f290406252cc41ba98

Author: Marco Poletti <poletti.marco at gmail.com>
Date:   Sun Aug  8 08:44:31 2010 +0200

CO_Tree: use new/delete instead of malloc/free.

---

 src/CO_Tree.cc         |   24 ++++++++----------------
 src/CO_Tree.inlines.hh |   29 +++++++++++------------------
 2 files changed, 19 insertions(+), 34 deletions(-)

diff --git a/src/CO_Tree.cc b/src/CO_Tree.cc
index 495e616..c7f9229 100644
--- a/src/CO_Tree.cc
+++ b/src/CO_Tree.cc
@@ -172,19 +172,16 @@ PPL::CO_Tree::init(dimension_type reserved_size1) {
   l++;
 
   reserved_size = ((dimension_type)1 << l) - 1;
-  // We use malloc() instead of operator new(), because we want to use
-  // realloc().
-  indexes = static_cast<dimension_type*>(malloc(sizeof(dimension_type)
-                                                * (reserved_size + 2)));
-  data = static_cast<data_type*>(malloc(sizeof(data_type)
-                                        * (reserved_size + 1)));
+  indexes = new dimension_type[reserved_size + 2];
+  data = static_cast<data_type*>(operator new(sizeof(data_type)
+                                              * (reserved_size + 1)));
   // Mark all pairs as unused.
   for (dimension_type i = 1; i <= reserved_size; ++i)
-    new (&(indexes[i])) dimension_type(unused_index);
+    indexes[i] = unused_index;
 
   // These are used as markers by iterators.
-  new (&(indexes[0])) dimension_type(0);
-  new (&(indexes[reserved_size + 1])) dimension_type(0);
+  indexes[0] = 0;
+  indexes[reserved_size + 1] = 0;
 
   max_depth = l;
 
@@ -200,15 +197,10 @@ PPL::CO_Tree::destroy() {
     for (dimension_type i = 1; i <= reserved_size; ++i) {
       if (indexes[i] != unused_index)
         data[i].~data_type();
-      indexes[i].~dimension_type();
     }
-    indexes[0].~dimension_type();
-    indexes[reserved_size + 1].~dimension_type();
 
-    // We use malloc()/free() instead of operator new()/operator delete()
-    // because we want to use realloc().
-    free(static_cast<void*>(indexes));
-    free(static_cast<void*>(data));
+    delete [] indexes;
+    operator delete(static_cast<void*>(data));
   }
 }
 
diff --git a/src/CO_Tree.inlines.hh b/src/CO_Tree.inlines.hh
index 5b1279d..43ee3a5 100644
--- a/src/CO_Tree.inlines.hh
+++ b/src/CO_Tree.inlines.hh
@@ -529,37 +529,30 @@ CO_Tree::rebuild_bigger_tree() {
   else {
     dimension_type new_reserved_size = reserved_size*2 + 1;
 
-    dimension_type* new_indexes
-      = static_cast<dimension_type*>(malloc(sizeof(dimension_type)
-                                            * (new_reserved_size + 2)));
+    dimension_type* new_indexes = new dimension_type[new_reserved_size + 2];
     data_type* new_data
-      = static_cast<data_type*>(malloc(sizeof(data_type)
-                                       * (new_reserved_size + 1)));
+      = static_cast<data_type*>(operator new(sizeof(data_type)
+                                             * (new_reserved_size + 1)));
 
-    new (&(new_indexes[1])) dimension_type(unused_index);
+    new_indexes[1] = unused_index;
 
     for (dimension_type i = 1, j = 2; i <= reserved_size; ++i, ++j) {
       if (indexes[i] == unused_index)
-        new (&(new_indexes[j])) dimension_type(unused_index);
+        new_indexes[j] = unused_index;
       else {
-        new (&(new_indexes[j])) dimension_type(indexes[i]);
+        new_indexes[j] = indexes[i];
         move_data_element(new_data[j], data[i]);
       }
-      indexes[i].~dimension_type();
       ++j;
-      new (&(new_indexes[j])) dimension_type(unused_index);
+      new_indexes[j] = unused_index;
     }
 
-    // These were used as markers by iterators.
-    indexes[0].~dimension_type();
-    indexes[reserved_size + 1].~dimension_type();
-
     // These are used as markers by iterators.
-    new (&(new_indexes[0])) dimension_type(0);
-    new (&(new_indexes[new_reserved_size + 1])) dimension_type(0);
+    new_indexes[0] = 0;
+    new_indexes[new_reserved_size + 1] = 0;
 
-    free(indexes);
-    free(data);
+    delete [] indexes;
+    operator delete(data);
 
     indexes = new_indexes;
     data = new_data;