When to Use References vs Smart Pointers vs Raw Pointers
Offers several tools for memory management, including references, smart pointers, and raw pointers. To write safe and efficient code, it’s important to understand the specific scenarios where each of these tools may outperform the others.
When to use references?
As a general rule, it’s advised to always prefer references over pointers, because they are safer and easier to work with. With that said, here are a few specific use cases of references:
- You want a cleaner and more readable syntax. References don’t need dereferencing and are easier to manage.
- You want to enforce non-nullability to an extent. References can’t be explicitly set to
NULL. - You want to pass a local variable to a function without making any copies. References are just aliases of the original object.
When to use smart pointers?
The golden rule is to avoid pointers (both raw and smart) until you can’t. This is because pointers are harder to manage, and small mistakes can lead to issues like memory leaks and dangling pointers. With that said, here are a few scenarios where using pointers is the right choice:
- You want to manage the ownership of dynamically allocated objects. Smart pointers excel in this regard by automating resource cleanup, even in case of exceptions.
- You want to maintain shared ownership of a dynamic resource. In such a situation, shared pointers are the perfect candidate as they perform reference counting to manage the lifetime of shared objects.
- You want to enforce exclusive ownership of a dynamic resource, such that no other pointer can have access to it. This use case can be fulfilled by using a unique pointer.
When to use raw pointers?
Raw pointers should only be considered when references and smart pointers are not feasible. The reason is that raw pointers don’t offer any memory safety, and are one of the biggest reasons why programs crash. With that said, here are a few justifiable use cases for raw pointers:
- You are interfacing with C-style libraries. Since C doesn’t support smart pointers, you may be forced to use raw pointers.
- You are writing performance-critical code where the overhead of smart pointers is a concern. For example, you may be building an intensive embedded application that has to run in a resource-constrained environment.
- You are working with legacy code that predates the introduction of smart pointers. In such cases, using raw pointers may be your only option.
Tudo estava claro?
Conteúdo do Curso
C++ Smart Pointers
C++ Smart Pointers
When to Use References vs Smart Pointers vs Raw Pointers
Offers several tools for memory management, including references, smart pointers, and raw pointers. To write safe and efficient code, it’s important to understand the specific scenarios where each of these tools may outperform the others.
When to use references?
As a general rule, it’s advised to always prefer references over pointers, because they are safer and easier to work with. With that said, here are a few specific use cases of references:
- You want a cleaner and more readable syntax. References don’t need dereferencing and are easier to manage.
- You want to enforce non-nullability to an extent. References can’t be explicitly set to
NULL. - You want to pass a local variable to a function without making any copies. References are just aliases of the original object.
When to use smart pointers?
The golden rule is to avoid pointers (both raw and smart) until you can’t. This is because pointers are harder to manage, and small mistakes can lead to issues like memory leaks and dangling pointers. With that said, here are a few scenarios where using pointers is the right choice:
- You want to manage the ownership of dynamically allocated objects. Smart pointers excel in this regard by automating resource cleanup, even in case of exceptions.
- You want to maintain shared ownership of a dynamic resource. In such a situation, shared pointers are the perfect candidate as they perform reference counting to manage the lifetime of shared objects.
- You want to enforce exclusive ownership of a dynamic resource, such that no other pointer can have access to it. This use case can be fulfilled by using a unique pointer.
When to use raw pointers?
Raw pointers should only be considered when references and smart pointers are not feasible. The reason is that raw pointers don’t offer any memory safety, and are one of the biggest reasons why programs crash. With that said, here are a few justifiable use cases for raw pointers:
- You are interfacing with C-style libraries. Since C doesn’t support smart pointers, you may be forced to use raw pointers.
- You are writing performance-critical code where the overhead of smart pointers is a concern. For example, you may be building an intensive embedded application that has to run in a resource-constrained environment.
- You are working with legacy code that predates the introduction of smart pointers. In such cases, using raw pointers may be your only option.
Tudo estava claro?
