type erasure added

Author: behnamasadi

docs/type_erasure.md

@@ -1,2 +1,112 @@
+# Type erasure
+
+Type erasure in C++ is a technique used to abstract away the specific type of an object while still allowing operations on that object to be performed in a type-safe manner. This is particularly useful in situations where you want to work with objects of different types in a uniform way without losing the benefits of strong typing.
+
+In C++, type erasure often involves creating a base class with virtual functions and derived classes that implement these functions for specific types. The base class acts as a common interface, while the derived classes handle the type-specific logic. Here's a simple example to illustrate this:
+
+### Base Interface
+
+First, you define a base class that provides a generic interface:
+
+```cpp
+class AnyType {
+public:
+    virtual ~AnyType() {}
+    // Virtual methods that can be implemented by derived classes
+};
+```
+
+### Derived Class
+
+Next, create a template-derived class that can hold any type:
+
+```cpp
+template<typename T>
+class Holder : public AnyType {
+    T value;
+public:
+    Holder(T v) : value(v) {}
+    // Methods to interact with the value
+    T getValue() const { return value; }
+    void setValue(T v) { value = v; }
+};
+```
+
+### Using Type Erasure
+
+You can then create instances of `Holder` for different types and store them in a container that holds base class pointers:
+
+```cpp
+#include <memory>
+#include <vector>
+
+int main() {
+    std::vector<std::unique_ptr<AnyType>> objects;
+
+    objects.push_back(std::make_unique<Holder<int>>(10));
+    objects.push_back(std::make_unique<Holder<double>>(3.14));
+    objects.push_back(std::make_unique<Holder<std::string>>("Hello, World!"));
+
+    // You can iterate over these objects and use them
+    // but you've lost the specific type information.
+}
+```
+
+### Limitations and Considerations
+
+- The type-specific operations need to be known and defined in the base interface, which can limit flexibility.
+- Casting or dynamic type checking might be necessary to retrieve the original type, which can introduce runtime overhead.
+- This approach doesn't preserve type information, which can be a limitation in some scenarios.
+
+Type erasure is a powerful tool in C++, especially in library design where you need to handle different types uniformly without exposing implementation details. However, it should be used judiciously as it comes with its own complexities and trade-offs.
+
+# OpenCV Example
+
+OpenCV, a popular library for computer vision, utilizes the concept of type erasure in several ways to handle a wide range of image types and matrix operations efficiently. One of the most notable implementations of type erasure in OpenCV is through the `cv::Mat` class, which is used for storing images and matrices.
+
+### The `cv::Mat` Class
+
+The `cv::Mat` class is a part of OpenCV's core module and is a good example of type erasure. It can store an image or a matrix of various data types (like `uint8`, `int`, `float`, etc.) and sizes, but the specific type information is not part of the `cv::Mat` type itself. Instead, the type information is stored internally and can be accessed at runtime.
+
+Here's how type erasure is achieved in `cv::Mat`:
+
+1. **Generalized Data Storage**: `cv::Mat` holds its data in a generic way, typically as a pointer to a memory block. The actual data type (e.g., `uint8`, `float`) is not part of the `cv::Mat` class's type.
+
+2. **Runtime Type Information**: The data type and the number of channels in the matrix are stored as part of the `cv::Mat` object, typically in an integer format. This information is used at runtime to interpret the raw data correctly.
+
+3. **Type-Safe Access**: OpenCV provides templated functions for accessing and manipulating `cv::Mat` data in a type-safe manner. These functions use the runtime type information to ensure that operations are performed correctly according to the actual data type.
+
+### Example: Using `cv::Mat`
+
+Here’s a basic example of how `cv::Mat` is typically used:
+
+```cpp
+#include <opencv2/opencv.hpp>
+
+int main() {
+    // Create a 3x3 matrix of type CV_32FC1 (32-bit floating-point, 1 channel)
+    cv::Mat mat(3, 3, CV_32FC1);
+
+    // Access and modify elements
+    mat.at<float>(0, 0) = 1.0f;
+    mat.at<float>(1, 1) = 2.0f;
+    // ... and so on
+
+    // The actual type of elements is known at runtime
+}
+```
+
+In this example, `cv::Mat` erases the type of its elements (floats, in this case) but still allows type-safe access through the `at` method, which is a templated function.
+
+### Benefits in OpenCV
+
+The use of type erasure in OpenCV, particularly in the `cv::Mat` class, provides several advantages:
+
+- **Flexibility**: It allows a single class (`cv::Mat`) to handle a wide range of image and matrix types.
+- **Ease of Use**: Users can work with different types of images and matrices without worrying about the specifics of their storage.
+- **Performance**: It enables efficient memory management and optimized performance for image processing operations, as the library can handle different types optimally.
+
+However, it's important to use the `cv::Mat` class and similar constructs correctly to avoid type mismatches and runtime errors. The design of `cv::Mat` showcases how type erasure can be used to create flexible and efficient libraries in domains like image processing and computer vision.
+
+
 
-Refs: [1](https://www.youtube.com/watch?v=jKt6A3wnDyI)