Added RAII

1 files changed, 94 insertions, 0 deletions

diff --git a/raii/all-constructors.cpp b/raii/all-constructors.cpp
new file mode 100644
index 0000000..27add07
--- /dev/null
+++ b/raii/all-constructors.cpp
@@ -0,0 +1,94 @@
+#include <iostream>
+
+class T {
+public:
+        T(const std::string& a) : name{a} {
+                std::cout << "Called constructor for " << name
+                          << " (" << this << ")" << std::endl;
+        }
+
+        ~T() {
+                std::cout << "Called destructor for " << name
+                          << " (" << this << ")" << std::endl;
+        }
+
+        T(T& other) : name{other.name} {
+                std::cout << "Copy constructor called for " << name
+                          << " (" << this << " copied from "
+                          << &other << ")" << std::endl;
+        }
+
+        T& operator=(T& other) {
+                name = other.name;
+                std::cout << "Copy assignment called for " << name
+                          << " (" << this << " copied from "
+                          << &other << ")" << std::endl;
+                return *this;
+        }
+
+        T(T&& other) : name{other.name} {
+                std::cout << "Move constructor called for " << name
+                          << " (" << this << " moved from "
+                          << &other << ")" << std::endl;
+        }
+
+        T& operator=(T&& other) {
+                name = other.name;
+                std::cout << "Move assignment called for " << name
+                          << " (" << this << " moved from "
+                          << &other << ")" << std::endl;
+                return *this;
+        }
+private:
+        std::string name;
+};
+
+T do_nothing_and_return(T x) {
+        return x;
+}
+
+T create(const std::string& str) {
+        return T(str);
+}
+
+int main() {
+        //T bad; // Compile-time error: no default constructor.
+
+        std::cout << "---------- Declaring a simple variable ----------" << std::endl;
+        T a("A");
+        std::cout << std::endl;
+
+        // Now we can see that objects are indeed scope-bound: they
+        // are destroyed when they go out of scope.
+        std::cout << "--- Declaring a variable in a temporary scope ---" << std::endl;
+        {
+                std::cout << "Entering temporary scope" << std::endl;
+                T b("short-lived");
+                std::cout << "Exiting temporary scope" << std::endl;
+        }
+        std::cout << "Out of temporary scope" << std::endl;
+        std::cout << std::endl;
+
+        std::cout << "------------ Constructing by copying ------------" << std::endl;
+        T b("B");
+        T c(b);
+        T d = b; // This is also a copy constructor, not a copy assignment
+        std::cout << std::endl;
+
+        // Copy assignment operators differ from copy constructors in that they
+        // should also clean up the resources for the copied-to object.
+        std::cout << "---------------- Copy assignment ----------------" << std::endl;
+        c = b;
+        std::cout << std::endl;
+
+        std::cout << "------------ Constructing by moving -------------" << std::endl;
+        T e(do_nothing_and_return(b));
+        std::cout << std::endl;
+
+        std::cout << "---------------- Move assignment ----------------" << std::endl;
+        e = create("E");
+        std::cout << std::endl;
+        
+        std::cout << "------------- Destroying everything -------------" << std::endl;
+        return 0;
+}