Short notes on 1. Early vs late binding 2. POP vs OOP 3. Namespaces

1. Early vs late binding

Early binding and late binding are concepts in programming that determine when the code is linked to the actual functions or methods it refers to.

Early binding is also known as static binding or compile-time binding. In early binding, the compiler knows the type of the object being referred to, and the specific function or method to be called is determined at compile-time. This means that the code is linked to the function or method before the program is executed, making it faster and more efficient.

Late binding is also known as dynamic binding or runtime binding. In late binding, the type of the object being referred to is not determined until runtime, and the specific function or method to be called is determined at runtime. This means that the code is linked to the function or method during runtime, making it slower and less efficient.

2. POP vs OOP

POP (Procedural Oriented Programming) and OOP (Object Oriented Programming) are two different programming paradigms.

The main differences between POP and OOP are as follows:

1. Data and functions: In POP, data and functions are treated separately, and functions manipulate the data passed to them. In OOP, data and functions are encapsulated in objects.
2. Focus: In POP, the main focus is on functions or procedures and how they are executed. In OOP, the main focus is on objects and their interactions.
3. Reusability: In POP, functions can be reused across different programs. In OOP, objects and classes can be reused across different programs.
4. Polymorphism: Polymorphism is easier to achieve in OOP, where objects can be used interchangeably with objects of other classes. In POP, achieving polymorphism requires more work and is less flexible

3. Namespaces

Namespaces are a feature in C++ that allow us to group related functions, classes, and variables under a single name. This helps in preventing naming conflicts and organizing code. We can create a namespace using the keyword "namespace" followed by the namespace name and enclosing the contents within curly braces. We can access the contents of a namespace using the scope resolution operator "::". For example:

namespace myNamespace {
   int myFunction() {
      // function code
   }
}
int main() {
   myNamespace::myFunction(); // accessing function from the namespace
   return 0;
}