cpp Inheritance

Published on: 08 February 2025

Resources

  1. Video Lecture

Aim: Construct a program that demonstrates implementation of Inheritance - Single and Multilevel

Practice Exercise 6: Write a program to demonstrate the concept of single inheritance by calculating the density and relative density of fluid.

Theory:

Density ($\rho$) is the ratio of mass ($m$) of the fluid to its volume ($V$). It is given by:

$$ \rho = \frac{m}{V} $$

Relative density (also known as specific gravity) is the ratio of the density of a substance to the density of a reference material, usually water. It is given by:

$$ \text{Relative Density} = \frac{\text{Density of Object}}{\text{Reference Density}} $$

Algorithm:

  1. Define a class Density with float variables mass and volume.
  2. Create a constructor to initialize mass and volume.
  3. Define a member function mDensity() to compute mass/volume.
  4. Define a derived class RelativeDensity, inheriting from Density.
  5. Add a float variable refDensity to store the reference density.
  6. Create a constructor to initialize mass, volume, and refDensity.
  7. Define a member function rDensity() to compute mDensity()/refDensity.
  8. In main(), create an object of RelativeDensity and an object of Density.
  9. Display mass, volume, and relative density.

Code:

#include <iostream>
using namespace std;

class Density
{
public:
    float mass;
    float volume;

    Density(float m, float v) : mass(m), volume(v) {}

    float mDensity()
    {
        return mass / volume;
    }
};

class RelativeDensity : public Density
{
public:
    float refDensity;

    RelativeDensity(float m1, float v1, float r) : Density(m1, v1), refDensity(r) {}

    float rDensity()
    {
        float density = mDensity();
        return density / refDensity;
    }
};

int main()
{
    RelativeDensity rd(50, 20, 1000);
    Density bclass(30, 10);
    cout << bclass.mass << endl;
    cout << bclass.volume << endl;
    cout << rd.mass << endl;
    cout << rd.volume << endl;
    cout << rd.rDensity() << endl;
    return 0;
}

Practice Exercise 7: Write a program to demonstrate the concept of multilevel inheritance by calculating the density, relative density, and weight of fluid.

Theory:

Density ($\rho$) is the ratio of mass ($m$) of the fluid to its volume ($V$). It is given by:

$$ \rho = \frac{m}{V} $$

Relative density (also known as specific gravity) is the ratio of the density of a substance to the density of a reference material, usually water. It is given by:

$$ \text{Relative Density} = \frac{\text{Density of Object}}{\text{Reference Density}} $$

The weight of a fluid is given by:

$$ W = \text{Density} \times \text{Volume} \times g $$

Since relative density is used in weight calculation, we modify the formula as:

$$ W = \text{Relative Density} \times \text{Reference Density} \times \text{Volume} \times g $$

Algorithm:

  1. Define a class Density with float variables mass and volume.
  2. Create a constructor to initialize mass and volume.
  3. Define a function mDensity() to compute mass/volume.
  4. Define a derived class RelativeDensity, inheriting from Density.
  5. Add a float variable refDensity and a constructor to initialize it.
  6. Define a function rDensity() to compute mDensity()/refDensity.
  7. Define another derived class Weight, inheriting from RelativeDensity.
  8. Add a float variable gravity and a constructor to initialize it.
  9. Define a function fluidWeight() to compute rDensity() * refDensity * volume * gravity.
  10. In main(), create an object of Weight and display mass, volume, density, relative density, and weight.

Code:

#include <iostream>
using namespace std;

class Density
{
public:
    float mass;
    float volume;

    Density(float m, float v) : mass(m), volume(v) {}

    float mDensity()
    {
        return mass / volume;
    }
};

class RelativeDensity : public Density
{
public:
    float refDensity;

    RelativeDensity(float m1, float v1, float r) : Density(m1, v1), refDensity(r) {}

    float rDensity()
    {
        return mDensity() / refDensity;
    }
};

class Weight : public RelativeDensity
{
public:
    float gravity;

    Weight(float m1, float v1, float r, float g) : RelativeDensity(m1, v1, r), gravity(g) {}

