79:T7f5,#include #include class Vector2D { private: double x, y; public: Vector2D(double x = 0, double y = 0) : x(x), y(y) {} // Getter methods double getX() const { return x; } double getY() const { return y; } // Operator+ : Vector addition Vector2D operator+(const Vector2D& other) const { return Vector2D(x + other.x, y + other.y); } // Operator- : Vector subtraction Vector2D operator-(const Vector2D& other) const { return Vector2D(x - other.x, y - other.y); } // Operator* : Scalar multiplication Vector2D operator*(double scalar) const { return Vector2D(x * scalar, y * scalar); } // Operator== : Equality comparison bool operator==(const Vector2D& other) const { const double epsilon = 1e-9; return std::abs(x - other.x) < epsilon && std::abs(y - other.y) < epsilon; } // Operator[] : Component access (0 = x, 1 = y) double operator[](int index) const { if (index == 0) return x; if (index == 1) return y; throw std::out_of_range("Index must be 0 or 1"); } // Friend function for commutative scalar multiplication friend Vector2D operator*(double scalar, const Vector2D& v) { return v * scalar; } // Friend function for stream output friend std::ostream& operator<<(std::ostream& os, const Vector2D& v) { os << "(" << v.x << ", " << v.y << ")"; return os; } }; int main() { Vector2D a(3, 4); Vector2D b(1, 2); Vector2D c = a + b; // Vector addition: (4, 6) Vector2D d = a - b; // Vector subtraction: (2, 2) Vector2D e = a * 2.0; // Scalar multiplication: (6, 8) Vector2D f = 2.0 * a; // Commutative: (6, 8) bool equal = (a == b); // Equality check: false double xComp = a[0]; // Index access: 3 std::cout << "c = " << c << std::endl; // Output: c = (4, 6) return 0; }7a:T7ec,import math class Vector2D: def __init__(self, x: float = 0, y: float = 0): self._x = x self._y = y @property def x(self) -> float: return self._x @property def y(self) -> float: return self._y # __add__ : Vector addition (a + b) def __add__(self, other: 'Vector2D') -> 'Vector2D': return Vector2D(self._x + other._x, self._y + other._y) # __sub__ : Vector subtraction (a - b) def __sub__(self, other: 'Vector2D') -> 'Vector2D': return Vector2D(self._x - other._x, self._y - other._y) # __mul__ : Scalar multiplication (v * scalar) def __mul__(self, scalar: float) -> 'Vector2D': return Vector2D(self._x * scalar, self._y * scalar) # __rmul__ : Reverse multiplication (scalar * v) def __rmul__(self, scalar: float) -> 'Vector2D': return self.__mul__(scalar) # __eq__ : Equality comparison def __eq__(self, other: object) -> bool: if not isinstance(other, Vector2D): return NotImplemented epsilon = 1e-9 return (abs(self._x - other._x) < epsilon and abs(self._y - other._y) < epsilon) # __getitem__ : Index access (v[0], v[1]) def __getitem__(self, index: int) -> float: if index == 0: return self._x elif index == 1: return self._y raise IndexError("Index must be 0 or 1") # __repr__ : String representation def __repr__(self) -> str: return f"Vector2D({self._x}, {self._y})" # __str__ : Human-readable string def __str__(self) -> str: return f"({self._x}, {self._y})" # Usage a = Vector2D(3, 4) b = Vector2D(1, 2) c = a + b # Vector addition: (4, 6) d = a - b # Vector subtraction: (2, 2) e = a * 2.0 # Scalar multiplication: (6, 8) f = 2.0 * a # Commutative: (6, 8) equal = (a == b) # Equality check: False x_comp = a[0] # Index access: 3 print(f"c = {c}") # Output: c = (4, 6)7b:T661,// Generic class: A type-safe container public class Box { private T content; public Box(T content) { this.content = content; } public T getContent() { return content; } public void setContent(T content) { this.content = content; } } // Generic method: Works with any comparable type public class Algorithms { public static > T findMax(T a, T b) { return a.compareTo(b) >= 0 ? a : b; } // Multiple type parameters public static void printPair(K key, V value) { System.out.println(key + " -> " + value); } // Bounded wildcards for flexibility public static double sumOfNumbers(List numbers) { double sum = 0; for (Number n : numbers) { sum += n.doubleValue(); } return sum; } } // Usage - compiler enforces type safety Box stringBox = new Box<>("Hello"); String s = stringBox.getContent(); // No cast needed, type-safe Box intBox = new Box<>(42); Integer i = intBox.getContent(); // Type-safe // Compile-time type checking prevents errors // stringBox.setContent(42); // Compile error! Expected String String maxStr = Algorithms.findMax("apple", "banana"); // "banana" Integer maxInt = Algorithms.findMax(10, 20); // 20 List ints = Arrays.asList(1, 2, 3); List doubles = Arrays.asList(1.5, 2.5, 3.5); double sumInts = Algorithms.sumOfNumbers(ints); // Works with Integer double sumDoubles = Algorithms.sumOfNumbers(doubles); // Works with Double7c:T78f,#include #include #include // Class template: Type-safe container template class Box { private: T content; public: Box(T content) : content(content) {} T getContent() const { return content; } void setContent(T newContent) { content = newContent; } }; // Function template: Works with any type supporting operator< template T findMax(T a, T b) { return (a < b) ? b : a; } // Template with multiple type parameters template void printPair(const K& key, const V& value) { std::cout << key << " -> " << value << std::endl; } // Template specialization: Custom behavior for specific types template <> class Box { private: bool content; public: Box(bool content) : content(content) {} bool getContent() const { return content; } // Additional method only for bool specialization bool toggle() { content = !content; return content; } }; // SFINAE: Substitution Failure Is Not An Error // Enable function only for numeric types template typename std::enable_if::value, T>::type square(T value) { return value * value; } int main() { // Template instantiation at compile time Box stringBox("Hello"); std::string s = stringBox.getContent(); // Type-safe Box intBox(42); int i = intBox.getContent(); // Type-safe // Bool specialization has extra method Box boolBox(true); boolBox.toggle(); // Available only for Box // Function template instantiation std::string maxStr = findMax("apple", "banana"); int maxInt = findMax(10, 20); // Type deduction // SFINAE in action int squared = square(5); // Works: 25 // std::string sqStr = square("hi"); // Compile error: not arithmetic return 0; }7d:T496,**How templates/generics achieve static polymorphism:** The key insight is that generics allow you to write a single piece of code that behaves differently for different types—without runtime dispatch. When you use `Box` and `Box`, the compiler (or JIT) produces type-specific code: **C++ Templates (Full Monomorphization):** - For each distinct type instantiation, the compiler generates a completely separate copy of the code with concrete types substituted. - `Box` and `Box` become two distinct classes in the compiled binary. - Maximum performance (no indirection), but potential code bloat. **Java Generics (Type Erasure):** - Generics are a compile-time construct. At runtime, `Box` and `Box` are both just `Box

Dynamic (Runtime) Polymorphism

Dynamic (Runtime) Polymorphism