C++ Program To Find Area Of Circle Using Class And Object

In this article, you will learn how to calculate the area of a circle in C++ using object-oriented programming principles, specifically by defining a class and creating objects. This approach helps encapsulate data and behavior, making code more organized and reusable.

Problem Statement

Calculating the area of a circle is a fundamental geometric problem defined by the formula Area = π * radius * radius. While straightforward, a procedural approach can become cumbersome when dealing with multiple circles or needing to associate various properties and operations with a circle. The challenge is to implement this calculation in a way that is structured, scalable, and adheres to modern programming paradigms.

Example

The program will take a radius as input and output the calculated area, similar to this:

Enter the radius of the circle: 5
The area of the circle with radius 5 is: 78.5

Background & Knowledge Prerequisites

To understand this article, readers should have a basic understanding of:

• C++ Fundamentals: Variables, data types, input/output operations.
• Functions: How to define and call functions.
• Object-Oriented Programming (OOP) Concepts:
• Classes: Blueprints for creating objects.
• Objects: Instances of a class.
• Member Variables: Data members within a class.
• Member Functions (Methods): Functions that operate on the object's data.
• Constructors: Special methods for initializing objects.

Use Cases or Case Studies

Using classes and objects for geometric calculations offers several benefits across different applications:

• CAD/CAM Software: Representing various shapes (circles, squares, triangles) as objects, each with its properties (radius, side length) and methods (calculate area, calculate perimeter), simplifies complex design and manufacturing processes.
• Game Development: Defining game entities (e.g., collision detection for circular objects, hitboxes) as classes allows for easy manipulation of their properties and behavior within the game world.
• Geographic Information Systems (GIS): Modeling geographical features like circular zones or influence areas, where each zone is an object with a defined center and radius, and methods to check for overlap or containment.
• Physics Simulations: Simulating interactions between circular bodies (planets, particles) where each body is an object with attributes like mass, radius, and methods to calculate forces or collisions.
• Web Development (Backend): When dealing with spatial data or creating APIs that handle geometric operations, using classes provides a clean and modular way to process requests related to shapes.

Solution Approaches

1. Basic Procedural Approach (for contrast)

A simple way to calculate the area is using a function without classes. This works for single calculations but lacks the organization and reusability of OOP.

// Procedural Circle Area
#include <iostream>
#include <cmath> // For M_PI or custom PI definition

// Define PI if not available via cmath (e.g., older compilers or specific standards)
#ifndef M_PI
#define M_PI 3.14159265358979323846
#endif

double calculateCircleArea(double radius) {
    return M_PI * radius * radius;
}

int main() {
    double radius;
    std::cout << "Enter the radius of the circle: ";
    std::cin >> radius;

    if (radius < 0) {
        std::cout << "Radius cannot be negative." << std::endl;
    } else {
        double area = calculateCircleArea(radius);
        std::cout << "The area of the circle with radius " << radius << " is: " << area << std::endl;
    }

    return 0;
}

Run

This approach is direct but doesn't bundle the radius with its related operations.

2. Calculating Circle Area with a Circle Class

This approach uses a C++ class to encapsulate the circle's properties (radius) and behaviors (calculating area). This makes the code more modular, readable, and easier to maintain.

// Circle Area using Class and Object
#include <iostream>
#include <cmath> // Required for M_PI constant

// Define PI if not available via cmath (e.g., older compilers or specific standards)
#ifndef M_PI
#define M_PI 3.14159265358979323846
#endif

// Define the Circle class
class Circle {
private:
    double radius; // Member variable to store the radius

public:
    // Constructor to initialize the radius
    Circle(double r) {
        radius = r;
    }

    // Member function to calculate the area of the circle
    double calculateArea() {
        return M_PI * radius * radius;
    }

    // Optional: Member function to display circle information
    void displayCircleInfo() {
        std::cout << "Radius: " << radius << std::endl;
        std::cout << "Area: " << calculateArea() << std::endl;
    }
    
    // Optional: Getter for radius
    double getRadius() {
        return radius;
    }
};

int main() {
    // Step 1: Declare a variable for the radius
    double r;

    // Step 2: Prompt the user to enter the radius
    std::cout << "Enter the radius of the circle: ";
    std::cin >> r;

    // Step 3: Validate the radius
    if (r < 0) {
        std::cout << "Radius cannot be negative. Please enter a positive value." << std::endl;
    } else {
        // Step 4: Create an object of the Circle class
        // The constructor Circle(r) is called to initialize the object's radius
        Circle myCircle(r);

        // Step 5: Call the calculateArea() member function using the object
        double area = myCircle.calculateArea();

        // Step 6: Display the result
        std::cout << "The area of the circle with radius " << myCircle.getRadius() << " is: " << area << std::endl;
        // Or using the displayCircleInfo method:
        // myCircle.displayCircleInfo();
    }

    return 0;
}

Run

Sample Output:

Enter the radius of the circle: 7.5
The area of the circle with radius 7.5 is: 176.714

Stepwise Explanation:

1. Include Headers: iostream for input/output and cmath for the M_PI constant (representing pi). A custom M_PI define is included for robustness.
2. Define Circle Class:
   • private: double radius;: Declares a private member variable radius. private means radius can only be accessed or modified by member functions of the Circle class, enforcing encapsulation.

1. main() Function:
   • Prompts the user to Enter the radius of the circle:.

Conclusion

Using classes and objects to calculate the area of a circle in C++ provides a structured and object-oriented approach. It allows for the encapsulation of data (radius) and behavior (calculate area), making the code more organized, reusable, and easier to scale for more complex geometric problems. This adheres to good software design principles, promoting modularity and maintainability.

Summary

• Classes in C++ serve as blueprints for creating objects, encapsulating related data and functions.
• Objects are instances of a class, holding specific data (e.g., a Circle object has a particular radius).
• The constructor initializes an object's state when it is created.
• Member functions define the operations an object can perform (e.g., calculateArea()).
• This approach makes code modular, reusable, and easier to maintain compared to purely procedural methods for managing geometric calculations.
• Encapsulation ensures data integrity by controlling access to member variables.