How does pointer to pointers to objects works? - c++

Question

I am new to c++ and trying to understand pointers. I read a example somewhere, which is like this:
#include<iostream>
#define N 5
using namespace std;
class Test {
int x, y;
public:
Test(int a, int b)
: x(a), y(b)
{
}
void print()
{
cout << x << " " << y << endl;
}
};
int main()
{
Test **arr = new Test*[N];
for (int i = 0; i < N; i++) {
arr[i] = new Test(i, i + 1);
}
for (int i = 0; i < N; i++) {
arr[i]->print();
}
}
So, in the line
Test **arr = new Test*[N];
as far as i understand, **arr means that it's a pointer to a pointer which points to a object. So when we assign it to new Test*[N], does it means *arr stores address of N object pointers?
And if it is correct, then how can i print the address of a object from the array of objects? let's say i want to print the address of the object Test[3]?

Answer 1

In modern C++, there's are better alternatives than having owning raw pointers, and better alternatives than manually new'ing up an array.
There are containers (such as std::vector), there are smart pointers (such as std::unique_ptr and std::shared_ptr).
Polymorphism needs to be done through a pointer (including smart pointer) or reference, but that is not a factor in the posted code.
The OP posted code has a memory leak, since it did not clean up the arr. In these kinds of small programs, memory leaks are sometimes handwaved away and ignored.
For the code you posted, I'd have done it this way, which eliminates the pointers altogether:
#include <iostream>
#include <vector>
using std::cout;
using std::vector;
constexpr int N = 5;
class Test {
int x;
int y;
public:
Test(int x_, int y_)
: x{x_}, y{y_}
{ }
void print() const {
cout << x << " " << y << "\n";
}
};
int main() {
vector<Test> arr;
for (int i = 0; i < N; i++) {
arr.emplace_back(Test{i, i+1});
}
for (auto const& test : arr) {
test.print();
}
}
I had to add a little const correctness. I relied on vector and have no need for a pointer or smart pointer, in this particular example.
In my last decade of programming C++, I've never needed to use a new or an owning raw pointer.
Raw pointers are still suitable for non-owning parameters which could be nullptr, and non-owning return values which could be nullptr. But since they are non-owning, there's no concern over memory management.
Update:
"... trying to understand pointers..."
Caveat. Unfortunately, my example of "how I'd do this kind of program" does not lend itself to the OP's goal of trying to understand pointers. That kind of topic is actually bit broad, and should be thoroughly covered in the first chapter or two of a good C++ book.

Answer 2

The answer to the first question is YES.
To the second question you can just send the pointer to cout without dereferencing it.
cout << arr[3];
Or use C's printf function:
printf("%p", arr[3]);
If you want to print it from the method, you use the this pointer:
void print()
{
cout << this << "- " << x << " " << y << endl;
}