Cannot access objects created in array of pointers - c++

Question

I am having trouble accessing objects that I have created in an array of pointers. I have some test code that shows the objects are being created but in my ShowCluster() function it hangs on the first iteration through the second level loop.
The way I believe I have it coded is that I have a Node** object that in essence becomes a 2d array. Since I am using the new operator I don't have to worry about the scope inside the function.
Any ideas on why I cannot display the contents of these objects that I have created. This is just toy code that I want to use to help my understanding of pointers.
Main.cpp
#include <iostream>
#include "Node.h"
void Test(std::string message){
static int testNumber = 0;
std::cout << "[+] Test: " << testNumber << " : " << message << std::endl;
testNumber++;
}
void Default2dNodeArray(Node** myCluster, int height, int width, int vecLength){
Test("Start of array creation.");
myCluster = new Node*[height];
for(int i=0; i<height; i++){
myCluster[i] = new Node[width];
}
Test("End of array creation.");
}
void ShowCluster(Node **myCluster, int height, int width){
Test("Start of Display array.");
for(int i=0; i<height; i++){
Test("Outer for loop");
for(int j=0; j<width; j++){
Test("Inner for loop");
std::cout << myCluster[i][j].myNodeString << " : " << myCluster[i][j].myNodeInt << std::endl;
}
}
Test("End of Display array.");
}
int main(){
int myHeight = 5;
int myWidth =8;
int myVecLength = 4;
Node** myNodeArray;
std::cout << "Starting pointer test" << std::endl;
Test("In main.");
Default2dNodeArray(myNodeArray, myHeight, myWidth, myVecLength);
Test("In main.");
ShowCluster(myNodeArray, myHeight, myWidth);
Test("In main.");
std::cout << "Ending pointer test" << std::endl;
return 1;
}
Node.cpp
#include "Node.h"
#include <stdlib.h>
#include <stdio.h>
#include <sstream>
#include <iostream>
int Node::globalCounter = 0;
Node::Node(){
std::cout << "Node created." << std::endl;
std::stringstream ss;
ss << "Default: " << globalCounter;
myNodeString = ss.str();;
myNodeInt = globalCounter;
myVecLength = new int[3];
globalCounter++;
}
Node::Node(std::string myString, int myInt, int vecLength){
myNodeString = "Non-Default:" + myString;
myNodeInt = globalCounter;
myVecLength = new int[vecLength];
globalCounter++;
}
Node.h
#ifndef NODE_H_
#define NODE_H_
#include <string>
class Node {
public:
static int globalCounter;
std::string myNodeString;
int myNodeInt;
int* myVecLength;
Node();
Node(std::string, int, int);
};
#endif /* NODE_H_ */

Answer 1

Whatever you do to your Node** myCluster variable in the Default2dNodeArray function, it will not be visible within your main function because you pass in myCluster by value. So myNodeArray in main will not be modified. If you want to modify it, either return the new variable from the function, or change the function signature to
void Default2dNodeArray(Node**& myCluster, int height, int width, int vecLength)
(note the reference in the first argument). Using a triple pointer would also be possible, but I think the intention of modifying the passed variable is much better expressed through a reference, especially since you are already dealing with a double pointer here. Also, it leaves the rest of the code untouched.

Answer 2

You're trying to create an array of pointers to Node objects and initialize each one of those pointers to a Node object allocated on the heap, and pass that around as a parameter.
Passing a pointer to a function can be done by value (i.e. the pointer gets copied, you're able to access the memory pointed by dereferencing it but you can't change the original pointer pointed value), by taking its address and passing it to the function, e.g.
Node *ptr = 0x10;
function(&ptr);
void function(Node** ptr_to_ptr) {
(*ptr_to_ptr) = 0x20; // This will modify ptr
}
or by reference (that will also modify the original pointer value)
Node *ptr = 0x10;
function(ptr);
void function(Node*& ref_to_ptr) {
ref_to_ptr = 0x20; // This will modify ptr
}
in your case, since a double pointer is necessary to hold an array of pointers to Node objects and you're trying to pass it around by taking its address, you're going to end up using a triple pointer:
void Default2dNodeArray(Node*** myCluster, int height, int width, int vecLength) {
Test("Start of array creation.");
// Dereference to access the original double pointer value
*myCluster = new Node*[height];
for (int i = 0; i<height; i++){
(*myCluster)[i] = new Node[width];
}
Test("End of array creation.");
}
void ShowCluster(Node*** myCluster, int height, int width) {
Test("Start of Display array.");
for (int i = 0; i<height; i++){
Test("Outer for loop");
for (int j = 0; j<width; j++){
Test("Inner for loop");
std::cout << (*myCluster)[i][j].myNodeString << std::endl;
}
}
Test("End of Display array.");
}
int main(){
int myHeight = 5;
int myWidth = 8;
int myVecLength = 4;
Node** myNodeArray; // Double pointer
std::cout << "Starting pointer test" << std::endl;
Test("In main.");
Default2dNodeArray(&myNodeArray, myHeight, myWidth, myVecLength);
Test("In main.");
ShowCluster(&myNodeArray, myHeight, myWidth);
Test("In main.");
std::cout << "Ending pointer test" << std::endl;
return 1;
}
The above signatures look much scarier than they actually are. Try to figure out the small snippets I posted at the beginning and then move forward to this code.
If you understood the above example, it will be much easier to get that you could also have done it with a reference to a double pointer:
void Default2dNodeArray(Node**& myCluster, int height, int width, int vecLength)
// etc..
One last piece of advice: although this is just a test, remember to free all the allocated memory or you'll end up leaking it!