# any

***

**1. Type Erasure:**

```cpp
#include <typeinfo>

struct Base {
  virtual std::string type() const = 0;
};

struct Derived1 : Base {
  std::string type() const override { return "Derived1"; }
};

struct Derived2 : Base {
  std::string type() const override { return "Derived2"; }
};

int main() {
  std::vector<Base*> objects;
  objects.push_back(new Derived1());
  objects.push_back(new Derived2());

  for (auto& obj : objects) {
    std::cout << obj->type() << std::endl;
  }

  return 0;
}
```

**2. Function Overloading:**

```cpp
#include <iostream>

int add(int a, int b) {
  return a + b;
}

double add(double a, double b) {
  return a + b;
}

std::string add(const std::string& a, const std::string& b) {
  return a + b;
}

int main() {
  std::cout << add(1, 2) << std::endl;
  std::cout << add(1.5, 2.5) << std::endl;
  std::cout << add("Hello", "World!") << std::endl;

  return 0;
}
```

**3. Default Function Parameters:**

```cpp
#include <iostream>

int sum(int a, int b, int c = 0) {
  return a + b + c;
}

int main() {
  std::cout << sum(1, 2) << std::endl;  // 3
  std::cout << sum(1, 2, 3) << std::endl;  // 6

  return 0;
}
```

**4. Variadic Templates:**

```cpp
#include <iostream>

template <typename... Args>
void print(Args... args) {
  for (auto arg : {args...}) {
    std::cout << arg << " ";
  }
  std::cout << std::endl;
}

int main() {
  print(1, 2.5, "Hello", true);  // Output: 1 2.5 Hello true

  return 0;
}
```

**5. Lambda Expressions:**

```cpp
#include <iostream>

int main() {
  auto multiply = [](int a, int b) { return a * b; };

  std::cout << multiply(2, 3) << std::endl;  // Output: 6

  return 0;
}
```

**6. Auto Keyword:**

```cpp
#include <vector>

int main() {
  auto numbers = {1, 2, 3, 4, 5};

  for (auto& number : numbers) {
    std::cout << number << " ";
  }
  std::cout << std::endl;

  return 0;
}
```

**7. Range-Based For Loops:**

```cpp
#include <vector>

int main() {
  std::vector<int> numbers = {1, 2, 3, 4, 5};

  for (int number : numbers) {
    std::cout << number << " ";
  }
  std::cout << std::endl;

  return 0;
}
```

**8. Structured Bindings:**

```cpp
#include <vector>

int main() {
  std::vector<int> numbers = {1, 2, 3, 4, 5};

  for (auto [i, number] : std::enumerate(numbers)) {
    std::cout << "Index: " << i << ", Number: " << number << std::endl;
  }

  return 0;
}
```

**9. Constexpr Functions:**

```cpp
#include <iostream>

constexpr int multiply(int a, int b) {
  return a * b;
}

int main() {
  std::cout << multiply(2, 3) << std::endl;  // Output: 6

  return 0;
}
```

**10. Template Specialization:**

```cpp
#include <iostream>

template <typename T>
void print(T value) {
  std::cout << value << std::endl;
}

template <>
void print(int value) {
  std::cout << "Integer: " << value << std::endl;
}

int main() {
  print(2.5);  // Output: 2.5
  print(10);  // Output: Integer: 10

  return 0;
}
```

**11. Static Assertions:**

```cpp
#include <iostream>

#define STATIC_ASSERT(condition) do { if (!(condition)) throw std::logic_error("Static assertion failed"); } while (0)

int main() {
  STATIC_ASSERT(1 == 1);  // No error

  // Static assertion will fail and throw an exception
  STATIC_ASSERT(1 == 2);

  return 0;
}
```

**12. Inline Namespace:**

```cpp
#include <iostream>

namespace {
  int secret = 10;
}

int main() {
  std::cout << secret << std::endl;  // Output: 10

  return 0;
}
```

**13. Move Constructors and Move Assignment Operators:**

