Templates

Ohjurot · Ohjurot · commit 1c9cfb5e22eb · 2022-12-23T23:22:43.000+01:00
diff --git a/07_SimpleCppApp/FunctionPreCacher.hpp b/07_SimpleCppApp/FunctionPreCacher.hpp
@@ -7,6 +7,7 @@
 
 namespace SimpleApp
 {
+    template<typename T>
     class FunctionPreCacher
     {
         public:
@@ -19,10 +20,13 @@ namespace SimpleApp
 
                 if (other.values)
                 {
-                    values = new int32_t[other.count];
+                    values = new T[other.count];
                     if (values)
                     {
-                        std::memcpy(values, other.values, sizeof(int32_t) * other.count);
+                        for (uint32_t i = 0; i < other.count; i++)
+                        {
+                            values[i] = other.values[i];
+                        }
                     }
                     else
                     {
@@ -39,7 +43,7 @@ namespace SimpleApp
 
                 other.values = nullptr;
             }
-            FunctionPreCacher(int32_t x, uint32_t count, int32_t(*function)(int32_t))
+            FunctionPreCacher(int32_t x, uint32_t count, T(*function)(int32_t))
             {
                 Setup(x, count, function);
             }
@@ -69,7 +73,7 @@ namespace SimpleApp
                 return *this;
             }
 
-            void Setup(int32_t x, uint32_t count, int32_t(*function)(int32_t))
+            void Setup(int32_t x, uint32_t count, T(*function)(int32_t))
             {
                 Release();
                 this->x = x;
@@ -81,7 +85,7 @@ namespace SimpleApp
                 if (function && count > 0)
                 {
                     Release();
-                    values = new int32_t[count];
+                    values = new T[count];
                     if (values)
                     {
                         for (uint32_t i = 1; i <= count; i++)
@@ -128,12 +132,12 @@ namespace SimpleApp
             {
                 return Compute();
             }
-            FunctionPreCacher& operator()(int32_t x, uint32_t count, int32_t(*function)(int32_t))
+            FunctionPreCacher& operator()(int32_t x, uint32_t count, T(*function)(int32_t))
             {
                 Setup(x, count, function);
                 return Compute();
             }
-            int32_t operator[](uint32_t index) const
+            const T& operator[](uint32_t index) const
             {
                 return At(index);
             }
@@ -143,14 +147,15 @@ namespace SimpleApp
             }
 
         private:
-            int32_t* values = nullptr;
+            T* values = nullptr;
             int32_t x = 0;
             uint32_t count = 0;
-            int32_t(*function)(int32_t x) = nullptr;
+            T(*function)(int32_t x) = nullptr;
     };
 }
 
-inline std::ostream& operator<<(std::ostream& os, const SimpleApp::FunctionPreCacher& pc)
+template<typename T>
+inline std::ostream& operator<<(std::ostream& os, const SimpleApp::FunctionPreCacher<T>& pc)
 {
     pc.Print(os);
     return os;
diff --git a/07_SimpleCppApp/PreCacherContainer.hpp b/07_SimpleCppApp/PreCacherContainer.hpp
@@ -7,6 +7,7 @@
 
 namespace SimpleApp
 {
+    template<typename T, typename Pc = FunctionPreCacher<T>>
     class PreCacherContainer
     {
         public:
@@ -27,25 +28,25 @@ namespace SimpleApp
                     os << m_preCachers[i];
                 }
             }
-            void Append(const FunctionPreCacher& pc)
+            void Append(const Pc& pc)
             {
                 if (m_usage >= 8)
                     throw std::overflow_error("PreCacherContainer Container overflown");
                 m_preCachers[m_usage++] = pc;
             }
-            void Append(FunctionPreCacher&& pc)
+            void Append(Pc&& pc)
             {
                 if (m_usage >= 8)
                     throw std::overflow_error("PreCacherContainer Container overflown");
                 m_preCachers[m_usage++] = std::move(pc);
             }
-            const FunctionPreCacher& At(int index) const
+            const Pc& At(int index) const
             {
                 if (index >= 8 || index < 0) 
                     throw std::range_error("PreCacherContainer index out of range");
                 return m_preCachers[index];
             }
-            FunctionPreCacher& At(int index)
+            Pc& At(int index)
             {
                 if (index >= 8 || index < 0)
                     throw std::range_error("PreCacherContainer index out of range");
@@ -56,32 +57,33 @@ namespace SimpleApp
                 return m_usage;
             }
 
-            PreCacherContainer& operator<<(const FunctionPreCacher& pc)
+            PreCacherContainer& operator<<(const Pc& pc)
             {
                 Append(pc);
                 return *this;
             }
-            PreCacherContainer& operator<<(FunctionPreCacher&& pc)
+            PreCacherContainer& operator<<(Pc&& pc)
             {
                 Append(std::move(pc));
                 return *this;
             }
-            const FunctionPreCacher& operator[](int index) const
+            const Pc& operator[](int index) const
             {
                 return At(index);
             }
-            FunctionPreCacher& operator[](int index)
+            Pc& operator[](int index)
             {
                 return At(index);
             }
 
         private:
-            FunctionPreCacher m_preCachers[8];
+            Pc m_preCachers[8];
             int m_usage = 0;
     };
 }
 
-inline std::ostream& operator<<(std::ostream& os, const SimpleApp::PreCacherContainer& pc)
+template<typename T>
+inline std::ostream& operator<<(std::ostream& os, const SimpleApp::PreCacherContainer<T>& pc)
 {
     pc.Print(os);
     return os;
diff --git a/07_SimpleCppApp/SimpleApp.cpp b/07_SimpleCppApp/SimpleApp.cpp
@@ -9,7 +9,7 @@ int SimpleApp::SaveMain()
     std::cout << "Enter the itterations: ";
     std::cin >> count;
 
-    PreCacherContainer cnt;
+    PreCacherContainer<Vector2> cnt;
     cnt << std::move(FunctionPreCacher(x, count, &f)())
         << std::move(FunctionPreCacher(x * 2, count, &f)())
         << std::move(FunctionPreCacher(x, count * 2, &f)())
diff --git a/07_SimpleCppApp/SimpleApp.hpp b/07_SimpleCppApp/SimpleApp.hpp
@@ -8,10 +8,34 @@
 
 namespace SimpleApp
 {
-    inline int32_t f(int32_t x)
+    struct Vector2
     {
-        return x * x + 5 * x + 5;
+        float x = 0.f, y = 0.f;
+
+        Vector2 operator+(const Vector2& rhs) const
+        {
+            return Vector2{ x + rhs.x, y + rhs.y };
+        }
+        Vector2 operator-(const Vector2& rhs) const
+        {
+            return Vector2{ x - rhs.x, y - rhs.y };
+        }
+        Vector2 operator*(const Vector2& rhs) const
+        {
+            return Vector2{ x * rhs.x, y * rhs.y };
+        }
+    };
+
+    inline Vector2 f(int32_t x)
+    {
+        return Vector2{ (float)x, (float)x } * Vector2{ 1.0f, 2.0f };
     }
 
     int SaveMain();
 }
+
+inline std::ostream& operator<<(std::ostream& os, const SimpleApp::Vector2& vec)
+{
+    os << "(" << vec.x << ", " << vec.y << ")";
+    return os;
+}

Original file line number	Diff line number	Diff line change
`@@ -7,6 +7,7 @@`
`7`	`7`
`8`	`8`	`namespace SimpleApp`
`9`	`9`	`{`
	`10`	`+ template<typename T>`
`10`	`11`	`class FunctionPreCacher`
`11`	`12`	`{`
`12`	`13`	`public:`
`@@ -19,10 +20,13 @@ namespace SimpleApp`
`19`	`20`
`20`	`21`	`if (other.values)`
`21`	`22`	`{`
`22`		`- values = new int32_t[other.count];`
	`23`	`+ values = new T[other.count];`
`23`	`24`	`if (values)`
`24`	`25`	`{`
`25`		`- std::memcpy(values, other.values, sizeof(int32_t) * other.count);`
	`26`	`+ for (uint32_t i = 0; i < other.count; i++)`
	`27`	`+ {`
	`28`	`+ values[i] = other.values[i];`
	`29`	`+ }`
`26`	`30`	`}`
`27`	`31`	`else`
`28`	`32`	`{`
`@@ -39,7 +43,7 @@ namespace SimpleApp`
`39`	`43`
`40`	`44`	`other.values = nullptr;`
`41`	`45`	`}`
`42`		`- FunctionPreCacher(int32_t x, uint32_t count, int32_t(*function)(int32_t))`
	`46`	`+ FunctionPreCacher(int32_t x, uint32_t count, T(*function)(int32_t))`
`43`	`47`	`{`
`44`	`48`	`Setup(x, count, function);`
`45`	`49`	`}`
`@@ -69,7 +73,7 @@ namespace SimpleApp`
`69`	`73`	`return *this;`
`70`	`74`	`}`
`71`	`75`
`72`		`- void Setup(int32_t x, uint32_t count, int32_t(*function)(int32_t))`
	`76`	`+ void Setup(int32_t x, uint32_t count, T(*function)(int32_t))`
`73`	`77`	`{`
`74`	`78`	`Release();`
`75`	`79`	`this->x = x;`
`@@ -81,7 +85,7 @@ namespace SimpleApp`
`81`	`85`	`if (function && count > 0)`
`82`	`86`	`{`
`83`	`87`	`Release();`
`84`		`- values = new int32_t[count];`
	`88`	`+ values = new T[count];`
`85`	`89`	`if (values)`
`86`	`90`	`{`
`87`	`91`	`for (uint32_t i = 1; i <= count; i++)`
`@@ -128,12 +132,12 @@ namespace SimpleApp`
`128`	`132`	`{`
`129`	`133`	`return Compute();`
`130`	`134`	`}`
`131`		`- FunctionPreCacher& operator()(int32_t x, uint32_t count, int32_t(*function)(int32_t))`
	`135`	`+ FunctionPreCacher& operator()(int32_t x, uint32_t count, T(*function)(int32_t))`
`132`	`136`	`{`
`133`	`137`	`Setup(x, count, function);`
`134`	`138`	`return Compute();`
`135`	`139`	`}`
`136`		`- int32_t operator[](uint32_t index) const`
	`140`	`+ const T& operator[](uint32_t index) const`
`137`	`141`	`{`
`138`	`142`	`return At(index);`
`139`	`143`	`}`
`@@ -143,14 +147,15 @@ namespace SimpleApp`
`143`	`147`	`}`
`144`	`148`
`145`	`149`	`private:`
`146`		`- int32_t* values = nullptr;`
	`150`	`+ T* values = nullptr;`
`147`	`151`	`int32_t x = 0;`
`148`	`152`	`uint32_t count = 0;`
`149`		`- int32_t(*function)(int32_t x) = nullptr;`
	`153`	`+ T(*function)(int32_t x) = nullptr;`
`150`	`154`	`};`
`151`	`155`	`}`
`152`	`156`
`153`		`-inline std::ostream& operator<<(std::ostream& os, const SimpleApp::FunctionPreCacher& pc)`
	`157`	`+template<typename T>`
	`158`	`+inline std::ostream& operator<<(std::ostream& os, const SimpleApp::FunctionPreCacher<T>& pc)`
`154`	`159`	`{`
`155`	`160`	`pc.Print(os);`
`156`	`161`	`return os;`