    float fluidWeight()
    {
        return rDensity() * refDensity * volume * gravity;
    }
};

int main()
{
    Weight w(50, 20, 1000, 9.81);
    cout << "Mass: " << w.mass << " kg" << endl;
    cout << "Volume: " << w.volume << " m^3" << endl;
    cout << "Density: " << w.mDensity() << " kg/m^3" << endl;
    cout << "Relative Density: " << w.rDensity() << endl;
    cout << "Weight of Fluid: " << w.fluidWeight() << " N" << endl;
    return 0;
}

Extra Self Practice Material

Self Practice Program 1: Write a program to demonstrate the concept of single inheritance by calculating the kinetic energy of fluid flow.

Theory:

Kinetic energy in fluid mechanics refers to the energy possessed by a moving fluid due to its velocity. It is given by the equation:

$$ KE = \frac{1}{2} m v^2 $$

where $m$ is the mass of the fluid and $v$ is its velocity. Since mass flow rate ($\dot{m}$) is defined as:

$$ \dot{m} = \rho Q $$

where $\rho$ is fluid density and $Q$ is the volumetric flow rate, the kinetic energy per unit time can be expressed as:

$$ KE = \frac{1}{2} \rho Q v^2 $$

Algorithm:

  1. Start
  2. Input fluid density ($\rho$), flow rate ($Q$), and velocity ($v$)
  3. Compute mass flow rate:

$$ \dot{m} = \rho Q $$

  1. Compute kinetic energy:

$$ KE = \frac{1}{2} \rho Q v^2 $$

  1. Output the kinetic energy
  2. End

Code:

#include <iostream>
using namespace std;

class Fluid {
public:
    double density;   // Fluid density (kg/m³)
    double flowRate;  // Flow rate (m³/s)

    // Parameterized Constructor
    Fluid(double d, double q) {
        density = d;
        flowRate = q;
    }

    void showType() {
        cout << "Fluid System:" << endl;
    }

    // Calculation function for mass flow rate
    double calculateMassFlowRate() {
        return density * flowRate;
    }

    // Calculation function for momentum (takes velocity as input)
    void calculateMomentum(double velocity) {
        double massFlowRate = calculateMassFlowRate();
        double momentum = massFlowRate * velocity;
        cout << "Momentum: " << momentum << " kg·m/s" << endl;
    }
};

class KineticEnergy : public Fluid {
public:
    double velocity;  // Fluid velocity (m/s)

    // Parameterized Constructor
    KineticEnergy(double d, double q, double v) : Fluid(d, q) {
        velocity = v;
    }

    // Calculation function for kinetic energy
    void calculateKE() {
        double KE = 0.5 * density * flowRate * velocity * velocity;
        cout << "Kinetic Energy: " << KE << " Joules" << endl;
    }
};

int main() {
    // Creating an object using the parameterized constructor
    KineticEnergy fluidSystem(1000, 0.05, 3);  // density, flow rate, velocity
    fluidSystem.showType();

    // Calling calculation functions from Fluid class
    cout << "Mass Flow Rate: " << fluidSystem.calculateMassFlowRate() << " kg/s" << endl;
    fluidSystem.calculateMomentum(fluidSystem.velocity);  // Call momentum calculation

    // Calling calculation function from derived class
    fluidSystem.calculateKE();  

    return 0;
}

Self Practice Program 2: Write a program to demonstrate multilevel inheritance by calculating the kinetic and potential energy of fluid flow.

Theory:

Fluid systems exhibit both kinetic energy (KE) due to motion and potential energy (PE) due to height.

  • Fluid Class:
  • Represents a fluid with density and flow rate.

  • Uses a constructor to initialize properties.

  • KineticEnergy Class (Inherits from Fluid):

  • Adds velocity and initializes it using a constructor.

  • Computes kinetic energy using:
    $$ KE = \frac{1}{2} \times \text{density} \times \text{flowRate} \times \text{velocity}^2 $$

  • PotentialEnergy Class (Inherits from KineticEnergy):

  • Adds height and initializes it using a constructor.
  • Computes potential energy using:
    $$ PE = \text{density} \times \text{flowRate} \times 9.81 \times \text{height} $$