```cpp
#include <iostream>

class MyClass {
public:
  MyClass() = default;
  MyClass(MyClass&& other) noexcept {
    std::cout << "Move constructor called" << std::endl;
    *this = std::move(other);
  }

  MyClass& operator=(MyClass&& other) noexcept {
    std::cout << "Move assignment operator called" << std::endl;
    *this = std::move(other);

    return *this;
  }

private:
  // ...
};

int main() {
  MyClass object1;
  MyClass object2(std::move(object1));  // Move constructor

  return 0;
}
```

**14. Virtual Functions:**

```cpp
#include <iostream>

class Base {
public:
  virtual void print() const = 0;
};

class Derived : public Base {
public:
  void print() const override {
    std::cout << "Derived class" << std::endl;
  }
};

int main() {
  Base* object = new Derived();
  object->print();  // Output: Derived class

  return 0;
}
```

**15. Abstract Classes:**

```cpp
#include <iostream>

class Shape {
public:
  virtual double area() const = 0;
  virtual double perimeter() const = 0;
};

class Square : public Shape {
public:
  Square(double side) : side_(side) {}

  double area() const override { return side_ * side_; }
  double perimeter() const override { return 4 * side_; }

private:
  double side_;
};

int main() {
  Shape* shape = new Square(2.0);
  std::cout << "Area: " << shape->area() << std::endl;
  std::cout << "Perimeter: " << shape->perimeter() << std::endl;

  return 0;
}
```

**16. Encapsulation:**

```cpp
#include <iostream>

class Person {
public:
  std::string name;
  int age;

private:
  // Private data members
};

int main() {
  Person person;
  person.name = "John Doe";
  person.age = 25;

  std::cout << person.name << ", " << person.age << std::endl;

  return 0;
}
```

**17. Inheritance:**

```cpp
#include <iostream>

class Animal {
public:
  std::string name;
};

class Dog : public Animal {
public:
  Dog(std::string name) : Animal() { this->name = name; }
};

int main() {
  Dog dog("Buddy");
  std::cout << dog.name << std::endl;  // Output: Buddy

  return 0;
}
```

**18. Polymorphism:**

```cpp
#include <iostream>

class Shape {
public:
  virtual double area() const = 0;
};

class Square : public Shape {
public:
  Square(double side) : side_(side) {}

  double area() const override { return side_ * side_; }

private:
  double side_;
};

class Circle : public Shape {
public:
  Circle(double radius) : radius_(radius) {}

  double area() const override { return M_PI * radius_ * radius_; }

private:
  double radius_;
};

int main() {
  Shape* shapes[] = {new Square(2.0), new Circle(3.0)};

  for (auto shape : shapes) {
    std::cout << shape->area() << std::endl;
  }

  return 0;
}
```

**19. Exception Handling:**

```cpp
#include <iostream>
#include <exception>

int divide(int a, int b) {
  if (b == 0) {
    throw std::invalid_argument("Division by zero");
  }

  return a / b;
}

int main() {
  try {
    int result = divide(10, 2);
    std::cout << result << std::endl;  // Output: 5

  } catch (std::invalid_argument& e) {
    std::cout << "Exception caught: " << e.what() << std::endl;  // Output: Exception caught: Division by zero

  }

  return 0;
}
```

**20. Templates:**

```cpp
#include <iostream>

template <typename T>
T add(T a, T b) {
  return a + b;
}

int main() {
  std::cout << add(1, 2) << std::endl;  // Output: 3
  std::cout << add(2.5, 3.5) << std::endl;  // Output: 6.0

  return 0;
}
```

**21. Iterators:**

```cpp
#include <vector>
#include <iostream>

int main() {
  std::vector<int> numbers = {1, 2, 3, 4, 5};

  for (auto it = numbers.begin(); it != numbers.end(); ++it) {
    std::cout << *it << " ";  // Output: 1 2 3 4 5
  }
  std::cout << std::endl;

  return 0;
}
```

**22. STL Algorithms:**

```cpp
#include <algorithm>
#include <vector>
#include <iostream>

int main() {
  std::vector<int> numbers = {1, 2, 3, 4, 5};

  int sum = std::accumulate(numbers.begin(), numbers.end(), 0);  // Sum all elements

  std::cout << sum << std::endl;  // Output: 15

  return 0;
}
```

