array class member, with dynamically changeable length during runtime-CodePudding

I am trying to make a network application. Its class blueprint is roughly like this-

class Node
{
    public:
    // member functions
    private:
    int nodeID;
    // other members
};

class NodeNetwork
{
    public:
    // member functions
    private:
    Node nodeArray[MAX_NODES];
    // other members
};

Here, the Node class will deal with each node and the NodeNetwork is used to deal with the complete network.

The actual number of nodes in nodeArray can vary from 0 to MAX_NODES during runtime, i.e., it may not always be MAX_NODES, the number of nodes can be increased or decreased during runtime. Moreover, when the program starts the number will always be 0, after that it will start increasing.

I am using Node nodeArray[MAX_NODES];, but I think it's a serious wastage of space as not always I will have MAX_NODES nodes at runtime. So I am looking for ways to optimize it. I want it so that it starts with a zero-length array, but the size can be increased or decreased subjected to the above constraints based on the nodes added or removed at runtime. I researched on the internet but did not find any concrete answer.

I hope someone can help me solve this problem, thanks in advance.

CodePudding user response：

You can use dynamically array allocation for this purpose:

int* arr = new int[5];

..and anytime you wish to change the number of elements:

int size = 5;
int* arr = new int[size] {};

int* new_arr = new int[size   1];
for (int i = 0; i < size; i  )
{
    new_arr[i] = arr[i];
}
delete[] arr;
arr = new_arr;

// Now arr has a storage capacity of 6 elements

..so for your case you can write:

Node* nodeArray = nullptr; // nullptr == null pointer

But this can take a lot of time for huge arrays.

So preferably, you can use std::vector:

#include <iostream>
#include <vector>

int main() 
{
    std::vector<int> vec{ 1, 2, 3, 4, 5 };
    vec.push_back(6); //Insert a new element

    std::cout << vec[0]; // Accessing an element is the same as an array
}

..so for your case:

// {} is just for initialization, not exactly mandatory
std::vector<Node> nodeArray{};

CodePudding user response：

You can use std::vector instead of array. That is, you can make the data member nodeArray to be a std::vector<Node> as shown below.

#include <iostream>
#include<vector>
class Node
{
    public:
       //constructor for initializing nodeID data member 
       Node(int pnodeID): nodeID(pnodeID)
       {
           
       }
       //getter for nodeId
       int getId() const 
       {
           return nodeID;
       }
    private:
       //always initialize built in type in local/block scope so that they don't have indeterminate value
       int nodeID = 0; 
    // other members
};

class NodeNetwork
{
    public:
    
        // member function to add Node 
        void addNode(const Node& n)
        {
            nodeArray.push_back(n);
        }
        //member function to print out the current nodes 
        void display() const
        {
            std::cout<<"Network has the following nodes: "<<std::endl;
            for(const Node& elem: nodeArray)
            {
                std::cout<<elem.getId()<<std::endl;
                
            }
        }
    private:
        std::vector<Node> nodeArray; //used std::vector instead of array
    // other members
};
int main()
{
    //create Node objects 
    Node node1{1};
    Node node2{2};
    Node node3{3};
    
    NodeNetwork network1;
    
    //add node1 into the network1's nodeArray data member 
    network1.addNode(node1);
    
    //add node2 into the network1's nodeArray data member 
    network1.addNode(node2);

    //display all nodes into network1 
    network1.display();
    return 0;
}

In the above demo we have added elements into the nodeArray data member by using std::vector::push_back member function.

The output of the above program can be seen here:

Network has the following nodes: 
1
2