C++ Fundamental

 Definition of C++

C++ is a general-purpose programming language created as an extension of the C programming language by Bjarne Stroustrup in 1985. It is known for its performance, efficiency, and flexibility, making it suitable for system/software development, game programming, real-time simulations, and more. C++ supports both procedural and object-oriented programming paradigms, providing a rich feature set that includes low-level memory manipulation and high-level abstractions.




Differences Between C and C++

  • Programming Paradigm:
    • C: Procedural programming language.
    • C++: Supports both procedural and object-oriented programming.
  • Standard Libraries:
    • C: Standard library functions such as stdio.h, stdlib.h.
    • C++: Standard Template Library (STL), which includes powerful data structures and algorithms.
  • Memory Management:
    • C: Uses malloc(), calloc(), free() for dynamic memory allocation.
    • C++: Uses new and delete operators.
  • Data Encapsulation:
    • C: Uses structures (struct) for data grouping but lacks encapsulation.
    • C++: Uses classes which provide encapsulation and data hiding.
  • Function Overloading:
    • C: Does not support function overloading.
    • C++: Supports function overloading.
  • Namespace:
    • C: No namespace feature.
    • C++: Provides namespaces to avoid name collisions.
  • Exception Handling:
    • C: Error handling is done through return codes and 'errno.'
    • C++: Provides exception handling using 'try', 'catch', and 'throw.'
  • Objects and Classes
    • Class
      A blueprint for creating objects. It encapsulates data for the object and methods to manipulate that data. Example:
      class Car {
      public:
          string brand;
          string model;
          int year;

          void displayInfo() {
              cout << brand << " " << model << " " << year << endl;
          }
      };


    • Object
      An instance of a class. It is created from a class and can access its public members. Example:
      Car myCar;
      myCar.brand = "Toyota";
      myCar.model = "Corolla";
      myCar.year = 2020;
      myCar.displayInfo();

  • Data Abstraction and Encapsulation
    • Data Abstraction
      The concept of providing only essential information and hiding the details. It helps to reduce complexity and increase efficiency.
      class Car {
      private:
          string brand;
          string model;
          int year;

      public:
          void setDetails(string b, string m, int y) {
              brand = b;
              model = m;
              year = y;
          }

          void displayInfo() {
              cout << brand << " " << model << " " << year << endl;
          }
      };

    • Encapsulation
      The bundling of data and methods that operate on that data within one unit, such as a class. This helps to protect the data from outside interference and misuse.
      // Data members are private and accessed through public methods

  • Inhericance
    Inheritance allows one class (derived class) to inherit the properties and behaviors of another class (base class), promoting code reusability and a hierarchical class structure.
    class Vehicle {
    public:
        string brand;
        void honk() {
            cout << "Honk!" << endl;
        }
    };

    class Car : public Vehicle {
    public:
        string model;
        int year;
    };


  • Polymorphism
    Polymorphism means "many shapes." In C++, it allows functions to be defined with the same name but to operate differently based on the context. There are two types:
    • Compile Time Polymorphism
      class Print {
      public:
          void show(int i) {
              cout << "Integer: " << i << endl;
          }
          void show(double d) {
              cout << "Double: " << d << endl;
          }
      };

    • Runtime Polymorphism
      class Base {
      public:
          virtual void display() {
              cout << "Base class display" << endl;
          }
      };

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

  • Dynamic Binding

    Dynamic binding, also known as late binding, occurs when the method to be executed is determined at runtime. This is typically achieved using virtual functions and pointers or references to base classes.

    Base* b;
    Derived d;
    b = &d;
    b->display();  // Calls Derived's display method

  • Message Passing

    Message passing refers to the process of invoking methods or functions on objects. In C++, this is done by calling methods on objects.

    myCar.displayInfo();  // Message passing in C++


 

0 Comments had been done yet:

Post a Comment