Algorithm:

  1. Start
  2. Define Fluid class with density and flowRate, initialized via constructor.
  3. Define KineticEnergy class (inherits Fluid), adding velocity and calculateKE():
    $$ KE = \frac{1}{2} \times \text{density} \times \text{flowRate} \times \text{velocity}^2 $$
  4. Define PotentialEnergy class (inherits KineticEnergy), adding height and calculatePE():
    $$ PE = \text{density} \times \text{flowRate} \times 9.81 \times \text{height} $$
  5. Instantiate PotentialEnergy in main() with constructor values.
  6. Call showType(), calculateKE(), and calculatePE().
  7. End

Code:

#include <iostream>
using namespace std;

class Fluid {
public:
    double density;   // Fluid density (kg/m³)
    double flowRate;  // Flow rate (m³/s)

    // Constructor to initialize fluid properties
    Fluid(double d, double q) : density(d), flowRate(q) {}

    void showType() {
        cout << "Fluid System:\n";
    }
};

class KineticEnergy : public Fluid {
public:
    double velocity;  // Fluid velocity (m/s)

    // Constructor to initialize fluid properties and velocity
    KineticEnergy(double d, double q, double v) : Fluid(d, q), velocity(v) {}

    double calculateKE() {
        return 0.5 * density * flowRate * velocity * velocity;
    }
};

class PotentialEnergy : public KineticEnergy {
public:
    double height;  // Height (m)

    // Constructor to initialize all properties including height
    PotentialEnergy(double d, double q, double v, double h) 
        : KineticEnergy(d, q, v), height(h) {}

    void calculatePE() {
        double PE = density * flowRate * 9.81 * height;
        cout << "Potential Energy: " << PE << " Joules\n";
    }
};

int main() {
    // Creating an object with constructor initialization
    PotentialEnergy fluidSystem(1000, 0.05, 3, 10);  // Density, Flow rate, Velocity, Height

    fluidSystem.showType();
    cout << "Kinetic Energy: " << fluidSystem.calculateKE() << " Joules\n";
    fluidSystem.calculatePE();

    return 0;
}

Aim: Construct a program that demonstrates implementation of Inheritance - Multiple, Hierarchical and Hybrid.

Practice Exercise 8: Write a program to demonstrate the concept of multiple inheritance by calculating the density, relative density, and weight of fluid.

Theory:

Density ($\rho$) is the ratio of mass ($m$) of the fluid to its volume ($V$). It is given by:

$$ \rho = \frac{m}{V} $$

Relative density (also known as specific gravity) is the ratio of the density of a substance to the density of a reference material, usually water. It is given by:

$$ \text{Relative Density} = \frac{\text{Density of Object}}{\text{Reference Density}} $$

The weight of a fluid is given by:

$$ W = \text{Density} \times \text{Volume} \times g $$

Using relative density, the formula modifies to:

$$ W = \text{Relative Density} \times \text{Reference Density} \times \text{Volume} \times g $$

Algorithm:

  1. Define a class Density with float variables mass and volume.
  2. Create a constructor to initialize mass and volume.
  3. Define a function mDensity() to compute mass/volume.
  4. Define another class RelativeDensity with a float variable refDensity.
  5. Create a constructor to initialize refDensity.
  6. Define a function rDensity() to compute density/refDensity.
  7. Define a derived class Weight, inheriting from both Density and RelativeDensity.
  8. Add a float variable gravity and a constructor to initialize it.
  9. Define a function fluidWeight() to compute rDensity(mDensity()) * refDensity * volume * gravity.
  10. In main(), create an object of Weight and display mass, volume, density, relative density, and weight.

Code:

#include <iostream>
using namespace std;

class Density
{
public:
    float mass;
    float volume;

    Density(float m, float v) : mass(m), volume(v) {}

    float mDensity()
    {
        return mass / volume;
    }
};

class RelativeDensity
{
public:
    float refDensity;

    RelativeDensity(float r) : refDensity(r) {}

    float rDensity(float density)
    {
        return density / refDensity;
    }
};

