1. A pointer can be re-assigned:

   Copyint x = 5;
   int y = 6;
   int *p;
   p = &x;
   p = &y;
   *p = 10;
   assert(x == 5);
   assert(y == 10);
   

   A reference cannot be re-bound, and must be bound at initialization:

   Copyint x = 5;
   int y = 6;
   int &q; // error
   int &r = x;
   

2. A pointer variable has its own identity: a distinct, visible memory address that can be taken with the unary & operator and a certain amount of space that can be measured with the sizeof operator. Using those operators on a reference returns a value corresponding to whatever the reference is bound to; the reference’s own address and size are invisible. Since the reference assumes the identity of the original variable in this way, it is convenient to think of a reference as another name for the same variable.

   Copyint x = 0;
   int &r = x;
   int *p = &x;
   int *p2 = &r;
   
   assert(p == p2); // &x == &r
   assert(&p != &p2);
   

3. It is possible to create a pointer to a pointer, but not a pointer to a reference.

   Copy int **pp; // OK, pointer to pointer
    int &*pr; // ill-formed, pointer to reference
   

4. It is possible to create an array of pointers, but not an array of references.

   Copyint *ap[]; // OK, array of pointers
   int &ar[]; // ill-formed, array of references
   

5. You can have arbitrarily nested pointers to pointers offering extra levels of indirection. References only offer one level of indirection because references to references collapse.

   Copyint x = 0;
   int y = 0;
   int *p = &x;
   int *q = &y;
   int **pp = &p;
   
   **pp = 2;
   pp = &q; // *pp is now q
   **pp = 4;
   
   assert(y == 4);
   assert(x == 2);
   

6. A pointer can be assigned nullptr, whereas a reference must be bound to an existing object. If you try hard enough, you can bind a reference to nullptr, but this is undefined and will not behave consistently.

   Copy/* the code below is undefined; your compiler may optimise it
    * differently, emit warnings, or outright refuse to compile it */
   
   int &r = *static_cast<int *>(nullptr);
   
   // prints "null" under GCC 10
   std::cout
       << (&r != nullptr
           ? "not null" : "null")
       << std::endl;
   
   bool f(int &r) { return &r != nullptr; }
   
   // prints "not null" under GCC 10
   std::cout
       << (f(*static_cast<int *>(nullptr))
           ? "not null" : "null")
       << std::endl;
   

   You can, however, have a reference to a pointer whose value is nullptr.

7. Pointers are ContiguousIterators (of an array). You can use ++ to go to the next item that a pointer is pointing to, and + 4 to go to the 5th element.

8. A pointer needs to be dereferenced with * to access the object it points to, whereas a reference can be used directly. A pointer to a class/struct uses -> to access its members whereas a reference uses a ..

9. Const references and rvalue references can be bound to temporaries (see temporary materialization). Pointers cannot (not without some indirection):

   Copyconst int &x = int(12); // legal C++
   int *y = &int(12); // illegal to take the address of a temporary.
   

   This makes const & more convenient to use in argument lists and so forth.

In this case, they are equivalent.

It does not matter which you use, and neither is "best".

If you really want to choose between them then the reference is probably more idiomatic. I generally stick to references wherever I can because my OCD likes it: they feel "tighter", cannot be re-bound (with or without you noticing) and don't require a dereference to get to the value.

But I'm not aware of any general consensus on the issue for cases such as this.

Also note that the two may not compile to the same code if your implementation does not implement references with pointers, though I know of no implementation like that, and you wouldn't notice the difference anyway.