@@ -64,6 +64,7 @@
     1.  [Headers](common.hpp)
     1.  [Containers](containers.md)
         1.  [vector](vector.cpp)
+        1.  [array](array.cpp)
         1.  [string](string.cpp)
         1.  [list](list.cpp)
         1.  [map](map.cpp)
 
@@ -0,0 +1,10 @@
+/* https://stackoverflow.com/questions/4424579/stdvector-versus-stdarray-in-c */
+
+#include "common.hpp"
+
+int main() {
+    std::array<int, 3> a{{0, 1, 2}};
+    assert(a.size() == 3);
+    // No implicit bounds checks.
+    //std::cout << a[4] << std::endl;
+}
@@ -109,30 +109,6 @@ int main() {
         compile time constants.
     */
 
-    /*
-    Get array length, find array length: http://stackoverflow.com/questions/4108313/how-do-i-find-the-length-of-an-array
-
-    Besides the C sizeof method which does not work for pointers and has lots of duplication, C++ offers:
-    */
-    {
-        // Vector class. Has overhead, but probably the best option given its flexibility.
-
-        // #array class. No overhead. Fixed size. Template based.
-        {
-            // WARN: double brackets required TODO why
-            //std::array<int, 3> a{0, 1, 2};
-
-            std::array<int, 3> a{{0, 1, 2}};
-            assert(a.size() == 3);
-        }
-
-        // Method which I don't understand.
-        {
-            //template<class T, size_t N>
-            //size_t size(T (&)[N]) { return N; }
-        }
-    }
-
     /*
     # array size from variables
 
 
@@ -220,12 +220,21 @@ int main() {
         }
 
         /* Standard library containers are not, for the most part (all?),
-         * POD because they are not trivial.
+         * POD because they are not trivial, which can be seen directly from their
+         * interface definition in the standard.
+         * https://stackoverflow.com/questions/27165436/pod-implications-for-a-struct-which-holds-an-standard-library-container
          */
         {
             static_assert(!std::is_pod<std::vector<int>>());
             static_assert(!std::is_trivially_copyable<std::vector<int>>());
         }
+
+        /* Array of POD is POD. */
+        {
+            struct C {};
+            static_assert(std::is_pod<C>());
+            static_assert(std::is_pod<C[]>());
+        }
     }
 #endif
 }
Original file line number	Diff line number	Diff line change
`@@ -220,12 +220,21 @@ int main() {`
`220`	`220`	`}`
`221`	`221`
`222`	`222`	`/* Standard library containers are not, for the most part (all?),`
`223`		`- * POD because they are not trivial.`
	`223`	`+ * POD because they are not trivial, which can be seen directly from their`
	`224`	`+ * interface definition in the standard.`
	`225`	`+ * https://stackoverflow.com/questions/27165436/pod-implications-for-a-struct-which-holds-an-standard-library-container`
`224`	`226`	`*/`
`225`	`227`	`{`
`226`	`228`	`static_assert(!std::is_pod<std::vector<int>>());`
`227`	`229`	`static_assert(!std::is_trivially_copyable<std::vector<int>>());`
`228`	`230`	`}`
	`231`	`+`
	`232`	`+ /* Array of POD is POD. */`
	`233`	`+ {`
	`234`	`+ struct C {};`
	`235`	`+ static_assert(std::is_pod<C>());`
	`236`	`+ static_assert(std::is_pod<C[]>());`
	`237`	`+ }`
`229`	`238`	`}`
`230`	`239`	`#endif`
`231`	`240`	`}`