class Weight : public Density, public RelativeDensity
{
public:
    float gravity;

    Weight(float m1, float v1, float r, float g) : Density(m1, v1), RelativeDensity(r), gravity(g) {}

    float fluidWeight()
    {
        float density = mDensity();
        return rDensity(density) * refDensity * volume * gravity;
    }
};

int main()
{
    Weight w(50, 20, 1000, 9.81);
    cout << "Mass: " << w.mass << " kg" << endl;
    cout << "Volume: " << w.volume << " m^3" << endl;
    cout << "Density: " << w.mDensity() << " kg/m^3" << endl;
    cout << "Relative Density: " << w.rDensity(w.mDensity()) << endl;
    cout << "Weight of Fluid: " << w.fluidWeight() << " N" << endl;
    return 0;
}

Practice Exercise 9: Write a program to demonstrate the concept of hierarchical inheritance by calculating the density, relative density, and weight of fluid.

Theory:

Density ($\rho$) is the ratio of mass ($m$) of the fluid to its volume ($V$). It is given by:

$$ \rho = \frac{m}{V} $$

Relative density (also known as specific gravity) is the ratio of the density of a substance to the density of a reference material, usually water. It is given by:

$$ \text{Relative Density} = \frac{\text{Density of Object}}{\text{Reference Density}} $$

The weight of a fluid is given by:

$$ W = \text{Density} \times \text{Volume} \times g $$

Algorithm:

  1. Define a class Density with float variables mass and volume.
  2. Create a constructor to initialize mass and volume.
  3. Define a function mDensity() to compute mass/volume.
  4. Define a derived class RelativeDensity, inheriting from Density.
  5. Add a float variable refDensity and a constructor to initialize it.
  6. Define a function rDensity() to compute mDensity()/refDensity.
  7. Define another derived class Weight, also inheriting from Density.
  8. Add a float variable gravity and a constructor to initialize it.
  9. Define a function fluidWeight() to compute mDensity() * volume * gravity.
  10. In main(), create objects of RelativeDensity and Weight and display mass, volume, density, relative density, and weight.

Code:

#include <iostream>
using namespace std;

class Density
{
public:
    float mass;
    float volume;

    Density(float m, float v) : mass(m), volume(v) {}

    float mDensity()
    {
        return mass / volume;
    }
};

class RelativeDensity : public Density
{
public:
    float refDensity;

    RelativeDensity(float m1, float v1, float r) : Density(m1, v1), refDensity(r) {}

    float rDensity()
    {
        return mDensity() / refDensity;
    }
};

class Weight : public Density
{
public:
    float gravity;

    Weight(float m1, float v1, float g) : Density(m1, v1), gravity(g) {}

    float fluidWeight()
    {
        return mDensity() * volume * gravity;
    }
};

int main()
{
    RelativeDensity rd(50, 20, 1000);
    Weight w(50, 20, 9.81);

    cout << "Mass: " << rd.mass << " kg" << endl;
    cout << "Volume: " << rd.volume << " m^3" << endl;
    cout << "Density: " << rd.mDensity() << " kg/m^3" << endl;
    cout << "Relative Density: " << rd.rDensity() << endl;
    cout << "Weight of Fluid: " << w.fluidWeight() << " N" << endl;

    return 0;
}

Practice Exercise 9: Write a C++ program to demonstrate hybrid inheritance by calculating the density, relative density, and weight of a fluid.

Theory:

Algorithm:

Code:

#include <iostream>
using namespace std;

class Density {
protected:
    float mass;
    float volume;

public:
    Density(float m, float v) : mass(m), volume(v) {}

    float mDensity() {
        return mass / volume;
    }
};

class RelativeDensity : virtual public Density {
protected:
    float refDensity;

public:
    RelativeDensity(float m, float v, float r) : Density(m, v), refDensity(r) {}

    float rDensity() {
        return mDensity() / refDensity;
    }
};

class Weight : virtual public Density {
protected:
    float gravity;

public:
    Weight(float m, float v, float g) : Density(m, v), gravity(g) {}

    float fluidWeight() {
        return mDensity() * volume * gravity;
    }
};

