Skip to content
Related Articles

Related Articles

How to Create a Dynamic 2D Array Inside a Class in C++?

View Discussion
Improve Article
Save Article
  • Difficulty Level : Hard
  • Last Updated : 23 May, 2022

A dynamic array is an array that can grow, resize itself, contains a dynamic table, which is mutable in nature, or an array list is randomly accessible, the variable-size list data structure that allows elements to be added or removed.

Suppose we want to create a class for Graph. The class stores the adjacency matrix representation of the graph.

Example:

CPP




// C++ program to demonstrate class of graphs
class Graph
{
  int V;
  int adj[V][V];  // This line doesn't work
   
  /* Rest of the members */
};
 
int main()
{
}

Output :

error: invalid use of non-static data
       member 'Graph::V'.

Even if we make V static, we get the error “array bound is not an integer constant”.

C++ doesn’t allow to creation of a stack-allocated array in a class whose size is not constant. So we need to dynamically allocate memory. Below is a simple program to show how to dynamically allocate a 2D array in a C++ class using a class for Graph with adjacency matrix representation. 

C++




// C++ program to demonstrate
// how to allocate dynamic 2D
// array in a class using a Graph
#include <bits/stdc++.h>
using namespace std;
 
// A Class to represent directed graph
class Graph {
    int V; // No. of vertices
 
    // adj[u][v] would be true if there is an edge
    // from u to v, else false
    bool** adj;
 
public:
    Graph(int V); // Constructor
 
    // function to add an edge to graph
    void addEdge(int u, int v) { adj[u][v] = true; }
    void print();
};
 
Graph::Graph(int V)
{
    this->V = V;
 
    // Create a dynamic array of pointers
    adj = new bool*[V];
 
    // Create a row for every pointer
    for (int i = 0; i < V; i++) {
        // Note : Rows may not be contiguous
        adj[i] = new bool[V];
 
        // Initialize all entries as false to indicate
        // that there are no edges initially
        memset(adj[i], false, V * sizeof(bool));
    }
}
 
// Utility method to print adjacency matrix
void Graph::print()
{
    for (int u = 0; u < V; u++) {
        for (int v = 0; v < V; v++)
            cout << adj[u][v] << " ";
        cout << endl;
    }
}
 
// Driver method
int main()
{
    // Create a graph given in the above diagram
    Graph g(4);
    g.addEdge(0, 1);
    g.addEdge(0, 2);
    g.addEdge(1, 2);
    g.addEdge(2, 0);
    g.addEdge(2, 3);
    g.addEdge(3, 3);
 
    g.print();
 
    return 0;
}

Output :

0 1 1 0 
0 0 1 0 
1 0 0 1 
0 0 0 1 

Note: memset() is used separately for individual rows. We can’t replace these calls with one call because rows are allocated at different addresses and making a memset call would be disastrous.

Example:

// Wrong!! (Rows of matrix at different addresses)
memset(adj, false, V*V*sizeof(bool));

This article is contributed by Dheeraj Gupta. Please write comments if you find anything incorrect, or if you want to share more information about the topic discussed above.


My Personal Notes arrow_drop_up
Recommended Articles
Page :

Start Your Coding Journey Now!