cpp: improve format of new a bit

cirosantilli · cirosantilli · commit cb27c3f2acd8 · 2019-01-11T22:43:43.000Z
diff --git a/cpp/algorithm.cpp b/cpp/algorithm.cpp
@@ -114,6 +114,15 @@ int main() {
             int v3[]{5, 5, 1, 2, 3};
             std::copy(std::begin(v1) + 1, std::end(v1) - 1, std::begin(v2) + 2);
             assert(std::equal(std::begin(v2), std::end(v2), std::begin(v3)));
+
+            // Pointer usage.
+            auto p1 = &v1[0];
+            auto p2 = &v2[0];
+            auto p3 = &v3[0];
+            std::copy(p1 + 1, p1 + 4, p2 + 2);
+            // Nah. Why.
+            // https://stackoverflow.com/questions/26909429/stdbegin-and-stdend-not-working-with-pointers-and-reference-why
+            //std::copy(std::begin(p1) + 1, std::begin(p1) + 4, std::begin(p2) + 2);
         }
 
         /* Therefore, a more elegant class approach that uses exact same syntax as arrays. */
diff --git a/cpp/new.cpp b/cpp/new.cpp
@@ -1,45 +1,26 @@
-/*
-# Dynamic memory
-
-    C++ replaces C's malloc and free with new and delete.
-
-    It is very rare to need explicit dynamic allocation. Always use:
-
-        std::vector<int> is(n)
-
-    instead of:
-
-        int *is = new int[n];
-
-    and `vector<int>(n)` is as efficient and much more flexible than `new int[N]`.
-
-    Dynamic allocation is a dangerous, and it may lead to hard to debug memory leaks.
-
-    Always encapsulate dynamic allocation inside class constructors,
-    and free it the destructor, like `std::vector` does.
-
-    Never use C style malloc on C++ code. `new` works better with classes.
-
-# new
-
-    Allocate dynamic memory.
-
-    Throw `std::bad_alloc` in case of error.
-
-# realloc
-
-    There is no direct replacement to realloc or calloc as of C++11
-    http://stackoverflow.com/questions/3482941/how-do-you-realloc-in-c
-*/
+/* # new
+ *
+ * # delete
+ *
+ * malloc and free in C++.
+ *
+ * As of C++11, you should almost never use new and delete, only:
+ *
+ * - containers like std::vector
+ * - smart pointers like unique_ptr + make_unique
+ *
+ * # realloc
+ *
+ * There is no direct replacement to realloc or calloc as of C++11
+ * https://stackoverflow.com/questions/3482941/how-do-you-realloc-in-c
+ */
 
 #include "common.hpp"
 
 int main() {
-    /*
-    Basic usage with proper error checking.
-    */
+    // Basic usage with proper error checking.
     {
-        int* ip;
+        int *ip;
         try {
             ip = new int[5];
         } catch(std::bad_alloc& ba) {
@@ -49,25 +30,24 @@ int main() {
         delete[] ip;
     }
 
-    /*
-    # delete
-
-        Free memory allocatedby `new`.
-
-        Just like C `free`:
-
-        - deleting a `NULL` does nothing.
-        - deleting any other pointer twice can lead to memory corruption
-        - deleting a pointer which was not dynamically allocated can lead to memory curruption
-
-        Destructor of object pointed to is called.
-
-        A common technique is to set a pointer to `NULL` after it is deleted,
-        to avoid deleting a pointer twice:
-        <stackoverflow.com/questions/4190703/is-it-safe-to-delete-a-null-pointer>
-
-        An even better techinque may be to use smart pointers and containers.
-    */
+    /* # delete
+     *
+     * Free memory allocated by `new`.
+     *
+     * Just like C `free`:
+     *
+     * - deleting a `NULL` does nothing.
+     * - deleting any other pointer twice can lead to memory corruption
+     * - deleting a pointer which was not dynamically allocated can lead to memory corruption
+     *
+     * Destructor of object pointed to is called.
+     *
+     * A common technique is to set a pointer to `NULL` after it is deleted,
+     * to avoid deleting a pointer twice:
+     * https://stackoverflow.com/questions/4190703/is-it-safe-to-delete-a-null-pointer
+     *
+     * An even better technique may be to use smart pointers and containers.
+     */
     {
         delete (int*)NULL;
         delete[] (int*)NULL;
@@ -90,16 +70,16 @@ int main() {
     {
         callStack.clear();
         NoBaseNoMember* cp = new NoBaseNoMember;
+        // Same.
         //NoBaseNoMember* cp = new NoBaseNoMember();
-            //SAME
         assert(callStack.back() == "NoBaseNoMember::NoBaseNoMember()");
 
         cp->method();
 
         callStack.clear();
         delete cp;
+        // Calls destructor.
         assert(callStack.back() == "NoBaseNoMember::~NoBaseNoMember()");
-            //calls destructor
     }
 
     {
@@ -141,11 +121,10 @@ int main() {
             //ip was not allocated after delete!
     }
 
-    /*
-    # calloc
-
-        An analogue effect to calloc can be attained with *value-initialization*.
-
-        http://stackoverflow.com/questions/808464/c-new-call-that-behaves-like-calloc
-    */
+    /* # calloc
+     *
+     * An analogue effect to calloc can be attained with *value-initialization*.
+     *
+     * http://stackoverflow.com/questions/808464/c-new-call-that-behaves-like-calloc
+     */
 }
