CODEWITHSUNDEEP
c++
madac
madac

Reputation: 3

C++ pointer vs object

Could you please clear up a question for me regarding pointer vs object in C++. I have the below code that has a class called "person" and a list that allows for 100 objects of that class type.

class person {...}

int main {
    person* mylist;
    mylist = new person[100];
    mylist[0].set_name("John")
    // ...
}

In this code I can call a method of the class by mylist[0].set_name() meaning (by my understanding) that mylist[0] is an object (hence the . operator to call a method). The code works fine.

I have another project where the "person" class is used as a base class to derive classes "carpenter" and "welder". The derived classes simply overwrite a virtual function called salary in the base "person" class to allow for a different calculation of salary.

person* mylist[100];
mylist[0] = new carpenter;
mylist[0]->set_name("John");

This code works fine as well. My question is - why in the first code I can call the set_name method using the . (meaning mylist[0] is an object) and in the second code I have to use the -> operator (meaning mylist[0] is a pointer to the object)?

Upvotes: 0

Views: 702

Answers (2)

mcilloni
mcilloni

Reputation: 743

T* represents a pointer type, which represents a variable that contains a "reference" (usually a memory address) to some instance of type T. Using a real world comparison, a T* pointer stands to T like a street address stands to a building.

Pointers allow you to refer to some instance owned by some other variable, and you can use a valid, non null instance of T* to read and write on a T. In this, they are similar to another C++ concept, references (written as T&), which allow you to alias variables, but differ significantly from pointers by not being objects in their own regard.

A pointer is, in fact, an object itself, with each pointer variable having its own unique address and being thus storable and referenceable. For instance, you can have pointers to pointers (T**) and references to pointers (T*&), but not pointers to references - pointers exist, while references may not (they are usually implemented as pointers underneath though).

To reflect the this "indirect" nature of pointers, C and C++ provide you with two different operators which allow you to dereference a pointer (* and ->), and to reference a variable (&).

For instance, you may do the following:

struct A { int x; };

// ... 

A a {};
A *aptr { &a }; // `&` takes the address of `a` and stores it into the `aptr` variable of type `A*`

aptr->x = 33; // `->` is equivalent here to `(*aptr).x`, a.x is now 33

A a2 {};
A **aptrptr { &aptr }; // pointer to pointer

*aptrptr = &a2; // `aptr` now points to `a2`

operator-> is basically syntactic sugar that avoids you some cumbersome expressions like (*aptr).x.

References, being basically just aliases to something else, do not need any special syntax at all, and are always converted transparently when neeeded:

int x { 33 };
int &xref { x }; // `xref` refers to `x`
xref = 12; // `x` is now 33

int y = xref; // copies `x` into `y`, no special syntax needed

Pointers are also used in the C language to access arrays, which always decay to a pointer as soon as they are referred to in expressions. This is messy and it's one of the reasons std::vector and std::array should always be used in their place when feasible.

int x[33];
x[3] = 44; // equivalent to `*(&x[0] + 3) = 44`

Finally, the "indirect" nature of pointers and references allow C++ to convert a Derived* to a Base*, given that a derived class contains a full instance of its base (it gets more complicated with multiple inheritance though).

Every class that inherits or contains from another class containing virtual methods will include a hidden pointer to a _Virtual Method Table`, a list of pointers to functions which will be used to dispatch the virtual methods to the correct implementation.

PS: in modern C++, you should rarely need raw pointers. The correct approach is to use containers such as std::vector, std::array and std::string, and special pointer-like wrappers called smart pointers (like std::unique_ptr) every time you need a pointer for some reason. These will handle the lifetime of a pointer for you, avoiding memory leaks and vastly simplifying memory handling. For the same reason, the new operator should be mostly considered as being deprecated and should not be used at all (unless in placement new expressions, are potentially dangerous if used improperly).

Upvotes: 1

Шериф Грей
Шериф Грей

Reputation: 134

basically the first case works like this: you have an array of objects. To access the object fields and methods you use . operator. In the second case you have an array of pointers to an object. Pointer is just a memory address, that points to an object of some type. In your case, this is an array of pointers to class person. By default, these pointers are invalid; you have to set them to the address of some existing object. new creates an object on the heap, and returns you an address of that object. In order to access the value behind the pointer, you have to de-reference it. The syntax is this:

some_type obj;
some_type* ptr = &obj; // get the address of the object
(*ptr).some_method(); // de-reference the pointer and call it
ptr->some_method(); // same

Upvotes: 0

Related Questions