What is a C++ Object?
C++ objects are any real-world entity, such as a chair, pencil, or eraser. It is defined as an entity that has both state and behavior and is an instance of a class. When a class is defined, no memory is initially allocated. However, memory is allocated when an object of that class is created.
For example: if two objects naming student-1 and student-2 of Student class are created, then both of them will have separate memory allocated to them, both of them will have all the properties of the Student class.
Creating a Class and Declaring Objects
In order to define a class in C++, the ‘class’ keyword must be used, followed by the className. The data members and member functions which constitute the body of the class are defined inside curly brackets. A class is always terminated by a semicolon at the end.
class className
{
Access specifier // can be private, protected, public
Data members // variables
Member Functions() // methods to access data members
}; // Class ends with a semicolon
Declaring Objects
When a class is defined, only the specifications or the blueprint for the object is defined, no memory is allocated. In order to use the data and access the functions defined inside a class, we need an object. In order to access the data members and member functions of a class, the dot (‘.’) operator is used along with the object name. For example, if student1 is the object name and we want to access the getMarks() member function, we will write student1.getMarks() .
Syntax
className objectName;
Access Specifier
Access Specifiers are used to implement data hiding which is a very important aspect of object-oriented programming. Access Specifiers in a class are used to assign the accessibility to the class members, that is, they are used to set some level of restrictions on the class members as to not get directly accessible from outside the function. There are 3 types of access specifiers:
Public
- All the class members declared under this are available to everyone, that is, they can be accessed by other classes and functions too. The public members are directly accessible using the dot operator with the object of the class from anywhere in the program.
Example
C++
#include<iostream>
using namespace std;
class student{
public:
int marks;
int getPercentage()
{
return (marks*100)/100;
}
};
int main(){
student student1;
student1.marks=92;
cout<<"Percentage = "<<student1.getPercentage()<<endl;
}
You can also try this code with Online C++ Compiler
Output
Percentage = 92
You practice by yourself with the help of online c++ compiler.
Private
- All the class members declared under private can be accessed only by the member functions inside the class, they can not be accessed by any object or function outside the class. The member functions and the friend functions are allowed to access them.
- If we don't specify any access modifiers for the members inside the class, then by default, the access modifier for members is set as Private.
Example
#include<iostream>
using namespace std;
class student{
private:
int marks;
public:
int getPercentage()
{
return (marks*100)/100;
}
};
int main(){
student student1;
student1.marks=92;
cout<<"Percentage = "<<student1.getPercentage()<<endl;
}
Output
18:13: error: 'marks' is a private member of 'student'
student1.marks=92;
^
r-6:13: note: declared private here
int marks;
^
The above program gives a compile-time error as we are not allowed to access the private data members of a class directly from outside the class.
We can indirectly access the private data members using the public member functions of the class.
Example
C++
#include<iostream>
using namespace std;
class student{
private:
int marks;
public:
int getPercentage(int m)
{
marks=m;
return (marks*100)/100;
}
};
int main(){
student student1;
cout<<"Percentage = "<<student1.getPercentage(92)<<endl;
}
You can also try this code with Online C++ Compiler
Output
Percentage = 92
Protected
- All the data members which are declared under this cant be accessed outside of the class unless with the help of a friend class. The only difference between private and protected is that protected class members can not be accessed by any subclass of that class as well.
Example
C++
#include <bits/stdc++.h>
using namespace std;
// base class
class Database{
// protected data members
protected:
int marks;
};
// sub class or derived class from public base class
class student : public Database
{
public:
void setMarks(int m)
{
marks = m;
}
void displayMarks()
{
cout << "Marks = " << marks << endl;
}
};
// main function
int main() {
student obj1;
obj1.setMarks(81);
obj1.displayMarks();
}
You can also try this code with Online C++ Compiler
Output
Marks = 81
Also check out this article - Pair in C++
Member Functions in Classes
There are 2 ways in which we can define member functions in classes:
- Outside Class
- Inside Class
Outside Class
- In order to define a member function outside the class, we have to use the scope ‘::’ resolution operator along with the class name followed by the function name.
Syntax
Return_type ClassName::Function_Name()
Inside Class
- All the member functions which are defined inside the class are by default inline. We can make any non-class function inline by using the keyword inline. These are the functions that are copied everywhere during compilation so that the overhead of function calling is reduced.
Constructors in C++
A constructor in C++ is a special member function of a class that initializes objects of the class. It is called automatically when an object is created. Constructors have the same name as the class and do not have a return type.
Syntax:
class ClassName {
public:
ClassName() {
// Constructor code here
}
};
Implementation
C++
#include <iostream>
using namespace std;
class Student {
public:
string name;
int roll_no;
// Constructor
Student(string n, int r) {
name = n;
roll_no = r;
cout << "Constructor called for " << name << endl;
}
void display() {
cout << "Name: " << name << ", Roll No: " << roll_no << endl;
}
};
int main() {
// Creating objects
Student student1("Virat", 1);
Student student2("Rohit", 2);
// Displaying student details
student1.display();
student2.display();
return 0;
}
You can also try this code with Online C++ Compiler
Output:
Constructor called for Virat
Constructor called for Rohit
Name: Alice, Roll No: 1
Name: Bob, Roll No: 2
Destructors in C++
A destructor in C++ is a special member function of a class that is executed whenever an object of the class goes out of scope or is explicitly deleted. It has the same name as the class but is preceded by a tilde (~) and does not take any parameters nor does it return a value.
Syntax:
class ClassName {
public:
~ClassName() {
// Destructor code here
}
};
Implementation
C++
#include <iostream>
using namespace std;
class Student {
public:
string name;
int roll_no;
// Constructor
Student(string n, int r) {
name = n;
roll_no = r;
cout << "Constructor called for " << name << endl;
}
// Destructor
~Student() {
cout << "Destructor called for " << name << endl;
}
void display() {
cout << "Name: " << name << ", Roll No: " << roll_no << endl;
}
};
int main() {
// Creating objects
Student student1("Virat", 1);
Student student2("Rohit", 2);
// Displaying student details
student1.display();
student2.display();
return 0;
}
You can also try this code with Online C++ Compiler
Output:
Constructor called for Virat
Constructor called for Rohit
Name: Alice, Roll No: 1
Name: Bob, Roll No: 2
Destructor called for Virat
Destructor called for Rohit
In this example, the constructor initializes the objects student1 and student2, and the destructor is automatically called when the objects go out of scope at the end of the main function.
Object-Oriented Concepts in C++
Inheritance: Creating Subclasses and Inheriting Properties
Inheritance in C++ allows one class (called the subclass or derived class) to inherit properties and behaviors (methods) from another class (called the superclass or base class). This enables code reuse and simplifies maintenance.
For example:
#include <iostream>
using namespace std;
class Animal {
public:
void speak() {
cout << "Animal speaks" << endl;
}
};
class Dog : public Animal {
public:
void bark() {
cout << "Dog barks" << endl;
}
};
int main() {
Dog d;
d.speak(); // Inherited from Animal
d.bark();
return 0;
}
You can also try this code with Online C++ Compiler
In this example, the Dog class inherits the speak() method from the Animal class. This shows how inheritance supports code reuse and reduces redundancy.
Polymorphism: Method Overloading and Overriding
Polymorphism in C++ allows the same function name to behave differently based on context. There are two types:
1. Method Overloading (Compile-Time Polymorphism):
class Print {
public:
void show(int i) {
cout << "Integer: " << i << endl;
}
void show(string s) {
cout << "String: " << s << endl;
}
};
You can also try this code with Online C++ Compiler
This allows different versions of the show function depending on the input type.
2. Method Overriding (Runtime Polymorphism):
class Base {
public:
virtual void display() {
cout << "Base display" << endl;
}
};
class Derived : public Base {
public:
void display() override {
cout << "Derived display" << endl;
}
};
You can also try this code with Online C++ Compiler
Polymorphism allows flexibility in using functions with the same name, improving program extensibility and maintainability.
Abstraction: Hiding Complexity and Exposing Only Necessary Details
Abstraction in C++ hides complex implementation details and only exposes essential features. It can be achieved using abstract classes and pure virtual functions.
Example:
class Shape {
public:
virtual void draw() = 0; // Pure virtual function
};
class Circle : public Shape {
public:
void draw() override {
cout << "Drawing Circle" << endl;
}
};
You can also try this code with Online C++ Compiler
Here, Shape provides an abstract interface, and Circle implements the necessary details. Abstraction makes the code easier to understand and modify.
Static Members in C++
Understanding Static Variables and Functions
Static variables and functions in C++ are shared across all instances of a class. They belong to the class itself, not to any object.
Example:
class Counter {
public:
static int count;
Counter() {
count++;
}
static void showCount() {
cout << "Count: " << count << endl;
}
};
int Counter::count = 0;
You can also try this code with Online C++ Compiler
Each time a Counter object is created, the count variable is shared and incremented. Static functions can access only static variables.
Use Cases for Static Members in Classes
Static members are useful in scenarios where you need shared data across all objects. Common use cases include:
Counting instances: Keep track of how many objects of a class are created.
class User {
static int userCount;
public:
User() { userCount++; }
static int getUserCount() { return userCount; }
};
int User::userCount = 0;
You can also try this code with Online C++ Compiler
Accessing utility functions: Use static methods for helper functions that do not depend on object data.
class Math {
public:
static int add(int a, int b) {
return a + b;
}
};
You can also try this code with Online C++ Compiler
Static members help reduce memory usage and make code more organized when shared access is needed.
Frequently Asked Questions
What are classes and objects in C++?
Classes are blueprints for creating objects, which are instances that hold data and functions defining their behavior.
How many objects in a class?
A class can have any number of objects created from it, limited only by system memory.
Why do we need classes?
Classes provide a way to organize and structure code, promoting reuse, modularity, and encapsulation in object-oriented programming.
What is object class type?
The object class type refers to the specific class from which an object is instantiated, defining its properties and behaviors.
Conclusion
In this blog, we have covered the following topics:
- Firstly, we discussed what classes and objects are and what their use is.
- Then we discussed how we can define a class and declare an object.
- Finally, we discussed the types of access specifiers and different ways to declare member functions.
Classes help us implement the concepts of object-oriented programming in order to study more about object-oriented programming in detail refer to this. Also, to understand more about programming, see the difference between procedural and object-oriented programming in detail.
Recommended Readings:
518+ registered 