**23. STL Containers:**

```cpp
#include <vector>
#include <iostream>

int main() {
  std::vector<int> numbers;

  numbers.push_back(1);
  numbers.push_back(2);
  numbers.push_back(3);

  for (auto number : numbers) {
    std::cout << number << " ";  // Output: 1 2 3
  }
  std::cout << std::endl;

  return 0;
}
```

**24. Function Pointers:**

```cpp
#include <iostream>

int add(int a, int b) {
  return a + b;
}

int main() {
  int (*function_ptr)(int, int) = &add;

  std::cout << function_ptr(2, 3) << std::endl;  // Output: 5

  return 0;
}
```

**25. Smart Pointers:**

```cpp
#include <memory>
#include <iostream>

class MyClass {
public:
  MyClass() { std::cout << "MyClass constructor called" << std::endl; }
  ~MyClass() { std::cout << "MyClass destructor called" << std::endl; }
};

int main() {
  {
    std::unique_ptr<MyClass> object = std::make_unique<MyClass>();  // Smart pointer
  }

  // MyClass destructor is automatically called when 'object' goes out of scope

  return 0;
}
```

**26. Lambda Expressions with Captures:**

```cpp
#include <iostream>

int main() {
  int value = 10;

  auto multiply = [value](int a) {  // Capture 'value' by reference
    return a * value;
  };

  std::cout << multiply(2) << std::endl;  // Output: 20

  return 0;
}
```

**27. Rvalue References:**

```cpp
#include <iostream>

int&& move(int&& value) {
  std::cout << "Rvalue reference function called" << std::endl;
  return std::move(value);
}

int main() {
  int x = 10;
  move(std::move(x));  // Rvalue reference

  return 0;
}
```

**28. Perfect Forwarding:**

```cpp
#include <iostream>

template <typename T>
void forward(T&& value) {
  std::forward<T>(value);  // Perfect forwarding
}

int main() {
  int x = 10;
  forward(std::move(x));  // Perfect forwarding

  return 0;
}
```

**29. Type Aliases:**

```cpp
#include <iostream>

using IntVector = std::vector<int>;

int main() {
  IntVector numbers;  // Type alias

  numbers.push_back(1);
  numbers.push_back(2);
  numbers.push_back(3);

  for (auto number : numbers) {
    std::cout << number << " ";  // Output: 1 2 3
  }
  std::cout << std::endl;

  return 0;
}
```

**30. Enum Classes:**

```cpp
#include <iostream>

enum class Color {
  Red,
  Green,
  Blue
};

int main() {
  Color color = Color::Red;

  switch (color) {
    case Color::Red:
      std::cout << "Red" << std::endl;
      break;

    case Color::Green:
      std::cout << "Green" << std::endl;
      break;

    case Color::Blue:
      std::cout << "Blue" << std::endl;
      break;
  }

  return 0;
}
```

**31. Bit Manipulation:**

```cpp
#include <iostream>

int main() {
  int number = 10;  // 1010 in binary

  std::cout << (number & 1) << std::endl;  // Output: 0 (LSB is 0)
  std::cout << (number | 1) << std::endl;  // Output: 11 (Sets LSB to 1)
  std::cout << (number ^ 1) << std::endl;  // Output: 11 (XORs with 1)
  std::cout << (~number) << std::endl;  // Output: 1011111111 (Negates all bits)

  return 0;
}
```

**32. Using Directive:**

```cpp
#include <iostream>
#include <vector>

using namespace std;

int main() {
  vector<int> numbers;

  numbers.push_back(1);
  numbers.push_back(2);
  numbers.push_back(3);

  for (auto number : numbers) {
    cout << number << " ";  // Output: 1 2 3
  }
  cout << endl;

  return 0;
}
```

**33. Conditional Operator (Ternary Operator):**

```cpp
#include <iostream>

int main() {
  int number = 10;

  std::string result = (number % 2 == 0) ? "Even" : "Odd";

  std::cout << result << std::endl;  // Output: Even

  return 0;
}
```

\*\*34. Range-Based For Loop with Ind