class Fluid : public RelativeDensity, public Weight {
public:
    Fluid(float m, float v, float r, float g) : Density(m, v), RelativeDensity(m, v, r), Weight(m, v, g) {}

    void display() {
        cout << "Mass: " << mass << " kg" << endl;
        cout << "Volume: " << volume << " m^3" << endl;
        cout << "Density: " << mDensity() << " kg/m^3" << endl;
        cout << "Relative Density: " << rDensity() << endl;
        cout << "Weight of Fluid: " << fluidWeight() << " N" << endl;
    }
};

int main() {
    Fluid fluid(50, 20, 1000, 9.81);
    fluid.display();
    return 0;
}

Extra Self Practice Material

Self Practice Program 1: Write a program to demonstrate multiple inheritance by calculating the Reynolds number of fluid flow.

Theory:

The Reynolds number is a dimensionless quantity used to predict fluid flow behavior in a pipe. It determines whether the flow is laminar, transitional, or turbulent based on the relationship between fluid properties and velocity. The Reynolds number is calculated using the formula:

$$ Re = \frac{\rho V D}{\mu} $$

Where:
- $ \rho $ = Fluid density (kg/m³)
- $ V $ = Flow velocity (m/s)
- $ D $ = Pipe diameter (m)
- $ \mu $ = Fluid viscosity (Pa·s)

The velocity $ V $ is calculated as:

$$ V = \frac{Q}{\frac{\pi D^2}{4}} $$

where $ Q $ is the flow rate (m³/s).

Algorithm:

  1. Define the Fluid class with a constructor to initialize density and viscosity.
  2. Define the Velocity class with a constructor to initialize flow rate and pipe diameter.
  3. Implement the calculateVelocity() function in Velocity to compute velocity using the given formula.
  4. Define the ReynoldsNumber class inheriting from both Fluid and Velocity.
  5. Use a constructor in ReynoldsNumber to initialize fluid and velocity properties.
  6. Calculate the Reynolds number using the given formula.

$$ Re = \frac{\rho V D}{\mu} $$

  1. Determine the flow regime based on the Reynolds number:
  2. $ Re < 2000 $ → Laminar flow
  3. $ 2000 \leq Re \leq 4000 $ → Transitional flow
  4. $ Re > 4000 $ → Turbulent flow
  5. Display the Reynolds number and flow type.

Code:

#include <iostream>
using namespace std;

class Fluid {
public:
    double density;   // Fluid density (kg/m³)
    double viscosity; // Fluid viscosity (Pa.s)

    // Constructor for Fluid properties
    Fluid(double d, double v) {
        density = d;
        viscosity = v;
    }
};

class Velocity {
public:
    double flowRate;  // Flow rate (m³/s)
    double diameter;  // Pipe diameter (m)

    // Constructor for Velocity properties
    Velocity(double q, double d) {
        flowRate = q;
        diameter = d;
    }

    // Function to calculate velocity
    double calculateVelocity() {
        return flowRate / (3.1416 * diameter * diameter / 4);
    }
};

class ReynoldsNumber : public Fluid, public Velocity {
public:
    // Constructor to initialize both Fluid and Velocity properties
    ReynoldsNumber(double d, double v, double q, double dia) 
        : Fluid(d, v), Velocity(q, dia) {}

    void calculateReynolds() {
        double velocity = calculateVelocity();
        double Re = (density * velocity * diameter) / viscosity;
        cout << "Reynolds Number: " << Re << endl;
        if (Re < 2000)
            cout << "Flow is Laminar." << endl;
        else if (Re > 4000)
            cout << "Flow is Turbulent." << endl;
        else
            cout << "Flow is Transitional." << endl;
    }
};

int main() {
    // Creating an object with constructor parameters
    ReynoldsNumber fluidSystem(1000, 0.001, 0.05, 0.1);
    fluidSystem.calculateReynolds();
    return 0;
}

Self Practice Program 2: Write a program to demonstrate hierarchical inheritance by calculating the kinetic and potential energy of the fluid flow.

Theory:

Kinetic and potential energy depend on the fluid's properties such as velocity and height. Multiple derived classes can inherit from the same base class.

