In C++, object-oriented programming (OOP) is built upon four key principles — encapsulation, inheritance, polymorphism, and abstraction. At the heart of these principles lies the concept of a class. A class serves as a blueprint for creating objects, encapsulating both data (attributes) and functions (methods) that operate on that data. Understanding how to define a class is a fundamental step toward mastering C++ programming.
This post explores in depth what a class is, how to define one, the syntax involved, the role of access specifiers, constructors, destructors, member functions, and real-world examples. It also covers best practices, common pitfalls, and comparisons between classes and structures in C++.
Understanding What a Class Is
A class in C++ can be thought of as a user-defined data type that represents a real-world entity. It groups variables and functions under a single name, making the code more organized, modular, and easier to maintain.
For example, consider the concept of a Car. A car has characteristics such as color, brand, and model, and it performs actions such as starting, stopping, or accelerating. These characteristics can be represented as data members, while the actions can be represented as member functions.
A class allows programmers to model such entities in a way that mirrors the real world, leading to better program structure and reusability.
Basic Syntax of a Class
The general syntax of defining a class in C++ is as follows:
class ClassName {
// Access specifier
// Data members
// Member functions
};
Let’s break down the syntax step by step:
- Keyword
class: This keyword is used to declare a class. - Class Name: The name of the class should be meaningful and follow C++ naming conventions.
- Access Specifiers: They define the accessibility of class members (private, public, or protected).
- Data Members: These are variables that store the state or properties of the object.
- Member Functions: These functions define the behavior or operations that can be performed on the data members.
- Semicolon: Each class definition ends with a semicolon.
Example of a Simple Class
Here’s a simple example that demonstrates how to define and use a class in C++.
#include <iostream>
using namespace std;
class Car {
public:
string brand;
string model;
int year;
void displayInfo() {
cout << "Brand: " << brand << endl;
cout << "Model: " << model << endl;
cout << "Year: " << year << endl;
}
};
int main() {
Car car1;
car1.brand = "Toyota";
car1.model = "Corolla";
car1.year = 2021;
car1.displayInfo();
return 0;
}
In this example, we define a class named Car with three data members — brand, model, and year. The class also has a member function displayInfo() that displays the details of the car. Inside the main() function, we create an object car1 and assign values to its data members, then call the member function.
Access Specifiers in a Class
Access specifiers control the accessibility of class members. C++ provides three main access specifiers:
1. Public
Members declared under the public section are accessible from anywhere in the program where the object of the class is visible.
2. Private
Members declared as private are accessible only within the class itself. This is the default access specifier in C++ if none is mentioned.
3. Protected
Protected members are similar to private members but can also be accessed in derived classes.
Example demonstrating different access specifiers:
class Example {
private:
int privateVar;
protected:
int protectedVar;
public:
int publicVar;
void setValues(int a, int b, int c) {
privateVar = a;
protectedVar = b;
publicVar = c;
}
void display() {
cout << "Private: " << privateVar << endl;
cout << "Protected: " << protectedVar << endl;
cout << "Public: " << publicVar << endl;
}
};
Here, privateVar is accessible only within the class, protectedVar can be accessed by derived classes, and publicVar is accessible from outside the class as well.
Creating Objects of a Class
Once a class is defined, objects (instances) of that class can be created. Each object has its own copy of the class’s data members.
Example:
Car car1, car2;
Here, car1 and car2 are two distinct objects of the Car class. Both have their own set of variables such as brand, model, and year.
Member Functions
Member functions are functions that belong to a class. They can be defined inside or outside the class definition.
Inside Class Definition
class Rectangle {
public:
int length;
int width;
int area() {
return length * width;
}
};
Outside Class Definition
class Rectangle {
public:
int length;
int width;
int area();
};
int Rectangle::area() {
return length * width;
}
In the second example, the function area() is defined outside the class using the scope resolution operator (::) to specify that it belongs to the Rectangle class.
Constructors in a Class
A constructor is a special member function that initializes objects of a class. It has the same name as the class and does not have a return type. Constructors are automatically called when an object is created.
Example of a Constructor
class Student {
public:
string name;
int age;
Student(string n, int a) {
name = n;
age = a;
}
void display() {
cout << "Name: " << name << ", Age: " << age << endl;
}
};
int main() {
Student s1("Alice", 20);
s1.display();
return 0;
}
Here, the constructor Student(string n, int a) initializes the name and age attributes when an object is created.
Types of Constructors
- Default Constructor – Takes no arguments and initializes objects with default values.
- Parameterized Constructor – Takes arguments to initialize objects with specific values.
- Copy Constructor – Initializes an object using another object of the same class.
Example of a copy constructor:
class Box {
public:
int width;
Box(int w) {
width = w;
}
Box(const Box &b) {
width = b.width;
}
};
Destructor in a Class
A destructor is a special member function used to clean up resources when an object goes out of scope. It has the same name as the class but preceded by a tilde ~, and it does not take any parameters or return a value.
Example:
class Demo {
public:
Demo() {
cout << "Constructor called" << endl;
}
~Demo() {
cout << "Destructor called" << endl;
}
};
int main() {
Demo obj;
return 0;
}
When the object obj goes out of scope, the destructor is automatically called.
Encapsulation
Encapsulation is the process of bundling data and functions together while restricting direct access to some of the object’s components. It is implemented using private data members and public member functions.
Example:
class Account {
private:
double balance;
public:
void setBalance(double amount) {
if (amount >= 0)
balance = amount;
else
cout << "Invalid amount" << endl;
}
double getBalance() {
return balance;
}
};
Here, balance is private, meaning it cannot be accessed directly from outside the class. Access is provided through public getter and setter functions.
Class vs Structure
In C++, both classes and structures can contain data members and functions. The primary difference lies in their default access specifiers.
- Class: Members are private by default.
- Struct: Members are public by default.
Example:
class ClassExample {
int x; // private by default
};
struct StructExample {
int x; // public by default
};
Though they look similar, classes are generally preferred in OOP due to their strong encapsulation features.
Using the this Pointer
Inside a class’s member function, the this pointer refers to the object that invoked the function. It is used to distinguish between data members and parameters with the same name.
Example:
class Employee {
private:
string name;
int id;
public:
Employee(string name, int id) {
this->name = name;
this->id = id;
}
void display() {
cout << "Name: " << name << ", ID: " << id << endl;
}
};
Inline Member Functions
Functions defined inside a class definition are automatically treated as inline functions. Inline functions can improve performance by reducing function call overhead for small functions.
Example:
class Math {
public:
int add(int a, int b) {
return a + b;
}
};
Here, add() is considered an inline function.
Static Members
Static data members and static member functions belong to the class rather than to any particular object.
Static Data Member
A static data member retains its value across all objects of the class.
class Counter {
public:
static int count;
Counter() {
count++;
}
};
int Counter::count = 0;
int main() {
Counter c1, c2, c3;
cout << Counter::count;
return 0;
}
Output:
3
Static Member Function
A static member function can access only static data members.
class Test {
public:
static int value;
static void display() {
cout << "Value: " << value << endl;
}
};
int Test::value = 10;
Friend Functions
A friend function is not a member of the class but can access its private and protected members.
Example:
class Box {
private:
int width;
public:
Box(int w) {
width = w;
}
friend void printWidth(Box b);
};
void printWidth(Box b) {
cout << "Width: " << b.width << endl;
}
Constant Member Functions
If a member function does not modify any class data, it can be declared as a const function.
Example:
class Circle {
private:
double radius;
public:
Circle(double r) : radius(r) {}
double getArea() const {
return 3.14 * radius * radius;
}
};
Nesting of Member Functions
In C++, one member function can call another member function of the same class directly.
Example:
class Sample {
private:
int data;
public:
void input() {
cout << "Enter data: ";
cin >> data;
}
void display() {
cout << "Data is: " << data << endl;
}
void process() {
input();
display();
}
};
Objects as Function Arguments
Objects of a class can be passed as arguments to functions — by value or by reference.
Pass by Value
void print(Car c) {
cout << c.brand;
}
Pass by Reference
void print(const Car &c) {
cout << c.brand;
}
Returning Objects from Functions
Functions can also return objects of a class.
Example:
class Box {
public:
int length;
Box add(Box b) {
Box temp;
temp.length = length + b.length;
return temp;
}
};
Array of Objects
You can create an array of objects of a class.
Example:
class Student {
public:
string name;
int marks;
void getData() {
cout << "Enter name and marks: ";
cin >> name >> marks;
}
void display() {
cout << name << " " << marks << endl;
}
};
int main() {
Student s[3];
for (int i = 0; i < 3; i++)
s[i].getData();
for (int i = 0; i < 3; i++)
s[i].display();
}
Dynamic Memory Allocation with Classes
C++ allows objects to be created dynamically using the new keyword and destroyed using delete.
Example:
Student *s = new Student("John", 22);
s->display();
delete s;
Inheritance Overview
Classes in C++ support inheritance, which allows one class to derive properties and behavior from another. Although defining inheritance is a separate topic, it starts with understanding how classes are structured.
Best Practices for Defining Classes
- Keep data members private to maintain encapsulation.
- Use getter and setter functions for accessing private members.
- Keep class names meaningful and capitalize the first letter.
- Separate class definition and implementation for better readability.
- Use constructors to ensure all objects are properly initialized.
- Prefer const correctness for functions that do not modify data.
- Avoid unnecessary use of friend functions.
Common Mistakes When Defining Classes
- Forgetting the semicolon after the class definition.
- Accessing private members directly from outside the class.
- Not initializing data members properly.
- Misunderstanding the use of
thispointer. - Defining constructors incorrectly (wrong name or with a return type).
Real-World Example: Bank Account Class
#include <iostream>
using namespace std;
class BankAccount {
private:
string accountHolder;
double balance;
public:
BankAccount(string name, double bal) {
accountHolder = name;
balance = bal;
}
void deposit(double amount) {
if (amount > 0)
balance += amount;
}
void withdraw(double amount) {
if (amount <= balance)
balance -= amount;
else
cout << "Insufficient funds!" << endl;
}
void display() {
cout << "Account Holder: " << accountHolder << endl;
cout << "Balance: $" << balance << endl;
}
};
int main() {
BankAccount account("Alice", 1000);
account.deposit(500);
account.withdraw(200);
account.display();
return 0;
}
This example demonstrates encapsulation, data protection, and class-based design in action.
Leave a Reply