8

I'm currently learning C++ and I can't wrap my head around why one would define an object of a class as a pointer (i.e. Car *c = new Car; as opposed to Car c;) for no apparent reason?

Take for example:

#include <iostream> class Car { public: void accelerate() { std::cout << "Accelerating!.\n"; } }; int main() { Car *c = new Car; c->accelerate(); return 0; }

Why would one do it like that when it is much more intuitive to do it like this:

#include <iostream> class Car { public: void accelerate() { std::cout << "Accelerating!.\n"; } }; int main() { Car c; c.accelerate(); return 0; }

If a pointer to the object is ever needed, one could always declare one, no?

Improve this question
4
  • 1
    read good c++ book and learn about polymorphism. Also note that heap allocated object can have lifetime longer then current scope. Commented Jul 23, 2020 at 11:57
  • 1
    This simple example does not show the benefits coming from pointers to class. First benefit is when you pass object as argument for function, there is saving, because you pass with pointer just address, not whole complicated object. Second example is when you use polymorphism.You can point to different child classes with pointer of type of base class Commented Jul 23, 2020 at 11:58
  • 2
    One common case of this I've seen is Java and C# programmers coming to C++. Commented Jul 23, 2020 at 12:00
  • 2
    1. So they can be null. 2. So they can outlive the scope they are declared in. Commented Jul 23, 2020 at 12:25

2 Answers 2

Reset to default
4

why one would define an object of a class as a pointer

One shouldn't. Pointers are generally to be avoided as much as possible. However, they are necessary when you are doing polymorphism. In that case, use the smart pointers shared_ptr, unique_ptr instead of a raw pointer.

The following is a bad example of using pointers because now you have one additional problem i.e., "freeing the allocated memory".

int main() { Car *c = new Car; c->accelerate(); return 0; }

And you are right, the second example is much better and should be the default way to go.

Whenever such questions occur, it is best to see what C++ Core Guidelines say:

R.11: Avoid calling new and delete explicitly

Reason

The pointer returned by new should belong to a resource handle (that can call delete). If the pointer returned by new is assigned to a plain/naked pointer, the object can be leaked.

ES.60: Avoid new and delete outside resource management functions

Reason

Direct resource management in application code is error-prone and tedious.

R.3: A raw pointer (a T*) is non-owning

Reason

There is nothing (in the C++ standard or in most code) to say otherwise and most raw pointers are non-owning. We want owning pointers identified so that we can reliably and efficiently delete the objects pointed to by owning pointers. (Owning pointers are pointers which take ownership of a pointer and are responsible for freeing it.)

Example

void f() { int* p1 = new int{7}; // bad: raw owning pointer auto p2 = make_unique<int>(7); // OK: the int is owned by a unique pointer // ... }

So, the answer is use pointers only when you absolutely need to, otherwise stick to references and values.

When to use pointers?

  • When you are doing polymorphism (use smart pointers)
  • When you are need a huge array (> 1MB) because stack size is limited. (2 - 8 MB(usually) on linux, 1 MB on windows). Prefer using std::vector in this case if you can.
  • Pointers can sometimes be necessary when you are using "C" libraries or dealing with legacy C++ code.
Improve this answer
Sign up to request clarification or add additional context in comments.

Comments

3

The critical difference between your two examples is memory allocation and lifetimes.

Anything allocated by using new is allocated on the heap and must be de-allocated by calling delete. In your first example, you have created a memory leak, as the Car is never de-allocated. In modern C++ you should largely not use new or delete but instead use smart pointers (something like auto c = std::make_unique<Car>();)

The reason why you would want do this, would be to generate something which outlives the scope of the function.

In your second example the Car is created on the stack and is de-allocated when it goes out of scope (when the function returns).

Improve this answer

1 Comment

Lifetime is rarely, if ever, the reason to use pointers (except when implementing low-level object ownership, e.g. a container class). If you want an object to outlive the current scope, allocate it outside the scope or return it. And copying and moving makes this particular use of pointers completely unnecessary.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.