Formulas:

  • Kinetic Energy:

$$ KE = \frac{1}{2} \rho Q V^2 $$

  • Potential Energy:

$$ PE = \rho Q g h $$

Algorithm:

  1. Define the base class Fluid with properties density and flowRate.
  2. Define the class KineticEnergy to calculate kinetic energy.
  3. Define the class PotentialEnergy to calculate potential energy.
  4. Instantiate both classes, set fluid properties, and compute kinetic and potential energies separately.

Code:

#include <iostream>
using namespace std;

class Fluid {
public:
    double density;   // Fluid density (kg/m³)
    double flowRate;  // Flow rate (m³/s)

    void setFluidProperties(double d, double q) {
        density = d;
        flowRate = q;
    }

    void showType() {
        cout << "Fluid System:
";
    }
};

class KineticEnergy : public Fluid {
public:
    double velocity;  // Fluid velocity (m/s)

    void setVelocity(double v) {
        velocity = v;
    }

    double calculateKE() {
        return 0.5 * density * flowRate * velocity * velocity;
    }
};

class PotentialEnergy : public Fluid {
public:
    double height;  // Height (m)

    void setHeight(double h) {
        height = h;
    }

    void calculatePE() {
        double PE = density * flowRate * 9.81 * height;
        cout << "Potential Energy: " << PE << " Joules
";
    }
};

int main() {
    KineticEnergy ke;
    PotentialEnergy pe;

    ke.setFluidProperties(1000, 0.05);  // Example values: density, flow rate
    ke.setVelocity(3);  // Example velocity
    pe.setFluidProperties(1000, 0.05); // Example values: density, flow rate
    pe.setHeight(10);   // Example height

    ke.showType();
    cout << "Kinetic Energy: " << ke.calculateKE() << " Joules
";

    pe.calculatePE();

    return 0;
}

Self Practice Program 3: Write a program to demonstrate hybrid inheritance by calculating the Reynolds number considering multiple fluid properties and velocity characteristics.

Theory:

Hybrid inheritance combines both multiple and multilevel inheritance concepts. In this case, the Reynolds number is calculated using fluid and velocity properties, where fluid and velocity are inherited separately.

Formula:

$$ Re = \frac{\rho V D}{\mu} $$

Algorithm:

  1. Define the base class Fluid with properties density and viscosity.
  2. Define the class Velocity to calculate flow velocity using flow rate and pipe diameter.
  3. Create a derived class ReynoldsNumber that inherits from both Fluid and Velocity.
  4. Calculate Reynolds number:

$$ Re = \frac{\rho V D}{\mu} $$

  1. Display the flow regime based on the Reynolds number.

Code:

#include <iostream>
using namespace std;

class Fluid {
public:
    double density;   // Fluid density (kg/m³)
    double viscosity; // Fluid viscosity (Pa.s)

    void setFluidProperties(double d, double v) {
        density = d;
        viscosity = v;
    }
};

class Velocity {
public:
    double flowRate;  // Flow rate (m³/s)
    double diameter;  // Pipe diameter (m)

    void setVelocityProperties(double q, double d) {
        flowRate = q;
        diameter = d;
    }

    double calculateVelocity() {
        return flowRate / (3.1416 * diameter * diameter / 4);
    }
};

class ReynoldsNumber : public Fluid, public Velocity {
public:
    void calculateReynolds() {
        double velocity = calculateVelocity();
        double Re = (density * velocity * diameter) / viscosity;
        cout << "Reynolds Number: " << Re << endl;
        if (Re < 2000)
            cout << "Flow is Laminar.
";
        else if (Re > 4000)
            cout << "Flow is Turbulent.
";
        else
            cout << "Flow is Transitional.
";
    }
};

int main() {
    ReynoldsNumber fluidSystem;
    fluidSystem.setFluidProperties(1000, 0.001);  // Example values: density, viscosity
    fluidSystem.setVelocityProperties(0.05, 0.1); // Example flow rate, diameter
    fluidSystem.calculateReynolds();
    return 0;
}

References

There may be some AI Generated content in this article used for demonstration purposes.