Simple Interest Program in C++ using Class

Introduction

In this article, we will explore how to implement a simple interest program in C++ using the concept of class.

In the world of programming, C++ is a powerful and versatile language that allows developers to create efficient and reliable software applications.

Also Read: C++ Program to Read and Display Student Details using Class

One of the fundamental concepts in programming is the calculation of simple interest.

By the end of this article, you will have a clear understanding of how to write a C++ program that can calculate the simple interest.

What is Simple Interest?

Before we dive into the implementation, let’s first understand what simple interest is.

Simple interest is a quick and straightforward method of calculating the interest on a loan or an investment.

Also Read: Mastering Function Pointers in C++: A Comprehensive Guide

It is calculated based on the initial principal amount, the interest rate, and the time period.

The formula for calculating simple interest is as follows:

Simple Interest = (Principal * Rate * Time) / 100

Where:

• Principal: The initial amount of money.
• Rate: The rate of interest per time period.
• Time: The duration for which the money is borrowed or invested.

Now that we have a basic understanding of simple interest, let’s proceed to implement a simple interest program in C++.

Also Read: Mastering the getline Function in C++: A Comprehensive Guide

Implementation of Simple Interest Program in C++

To implement the simple interest program in C++, we will utilize the concept of class.

Classes are an essential part of object-oriented programming and allow us to encapsulate data and related functions into a single entity.

Also Read : Understanding Pointers in C++

Let’s start by defining a class named SimpleInterest:

class SimpleInterest {
  // Class members and functions
};

Within the SimpleInterest class, we will define the necessary data members and member functions to calculate the simple interest.

Also Read: The Power of Function Overloading in C++

The SimpleInterest class can have data members such as principal, rate, and time to store the respective values required for the calculation.

class SimpleInterest {
private:
  double principal;
  double rate;
  double time;
  
public:
  // Member functions
};

Next, we can define member functions within the class to set the values of the data members and calculate the simple interest.

Also Read: The Pointer to Understanding: Exploring the ‘this’ Pointer in C++

class SimpleInterest {
private:
  double principal;
  double rate;
  double time;
  
public:
  void setPrincipal(double p) {
    principal = p;
  }
  
  void setRate(double r) {
    rate = r;
  }
  
  void setTime(double t) {
    time = t;
  }
  
  double calculateSimpleInterest() {
    return (principal * rate * time) / 100;
  }
};

In the above code, we have defined setter functions setPrincipal, setRate, and setTime to set the values of the data members.

Also Read: 25 Tricky Questions on Pointers in C: Explained and Answered

The calculateSimpleInterest function calculates the simple interest using the formula mentioned earlier and returns the result.

To use the SimpleInterest class, we can create an instance of the class and invoke the member functions accordingly.

int main() {
  SimpleInterest si;
  
  si.setPrincipal(1000);
  si.setRate(5);
  si.setTime(2);
  
  double interest = si.calculateSimpleInterest();
  
  cout << "Simple Interest: $" << interest << endl;
  
  return 0;
}

The above code creates an instance of the SimpleInterest class, sets the values of principal, rate, and time using the setter functions, calculates the simple interest using the calculateSimpleInterest function, and displays the result.

Also Read: Function Overloading in C Plus Plus

By executing the above program, you will obtain the output:

Simple Interest: $100

Congratulations! You have successfully implemented a simple interest program in C++ using classes.

FAQs (Frequently Asked Questions)

Conclusion

In this article, we explored the implementation of a simple interest program in C++ using the concept of classes.

We learned how to create a class, define data members and member functions, and utilize them to calculate the simple interest.

By applying object-oriented principles, we achieved a modular and organized approach to programming.

Remember, understanding the fundamentals of programming concepts like simple interest is crucial as it forms the building blocks for more complex applications.

So, keep practicing and exploring the vast world of programming!