An array of objects in C++ is just like an array, but its elements are objects of a
class. It is essential for programmers to understand this concept for ease of data
manipulation and writing efficient code.
13 mins read
Arrays are fundamental data structures of fixed size that are used for storing and manipulating a
collection of elements in C++. We also need to create arrays when dealing with complex data
structures since they are capable of holding multiple instances of objects. we will learn about
arrays of objects in C++, i.e., arrays that hold objects and their technical aspects.
We will cover various aspects of working with arrays of objects, their declaration, initialization,
and different methods and techniques employed to work with an array of objects in C++
programming. We will explain these concepts with the help of detailed explanations and code
examples. Anyone who wishes to write effective, efficient, and sophisticated C++ code must
have a solid understanding of this powerful feature. So let's get started!
What Is An Object?
An object is an instance of a class in C++. It is a major part of the OOP paradigm, and it
encapsulates data (attributes) and functions (methods) into a single entity. Objects are created
using a class blueprint, which represents specific entities with their own state and behavior.
They enable the principles of encapsulation, abstraction, and polymorphism and help us to
interact with and manipulate data through well-defined interfaces. They are used to write
reusable, readable, and modular code, which are essential to model real-world entities and
implement complex systems.
What Is An Array Of Objects?
Arrays are fundamental data structures of fixed size that are used for storing and manipulating a
collection of elements in C++. An array of objects in C++ is a sequential collection of objects of
the same class type. Just as a regular array holds elements of a basic data type, an array of
objects stores and manipulates multiple instances of a particular class. Each element of an
array of objects represents an individual object which possesses its own attributes and
methods.
Declaration Of Array Of Objects In C++
There are several ways to declare an array of class objects in C++. Given below are two
different ways to declare an array of objects in C++, along with code examples and
explanations.
Declaring An Array Of Objects In C++ In Separate Lines
The first method for declaration and initialization is to do both of these separately.
Code:
#include<iostream>
using namespace std;
class MyClass {
private:
int data;
public:
void initialize(int i){
data = i;
void method(int i){
cout<<"object "<<i+1<<endl;}
};
int main(){
MyClass array_of_objects[5];
for(int i=0; i<5; i++){
array_of_objects[i].initialize(i+1);
for(int i=0; i<5; i++){
array_of_objects[i].method(i);}
}
Output:
object 1
object 2
object 3
object 4
object 5
Explanation:
1. We begin by including the necessary header files such as <iostream>(for input from
user and output) and use namespace std.
2. Define a simple class called MyClass with an integer private attribute and a public
method named method. The index of each array element/ object in the array of objects
is passed into the method(), and it prints the objects in numerical order.
3. Next, we define another public method called initialize() that will take an integer value
as a parameter. This is used to initialize the objects to the required value.
4. In the main() function, we then declare an array of objects having 5 objects of type
MyClass. We then initialize the objects in the size of array by using a for loop to iterate
through the array and call initialize from each object to initialize the object.
5. We iterate through each object in the array and call method() from each object using a
for loop by passing in the index as a parameter.
Time & Space Complexity: Both these are O(n), where n is the number of objects in the array.
Declaring An Array Of Objects In C++ In Single Line
In this method, we declare and initialize the array of objects in a single go or simultaneously.
The code example below showcases how this must be done.
Code:
#include <iostream>
using namespace std;
class MyClass{
public:
private:
int data;
public:
MyClass(int value) : data(value) {}
void method(){
cout << "object " << data << endl;}
};
int main(){
MyClass array_of_objects[5] = {1, 2, 3, 4, 5};
for (int i = 0; i < 5; i++){
array_of_objects[i].method();}
}
Output:
object 1
object 2
object 3
object 4
object 5
Explanation:
1. Include the necessary header files such as <iostream>(for input and output) and use
namespace std;
2. Define a simple class called MyClass with a private integer attribute and a public
method named method and a constructor that takes an int value as a parameter and
initializes the data attribute to the value passed.
3. The index of each object in the array of objects is passed into the method(), and it prints
the objects in numerical order.
4. In the main(), we initialize 5 objects of type MyClass by passing in the values to the
constructor, which initializes the objects.
5. Iterate through each object in the array and call method() from each object using a for
loop by passing in the index as a parameter.
Time complexity: O(n), where n is the number of objects in the array.
Space complexity: O(n), where n is the number of objects in the array
Initializing Array Of Objects In C++
Other than the techniques mentioned above, there are several other techniques that are used in
declaring and initializing arrays. Some of these methods are explained below with detailed
examples.
Using The New Keyword
The new keyword in C++ enables dynamic memory allocation and object initialization. We
dynamically allocate memory for an array of objects in C++ using this method. The size of the
array is determined at runtime and can be stored in a single variable. Given below is an
example to help you understand this method:
Code Example:
#include<iostream>
using namespace std;
class MyClass{
public:
void method(int i){
cout<<"object "<<i+1<<endl;}
};
int main(){
MyClass *array_of_objects= new MyClass[5]; // Creating an array of
MyClass objects using 'new'
for(int i=0; i<5; i++){
array_of_objects[i].method(i);}
delete[] array_of_objects;
}
Output:
object 1
object 2
object 3
object 4
object 5
Explanation:
1. Include the necessary header files such as <iostream> for input and output and use
namespace std.
2. Define a simple class called MyClass with a method named method. The index of each
object in the array of objects is passed into the method(), and it prints the objects in
numerical order.
3. Next, we declare a dynamically allocated pointer using the new keyword that points to
the array of objects. This allocates the necessary memory to perform the required
actions on the array of objects.
4. We then iterate through each object in the array and call the method from each object
using a for loop by passing in the index as a parameter.
5. Don’t forget to free the dynamically allocated memory using delete[]. Not deleting
dynamically allocated memory could cause memory leaks leading to severe problems,
including program crashes.
Time complexity: O(n), where n is the number of objects in the array.
Space complexity: O(n), where n is the number of objects in the array
Using Function Calls To Declare & Initialize An Array Of
Objects In C++
Function calls can be utilized to declare and initialize an array of objects in C++. We can invoke
a function that returns an object and assign the returned values to the elements of the array.
This method enables flexible initialization of an array of objects. It also allows customizable and
flexible initialization of an array of objects in C++. Given below is an example to demonstrate
how function calls can be used to initialize an array of objects.
Code example:
#include <iostream>
using namespace std;
class MyClass{
private:
int data;
public:
void initialize(int value){
data = value;}
void method(){
cout << "object " << data << endl;}
};
int main(){
MyClass array_of_objects[5];
for (int i = 0; i < 5; i++){
array_of_objects[i].initialize(i + 1);}
for (int i = 0; i < 5; i++){
array_of_objects[i].method();}
}
Output:
object 1
object 2
object 3
object 4
object 5
Explanation:
We begin the example above by including the necessary header files such as <iostream>(for
input and output) and use namespace std.
1. Then the program defines a simple class called MyClass with an integer private
member and a public method called initialize(). This method takes an integer data type
(int) parameter and initializes the data attribute to the value passed into the function.
2. The MyClass also defines a public method named method(). The index of each object
in the array of objects is passed into the method(), and it prints the objects in numerical
order.
3. Create an array named array_of_objects to utilize the class and function.
4. Initialize all the objects by using a for loop to call initialize for each member of the array
by passing in the index as a parameter. This initializes all objects to the required values.
5. Iterate through each object in the array using a for loop and call method() from each
object.
Time complexity: O(n), where n is the number of objects in the array.
Space complexity: O(n), where n is the number of objects in the array
Using Vectors To Initialize An Array Of Objects In C++
The <vector> header in C++ provides us with a convenient and safe way for declaring and
initializing an array of objects in C++. It belongs to the standard library, and it offers various
utilities, such as dynamic size adjustment when working with an array of objects in C++. Here is
an example to help you better understand this concept:
Code example:
#include<iostream>
#include<vector>
using namespace std;
class MyClass{
public:
MyClass(int value){}
void method(int i){
cout<<"object "<<i+1<<endl;}
};
int main(){
vector<MyClass>array_of_objects{};
for(int i=0; i<5; i++){
array_of_objects.push_back(i+1);
array_of_objects[i].method(i);}
}
Output:
object 1
object 2
object 3
object 4
object 5
Explanation:
1. Include the necessary header files such as <iostream> (for input and output) and
<vector> (contains various useful classes and methods to implement vectors).
2. Define a simple class called MyClass with a method named method and a constructor
that has an int value as a parameter. The index of each object in the array of objects is
passed into the method(), and it prints the objects in numerical order
3. Create a vector that holds objects of type MyClass and is named array_of_objects.
4. Initialize all the objects by using push_back() to call constructors for each object while
passing the index of each object. This is done by iterating through the vector using a for
loop.
5. Iterate through each object in the array and call method() from each object.
Time complexity: O(n), where n is the number of objects in the array.
Space complexity: O(n), where n is the number of objects in the array
Using malloc() To Declare & Initialize Array Of Objects In C++
Malloc() is a C function that is used to dynamically allocate memory at runtime. It’s not
recommended to use the function malloc to initialize an array of objects in C++, as it doesn’t
involve invoking constructors or properly initializing objects. Therefore, it is highly recommended
to use pointers and the new keyword, as explained in the article, to declare and initialize an
array of objects in C++. However, given below is an example to show you how the code would
look with malloc().
Code:
#include<iostream>
#include<cstdlib>
using namespace std;
class MyClass{
public:
void method(int i){
cout<<"object "<<i+1<<endl;}
};
int main(){
const int Size=5;
MyClass *array_of_objects=
static_cast<MyClass*>(malloc(sizeof(MyClass)*Size));
for(int i=0; i<5; i++){
array_of_objects[i].method(i);}
free(array_of_objects);
}
Output:
object 1
object 2
object 3
object 4
object 5
Explanation:
1. Include the necessary header files such as <iostream>(for input and output) and
<cstdlib> for using malloc().
2. Define a simple class called MyClass with a method named method that prints the
output.
3. Initialize a const int variable named Size, which will be the size of the array of objects.
4. Create an array of objects using malloc() by statically casting malloc() as a pointer to
MyClass. This is done as malloc() doesn’t return a specific type. Also, note that malloc()
doesn’t invoke constructors or destructors. Therefore, when initializing objects or raw
pointers, the programmer must explicitly call constructors and destructors to avoid
memory leaks and other errors.
5. Iterate through each object in the array and call the method from each object using a for
loop.
6. Free the dynamically allocated memory using free(). Not deleting dynamically allocated
memory could cause memory leaks leading to severe problems, including program
crashes.
Time complexity: O(n), where n is the number of objects in the array.
Space complexity: O(n), where n is the number of objects in the array
Using Pointers To Declare & Initialize Array Of Objects In C++
We can declare and initialize an array of objects in C++ using pointers. Pointers are an efficient
and effective way to declare and initialize an array of objects in C++. Given below is an example
to help you better understand how pointers are used to declare and initialize an array of objects
in C++:
Code:
#include<iostream>
using namespace std;
class MyClass{
public:
void method(int i){
cout<<"object "<<i+1<<endl;}
};
int main(){
MyClass obj1, obj2,obj3,obj4,obj5;
MyClass* array_of_objects[]={&obj1, &obj2, &obj3, &obj4, &obj5};
for(int i=0; i<5; i++){
array_of_objects[i]->method(i);}
}
Output:
object 1
object 2
object 3
object 4
object 5
Explanation:
1. Include the necessary header files, such as <iostream> for user input and output, and
use namespace std.
2. Define a simple class called MyClass with a method named method. The index of each
object in the array of objects is passed into the method(), and it prints the objects in
numerical order.
3. Then in the main() function, we declare 5 objects of type MyClass.
4. Next, the program creates an array of objects that contains pointers to the 5 objects of
MyClass that were declared previously.
5. Iterate through each object in the array and call method() from each object using a for
loop.
Time complexity: O(n), where n is the number of objects in the array
Space complexity: O(n), where n is the number of objects in the array
Frequently Asked Questions
Q. What is the concept of array of objects in C++?
Arrays are fundamental data structures of fixed size that are used for storing and manipulating a
collection of elements in C++. An array of objects in C++ is a sequential collection of objects of
the same class type. Just as a regular array holds elements of a built-in data type, an array of
objects stores and manipulates multiple instances of a particular class.
Q. Can we declare and initialize an array of objects in C++
using pointers?
Yes, we can declare and initialize an array of objects in C++ using pointers. Pointers are an
efficient and effective way to declare and initialize an array of objects in C++. The new keyword
in C++ enables dynamic memory allocation and object initialization. We dynamically allocate
memory for an array of objects in C++ using this method. The size of the array is determined at
runtime and can be stored in a variable.
Q. How to initialize an array of objects in C++ using function
calls?
Function calls can be utilized to declare and initialize an array of objects in C++. We can invoke
a function that returns an object and assign the returned values to the individual elements of the
array. We enable flexible initialization of an array of objects through this. This method allows
customizable and flexible initialization of an array of objects in C++.
Q. How to utilize vectors for initializing an array of objects in
C++?
The <vector> header in C++ provides us with a convenient and safe way for declaring and
initializing an array of objects in C++. It belongs to the standard library, and it offers various
utilities, such as dynamic size adjustment when working with an array of objects in C++.
Q. Can we use the malloc() function to dynamically allocate
memory for an array of objects in C++?
Malloc() is a C function that is used to dynamically allocate contiguous memory locations at
runtime. It’s not recommended to use the malloc function to initialize an array of objects in C++,
as it doesn’t involve invoking constructors or properly initializing objects. Therefore, It is highly
recommended to use pointers and the new keyword to declare and initialize an array of objects
in C++.
