(->) arrow operator and (.) dot operator , class pointer

Question

In C++ we know that for a pointer of class we use (->) arrow operator to access the members of that class like here:

#include <iostream>
using namespace std;

class myclass{
    private:
        int a,b;
    public:
        void setdata(int i,int j){
            a=i;
            b=j;
        }
};

int main() {
    myclass *p;
    p = new myclass;
    p->setdata(5,6);
    return 0;
}

Then I create an array of myclass.

p=new myclass[10];

when I go to access myclass members through (->) arrow operator, I get the following error:

base operand of '->' has non-pointer type 'myclass'

but while I access class members through (.) operator, it works. These things make me confused. Why do I have to use the (.) operator for an array of class?

Answer 1

you should read about difference between pointers and reference that might help you understand your problem.

In short, the difference is:
when you declare myclass *p it's a pointer and you can access it's members with ->, because p points to memory location.

But as soon as you call p=new myclass[10]; p starts to point to array and when you call p[n] you get a reference, which members must be accessed using ..
But if you use p->member = smth that would be the same as if you called p[0].member = smth, because number in [] is an offset from p to where search for the next array member, for example (p + 5)->member = smth would be same as p[5].member = smth

Answer 2

Note that for a pointer variable x

myclass *x;

• *x means "get the object that x points to"
• x->setdata(1, 2) is the same as (*x).setdata(1, 2) and finally
• x[n] means "get the n-th object in an array".

So for example x->setdata(1, 2) is the same as x[0].setdata(1, 2).

Answer 3

Because by using [] like p[3] you are already dereferencing the pointer to array + index shift. After that you have to use ".", since p[3] is an object, not a pointer.

Answer 4

After...

MyClass* p = new myclass[10];

...p is a pointer to an array of MyClass objects. The "pointer to an array" thing has to be delt with first. Whenever you have a pointer to an array, p[n] effectively gives you a reference to the nth element in the array, so you effectively have a MyClass&. That's why . is then needed to access MyClass members ala p[n].member, and why the pointer-specific -> notation is erroneous in this case....

Note that p->member (for any member) is still valid and equivalent to p[0].member, so you can only use it for accessing the first element in the array. I strongly recommend you don't use it at all whenever you're in a programmatic context where 'p' is known to be pointer to the array, as it hides the fact that p is an array. Sometimes though you may create another pointer - say q - with the purpose of refering to a single array element - may or may not be [0] - and in those situation's it's fair to use q->member. Variables like q may be used for iteration over the array too. But, sometime you're going to need to delete[] p; - so you won't tend to change p beforehands... you don't want to lose track of the p[0] address or delete[] p; will be Undefined Behaviour (which is allowed to be implementation defined and happens to be on Windows if p still points within the array, but won't be portable).

Answer 5

myclass *ptr;

ptr = new myclass();     // ptr points to a single object
ptr->doSomething();      // calls doSomething on the object _pointed to_

ptr = new myclass[10];   // ptr points to multiple objects
ptr->doSomething();      // calls doSomething on the first object _pointed to_
(ptr+1)->doSomething();  // calls doSomething on the second object _pointed to_

auto val = ptr[2];       // fetches a reference to the second _object_ to val.
val.doSomething();       // calls doSomething on the _object reference_ val.

In other words, when indexing the array to fetch the n'th element, you're not fetching a pointer to the n'th element, you're fetching a reference to the actual object, and the members of that need to be accessed using . syntax.

Answer 6

Perhaps its insightful to consider that, given

myclass obj;
auto p = &obj;  // avoid `new` with plain pointers. That combination is
               //  safer replaced by unique_ptr or std::vector.

the following will all work and are equivalent:

p->setdata(5, 6);
(*p).setdata(5, 6);
p[0].setdata(5, 6);
0[p].setdata(5, 6);

Showing that [] is really a pointer-dereferencing operator, just with the extra functionality that you can add offsets into a plain C-array.

It's generally questionable to use C-arrays in C++ code; the obvious alternative to your example is std::vector:

std::vector<myclass> array(10);

Here, array[n] can be used much like previously p[n], but

• You don't get any stupid pointer-ideas, because there are no pointers in the interface
• You get proper automatic memory management, i.e. when the array goes out of scope it automatically deletes the objects and its memory
• You can get bounds-checks if you want (array.at(n))
• You can easily loop over the whole array, with (C++11) for(auto& obj: array){...}.