In
computer science
Computer science is the study of computation, information, and automation. Computer science spans Theoretical computer science, theoretical disciplines (such as algorithms, theory of computation, and information theory) to Applied science, ...
, a smart pointer is an
abstract data type
In computer science, an abstract data type (ADT) is a mathematical model for data types, defined by its behavior (semantics) from the point of view of a '' user'' of the data, specifically in terms of possible values, possible operations on data ...
that simulates a
pointer while providing added features, such as automatic
memory management
Memory management (also dynamic memory management, dynamic storage allocation, or dynamic memory allocation) is a form of Resource management (computing), resource management applied to computer memory. The essential requirement of memory manag ...
or
bounds checking
In computer programming, bounds checking is any method of detecting whether a variable is within some bounds before it is used. It is usually used to ensure that a number fits into a given type (range checking), or that a variable being used as ...
. Such features are intended to reduce
bugs caused by the misuse of pointers, while retaining efficiency. Smart pointers typically keep track of the memory they point to, and may also be used to manage other resources, such as network connections and
file handle
In Unix and Unix-like computer operating systems, a file descriptor (FD, less frequently fildes) is a process-unique identifier (handle) for a file or other input/output resource, such as a pipe or network socket.
File descriptors typically ha ...
s. Smart pointers were first popularized in the programming language
C++ during the first half of the 1990s as rebuttal to criticisms of C++'s lack of
automatic garbage collection.
Pointer misuse can be a major source of bugs. Smart pointers prevent most situations of
memory leak
In computer science, a memory leak is a type of resource leak that occurs when a computer program incorrectly manages memory allocations in a way that memory which is no longer needed is not released. A memory leak may also happen when an objec ...
s by making the memory deallocation automatic. More generally, they make
object destruction automatic: an object controlled by a smart pointer is automatically destroyed (
finalized and then deallocated) when the last (or only) owner of an object is destroyed, for example because the owner is a
local variable
In computer science, a local variable is a variable that is given ''local scope''. A local variable reference in the function or block in which it is declared overrides the same variable name in the larger scope. In programming languages with ...
, and execution leaves the variable's
scope. Smart pointers also eliminate
dangling pointer
Dangling pointers and wild pointers in computer programming are pointers that do not point to a valid object of the appropriate type. These are special cases of memory safety violations. More generally, dangling references and wild references a ...
s by postponing destruction until an object is no longer in use.
If a language supports automatic garbage collection (for example,
Java
Java is one of the Greater Sunda Islands in Indonesia. It is bordered by the Indian Ocean to the south and the Java Sea (a part of Pacific Ocean) to the north. With a population of 156.9 million people (including Madura) in mid 2024, proje ...
or
C#), then smart pointers are unneeded for reclaiming and safety aspects of memory management, yet are useful for other purposes, such as
cache data structure residence management and
resource management
In organizational studies, resource management is the efficient and effective development of an organization's resources when they are needed. Such resources may include the financial resources, inventory, human skills, production resources, or ...
of objects such as file handles or
network socket
A network socket is a software structure within a network node of a computer network that serves as an endpoint for sending and receiving data across the network. The structure and properties of a socket are defined by an application programming ...
s.
Several types of smart pointers exist. Some work with
reference counting
In computer science, reference counting is a programming technique of storing the number of references, pointers, or handles to a resource, such as an object, a block of memory, disk space, and others.
In garbage collection algorithms, refere ...
, others by assigning ownership of an object to one pointer.
History
Even though C++ popularized the concept of smart pointers, especially the
reference-counted variety,
the immediate predecessor of one of the languages that inspired C++'s design had reference-counted references built into the language. C++ was inspired in part by
Simula67
Simula is the name of two simulation programming languages, Simula I and Simula 67, developed in the 1960s at the Norwegian Computing Center in Oslo, by Ole-Johan Dahl and Kristen Nygaard. Syntactically, it is an approximate superset of AL ...
.
Simula67's ancestor was
Simula I. Insofar as Simula I's ''element'' is analogous to C++'s pointer without ''null'', and insofar as Simula I's process with a dummy-statement as its activity body is analogous to C++'s ''struct'' (which itself is analogous to
C. A. R. Hoare's ''record'' in then-contemporary 1960s work), Simula I had reference counted elements (i.e., pointer-expressions that house indirection) to processes (i.e., records) no later than September 1965, as shown in the quoted paragraphs below.
Processes can be referenced individually. Physically, a process reference is a pointer to an area of memory containing the data local to the process and some additional information defining its current state of execution. However, for reasons stated in the Section 2.2 process references are always indirect, through items called ''elements.'' Formally a reference to a process is the value of an expression of type ''element''.
…
''element'' values can be stored and retrieved by assignments and references to ''element'' variables and by other means.
The language contains a mechanism for making the attributes of a process accessible from the outside, i.e., from within other processes. This is called remote access- ing. A process is thus a referenceable data structure.
It is worth noticing the similarity between a process whose activity body is a dummy statement, and the record concept recently proposed by C. A. R. Hoare and N. Wirth
Because C++ borrowed
Simula
Simula is the name of two simulation programming languages, Simula I and Simula 67, developed in the 1960s at the Norwegian Computing Center in Oslo, by Ole-Johan Dahl and Kristen Nygaard. Syntactically, it is an approximate superset of AL ...
's approach to memory allocationthe ''new'' keyword when allocating a process/record to obtain a fresh ''element'' to that process/recordit is not surprising that C++ eventually resurrected Simula's reference-counted smart-pointer mechanism within ''element'' as well.
Features
In
C++, a smart pointer is implemented as a template class that mimics, by means of
operator overloading
In computer programming, operator overloading, sometimes termed ''operator ad hoc polymorphism'', is a specific case of polymorphism, where different operators have different implementations depending on their arguments. Operator overloading ...
, the behaviors of a traditional
(raw) pointer, (e.g. dereferencing, assignment) while providing additional memory management features.
Smart pointers can facilitate intentional programming by expressing, in the type, how the memory of the referent of the pointer will be managed. For example, if a C++ function returns a pointer, there is no way to know whether the caller should delete the memory of the referent when the caller is finished with the information.
SomeType* AmbiguousFunction(); // What should be done with the result?
Traditionally, naming conventions have been used to resolve the ambiguity,
which is an error-prone, labor-intensive approach.
C++11
C++11 is a version of a joint technical standard, ISO/IEC 14882, by the International Organization for Standardization (ISO) and International Electrotechnical Commission (IEC), for the C++ programming language. C++11 replaced the prior vers ...
introduced a way to ensure correct memory management in this case by declaring the function to return a
unique_ptr
,
std::unique_ptr ObviousFunction();
The declaration of the function return type as a
unique_ptr
makes explicit the fact that the caller takes ownership of the result, and the C++ runtime ensures that the memory will be reclaimed automatically. Before
C++11
C++11 is a version of a joint technical standard, ISO/IEC 14882, by the International Organization for Standardization (ISO) and International Electrotechnical Commission (IEC), for the C++ programming language. C++11 replaced the prior vers ...
, unique_ptr can be replaced with
auto_ptr, which is now deprecated.
Creating new objects
To ease the allocation of a
std::shared_ptrC++11
C++11 is a version of a joint technical standard, ISO/IEC 14882, by the International Organization for Standardization (ISO) and International Electrotechnical Commission (IEC), for the C++ programming language. C++11 replaced the prior vers ...
introduced:
auto s = std::make_shared(constructor, parameters, here);
and similarly
std::unique_ptrSince
C++14
C14, C.XIV or C-14 may refer to:
Time
* The 14th century
* Carbon-14, a radioactive isotope of carbon
** Radiocarbon dating, C-14 dating, a method for dating events
Science
* IEC 60320#C14, IEC 60320 C14, a polarised, three pole socket electrical ...
one can use:
auto u = std::make_unique(constructor, parameters, here);
It is preferred, in almost all circumstances, to use these facilities over the
new
keyword.
unique_ptr
C++11
C++11 is a version of a joint technical standard, ISO/IEC 14882, by the International Organization for Standardization (ISO) and International Electrotechnical Commission (IEC), for the C++ programming language. C++11 replaced the prior vers ...
introduces , defined in the header .
A is a container for a raw pointer, which the
unique_ptr
is said to own. A
unique_ptr
explicitly prevents copying of its contained pointer (as would happen with normal assignment), but the function can be used to transfer ownership of the contained pointer to another . A
unique_ptr
cannot be copied because its copy constructor and assignment operators are explicitly deleted.
std::unique_ptr p1(new int(5));
std::unique_ptr p2 = p1; // Compile error.
std::unique_ptr p3 = std::move(p1); // Transfers ownership. p3 now owns the memory and p1 is set to nullptr.
p3.reset(); // Deletes the memory.
p1.reset(); // Does nothing.
std:: auto_ptr
is
deprecated
Deprecation is the discouragement of use of something human-made, such as a term, feature, design, or practice. Typically something is deprecated because it is claimed to be inferior compared to other options available.
Something may be deprec ...
under C++11 and completely removed from
C++17
C17, C-17 or C.17 may refer to:
Transportation
* , a 1917 British C-class submarine
Air
* Boeing C-17 Globemaster III, a military transport aircraft
* Lockheed Y1C-17 Vega, a six-passenger monoplane
* Cierva C.17, a 1928 English experimental ...
. The copy constructor and assignment operators of do not actually copy the stored pointer. Instead, they
transfer it, leaving the prior object empty. This was one way to implement strict ownership, so that only one object can own the pointer at any given time. This means that should not be used where copy semantics are needed.
Since already existed with its copy semantics, it could not be upgraded to be a move-only pointer without breaking
backward compatibility
In telecommunications and computing, backward compatibility (or backwards compatibility) is a property of an operating system, software, real-world product, or technology that allows for interoperability with an older legacy system, or with Input ...
with existing code.
shared_ptr and weak_ptr
C++11 introduces and , defined in the header .
C++11 also introduces ( was introduced in C++14) to safely allocate dynamic memory in the
RAII paradigm.
A is a container for a
raw pointer. It maintains
reference counting
In computer science, reference counting is a programming technique of storing the number of references, pointers, or handles to a resource, such as an object, a block of memory, disk space, and others.
In garbage collection algorithms, refere ...
ownership of its contained pointer in cooperation with all copies of the . An object referenced by the contained raw pointer will be destroyed when and only when all copies of the have been destroyed.
std::shared_ptr p0(new int(5)); // Valid, allocates 1 integer and initialize it with value 5.
std::shared_ptr p1(new int[5]); // Valid, allocates 5 integers.
std::shared_ptr p2 = p1; // Both now own the memory.
p1.reset(); // Memory still exists, due to p2.
p2.reset(); // Frees the memory, since no one else owns the memory.
A is a container for a raw pointer. It is created as a copy of a
shared_ptr
. The existence or destruction of copies of a
shared_ptr
have no effect on the
shared_ptr
or its other copies. After all copies of a
shared_ptr
have been destroyed, all
weak_ptr
copies become empty.
std::shared_ptr p1 = std::make_shared(5);
std::weak_ptr wp1 ; // p1 owns the memory.
// p2 is destroyed. Memory is owned by p1.
p1.reset(); // Free the memory.
std::shared_ptr p3 = wp1.lock();
// Memory is gone, so we get an empty shared_ptr.
if (p3)
Because the implementation of uses
reference counting
In computer science, reference counting is a programming technique of storing the number of references, pointers, or handles to a resource, such as an object, a block of memory, disk space, and others.
In garbage collection algorithms, refere ...
,
circular references are potentially a problem. A circular
shared_ptr
chain can be broken by changing the code so that one of the references is a
weak_ptr
.
Multiple threads can safely simultaneously access different and objects that point to the same object.
The referenced object must be protected separately to ensure
thread safety
In multi-threaded computer programming, a function is thread-safe when it can be invoked or accessed concurrently by multiple threads without causing unexpected behavior, race conditions, or data corruption. As in the multi-threaded context where ...
.
and are based on versions used by the
Boost libraries
Boost is a set of library (computing), libraries for the C++ programming language that provides support for tasks and structures such as linear algebra, pseudorandom number generator, pseudorandom number generation, multithreading, image proces ...
.
C++ Technical Report 1 (TR1) first introduced them to the standard, as
general utilities, but C++11 adds more functions, in line with the Boost version.
Other types of smart pointers
There are other types of smart pointers (which are not in the C++ standard) implemented on popular C++ libraries or custom
STL, some examples include
hazard pointer
In a multithreaded computing environment, hazard pointers are one approach to solving the problems posed by dynamic memory management of the nodes in a lock-free data structure. These problems generally arise only in environments that don't hav ...
and intrusive pointer.
See also
*
auto_ptr
*
Fat pointer
In computer science, dynamic dispatch is the process of selecting which implementation of a polymorphic operation (method or function) to call at run time. It is commonly employed in, and considered a prime characteristic of, object-oriented ...
*
Tagged pointer
*
Opaque pointer
In computer programming, an opaque pointer is a special case of an opaque data type, a data type declared to be a pointer to a record or data structure of some unspecified type.
Opaque pointers are present in several programming languages inclu ...
*
Reference (computer science)
In computer programming, a reference is a value that enables a program to indirectly access a particular datum, such as a variable (computer science), variable's value or a record (computer science), record, in the computer's memory (computing), ...
*
Boost (C++ libraries)
Boost, boosted or boosting may refer to:
Science, technology and mathematics
* Boost, positive manifold pressure in Turbocharger, turbocharged engines
* Boost (C++ libraries), a set of free peer-reviewed portable C++ libraries
* Boost (material), ...
*
Automatic Reference Counting
Automatic Reference Counting (ARC) is a memory management feature of the Clang compiler providing automatic reference counting for the Objective-C and Swift (programming language), Swift programming languages. At compile time, it inserts into the o ...
*
Resource acquisition is initialization
Resource acquisition is initialization (RAII) is a programming idiom used in several object-oriented, statically typed programming languages to describe a particular language behavior. In RAII, holding a resource is a class invariant, and is tie ...
(RAII)
*
Garbage collection in computer programming
References
Further reading
*
*
* {{cite web , url=http://www.drdobbs.com/184403837/ , title=The New C++: Smart(er) Pointers , author-first=Herb , author-last=Sutter , author-link=Herb Sutter , date=2002-08-01
Smart Pointers - What, Why, Which? Yonat Sharon
John M. Dlugosz
External links
The C++ Standard Library - A Tutorial and Reference' by Nicolai M. Josuttis
Articles with example C++ code
Data types
Pointers (computer programming)