Ce cours initie aux bases de la programmation en utilisant le langage C++ : variables, boucles, fonctions, ... Il ne présuppose pas de connaissance préalable. Les aspects plus avancés (programmation orientée objet) sont donnés dans un cours suivant, «Introduction à la programmation orientée objet (en C++)». Il s'appuie sur de nombreux éléments pédagogiques : vidéos sous-titrées, quizz dans et hors vidéos, exercices, devoirs notés automatiquement, notes de cours.
Pointeurs : allocation dynamique
Loading...
Del curso dictado por École Polytechnique Fédérale de Lausanne
Initiation à la programmation (en C++)
210 calificaciones
De la lección
Pointeurs et références
Cette semaine nous terminons notre présentation de nouveaux types de données avec les « pointeurs » et « références » qui permettent de faire référence à d'autres données existantes ou d'en créer de nouvelles dynamiquement.
Conoce a los instructores
Jean-Cédric ChappelierDr.
School of Computer and Communication Sciences
Jamila SamDr
School of Computer and Communication Sciences
In the introduction episode on pointers, you learned
that they serve essentially three purposes: they allow
referencing, that is, to point indirectly to a memory area;
genericity, to choose, to select an element that is unknown
at the time of programming; and finally, they can also be used for what we call
dynamic allocation. This is what we will focus on now.
When a program needs to manipulate data, it will have
to allocate memory to store this data.
And in C++, you have two ways of allocating memory.
The first, which you already know, is what you do
when you write a line of code like this one, a variable declaration.
At this moment, a so-called static allocation is made.
Why static?
This means that we do not need
to wait for the execution of the program to know the memory requirements.
Here, when we compile this line of code, we already know
that the program will need a memory area dedicated
to storing an integer, and which is named v.
There are however situations where the memory requirements are known
only when the program is executed.
And a typical example is linked to the use of dynamic arrays
of <i>vector</i> type, which you have already encountered.
Suppose that we come across a vector of integers v, in our program.
I can easily add, during execution of the program,
a new element, a new cell to my array, using a line
such as this one.
At the moment I execute this line of code, this routine
will allocate the memory necessary to store this new integer.
So it is only at the time that this line is executed that allocation
happens, that the new memory area is reserved for the needs
of your program.
So of course in this case, we speak of dynamic allocation,
because we need to wait for the program's execution,
and not just its compilation, to know the memory needs.
Why? Well, we aren't sure that this line will necessarily be executed,
so we cannot, at compilation time,
know what memory area to reserve. We must wait for execution.
Here, the memory area that we allocated dynamically via the push_back statement
was allocated to contain a value of 3, and we are thus
in this situation.
Note that in the case of pointers, dynamic allocation
allows us to manipulate data without them having to be associated
with explicit names -- they don't have to correspond to variables.
For example if, in a program, we have declared a pointer named px,
it can easily store the address of an object that we allocated dynamically
during the program's execution.
We can absolutely store the address of the new object in this pointer.
And what we notice is that it is not necessary
for this object to have a name.
We can simply access it via its associated pointer.
Basically, if you want to do dynamic allocation
in a C++ program, then you can use two operators
defined by the language: the <i>new</i> operator which allows you to allocate
the memory you need, and the <i>delete</i> operator, its converse, which
allows you to free this memory once you do not need it anymore in your program.
Usage of the <i>new</i> operator follows this syntax:
one writes the name of a pointer which will
store the address, and one uses the following syntax:
<i>new</i> followed by a type name.
This will reserve a memory area capable
of storing data of this type, and will return the address
of this memory area, allowing it to be assigned to the pointer.
Let's look at a real situation. Imagine, for example,
that a program contains the following line of code:
this line declares a pointer capable
of pointing to an integer.
So I will now use the syntax that we have just seen
to do dynamic allocation.
So I take the name of my pointer
and I write px, followed by "="
and followed by my new little instruction: "new <i>type</i>;".
Here, my pointer is a pointer to an integer,
so "type", corresponding to the type to which my pointer can point,
will be "int".
What I have just done is what we call dynamic allocation.
So, how will this happen, really?
When you compile this line of code,
-- compile, not execute -- you will have a static allocation
for a variable of pointer type, named px, and capable of storing
the address of an integer.
However, it is at the moment you execute this line of code that you
will have a dynamic allocation.
And at that moment, you will have allocated a memory area for an integer,
which is this area. This area will have an address,
and it is precisely this address that you will store in px like so.
So this happens at the moment...
So what we have here is a static allocation.
However here, you have a dynamic allocation.
It is this instruction, the "new int", which allows this,
which effects this allocation
If we use this syntax to do dynamic allocation,
the newly allocated area is reserved, indeed, but it does not contain any value.
So if, when we allocate memory, we also want to assign a value
in the memory area, we must use the following option:
for an instruction for dynamic allocation.
If we refer to the example we used earlier,
so for example if I have a px pointer declared in a program,
we can use this variant of the dynamic allocation instruction.
Like so.
We write "px = new int;". So, I reserve a memory area for an integer
and I put a value in it, for example a value of 3.
When this line of code is executed, this will
reserve a memory area for an integer, which is what "new int;" means.
We put a value in it, that is, 3.
"new int(3)" returns the address of the newly-allocated area,
and the assignment will make sure that this address is copied into px.
You now know how to allocate memory dynamically.
What should you do to free this memory when you do not need it anymore?
Actually, first, why is it necessary to free this memory?
Let's take another real example. Imagine that in a program,
in a bloc,
I declare a variable which I use in that bloc.
I obviously use static allocation.
Since I am declaring a variable,
I can know my memory requirements at compile time.
We know, thanks to the notion of scope, that this variable
is not accessible outside of this bloc.
So, when we execute this set of instructions,
and we reach the end of this bloc, then we know that this variable v
will never be used again. And so, statically-allocated variables
have the property
of being deallocated automatically.
You do not need to worry about what will become
of the memory area which is, here, no longer accessible.
Let's look at an analogous example but where, this time,
we use dynamic allocation. So here, say I declare, for example,
a pointer px.
Then, in a bloc,
I decide to dynamically allocate memory that I retrieve
in the px pointer.
What is important to note here is that the memory area
that you have just allocated is not destroyed, it is not freed
as long as you have not done it explicitely.
So, when we reach the end of this bloc here during execution, this memory
area stays totally accessible as long as you do not deallocate it.
This is what makes it possible for dynamic allocation to
create memory areas which have a lifespan greater than the scope
in which they were created.
And if, at any given time, we wish to free this area,
it is up to us to do it explicitly and for that, we will need to use
the <i>delete</i> operator. So for example, I can decide after this bloc
that I do not need this memory area anymore, and I can free
the area by calling <i>delete</i> on its associated pointer.
Basically, imagine that in a program, you have a px pointer
that points to a dynamically-allocated memory area.
Imagine that this memory area contains 3, and of course
px contains the address of this area.
What happens when we free memory
by deallocating the memory area associated to px by using this statement?
Remember the little analogy with the houses on a piece of land.
well, when we call <i>delete</i>, we destroy the house.
Which means, really, that the contents of this memory area
are no longer predictable and can no longer be used safely by the program.
Your value of 3 might well stay there for a little while,
but you cannot be sure, you cannot predict
what the contents of this memory area will be.
So we see here that by simply using delete px, we are in a situation
where this memory area no longer has usable content.
However, of course, the address still exists in memory
And this address is still stored, at this point, in the px pointer.
So this justifies one of the guidelines which I highly recommend that you follow:
that every <i>delete</i> instruction must be followed
by the instruction, "pointer = nullptr;".
Which will translate to something like "px = nullptr;".
This means that you are explicitly saying that, as of that moment,
px points to nothing valid and you do not keep,
within px, an address which means nothing for the program
which cannot be used safely for the program.
To summarize dynamic allocation, and to return to our little analogy
of the address book, what I am doing
when I execute a statement such as this one,
is to add a new page to my address book, a page named ptr.
What exactly am I putting on this ptr page? Well, I am writing down the address
of this dynamically-allocated area.
So allocation can be viewed, in the context of the address book,
as reservation of land, of the memory area that will store the value.
I build a house on this land; we can see this house as being
a bit like the value 3 that I am storing in the int memory area.
And what is returned is the address of this memory area,
which I am storing in my address book.
I can, in a program, allocate memory areas dynamically
for any type of data, and it is up to the programmer to make sure
to free the memory area once he needs it no more.
For example, if I do not need this memory area anymore
then what I must do is to call <i>delete ptr</i>
to deallocate, to free the memory area.
This means that my land no longer contains any usable data.
And that it is now available
to anyone else.
If I simply do this, then
in my address book, I will still have the address of this piece of land
which is for sale, which is available to someone else.
So, I must absolutely take care to indicate
that ptr no longer points to anything by assigning nullptr to it.
This is analogous to removing the page from my address book.
I am deleting this link,
which is no longer relevant or useful.
If however we assign the nullptr value without having first deallocated
the linked memory area, we will end up in
the following situation
Suppose that on the analog of this page from the
address book, we wrote "ptr3 = nullptr;".
Well, we know now that this means that we are erasing this page
and that the link to this area is lost.
This means that I cannot access it anymore via this page
from my address book, but that the area itself is intact.
The land is not made available to anyone else, and is left as-is.
So if, for example, no other page from my address book references
this memory area, then this area is lost, it cannot be reused
in my program. It is not available for reuse
and this causes what is known as a memory leak.
This is something that must absolutely be avoided in any program.
To end on good practices: Any memory area that was allocated dynamically,
i.e, that was made using <i>new</i>, must imperatively be deallocated,
as we discussed earlier. Indeed, a memory area that was
allocated dynamically is not freed
until we do it explicitely.
There, now you know a lot of essential information
about pointers and we will summarize all of this with a small example
Here is a program we will go over step-by-step.
Here, we declare a variable px which is a pointer
that can point to an integer, and I take the precaution
of initializing it to nullptr, which means that it points to nothing.
Second line of code,
there is a dynamic allocation. This dynamic allocation reserves
a memory area capable of storing an integer.
And this memory area has an address,
and this address is returned by the execution of "new int".
This is the address I will assign to px.
So now, I am making the px pointer point to this
newly allocated memory area.
Then, third instruction.
I use the famous little star to access the content pointer to by px.
The content pointed to by px is this.
In this pointed-to content, I will store the value 20,
which corresponds to this.
Then, I want to make sure that I have stored the right value
in this memory area, and so I want to display its contents.
Once again, I access the content that px points to with the star operator,
and this will simply display the value 20, followed by a newline,
a line break.
Then, I suppose that I no longer need
my memory area, and so I call delete,
which means that this memory area no longer has any usable content.
And I want to make sure that px doesn't point towards obsolete content,
that it doesn't point to an address that cannot be used safely and so,
once again, I assign nullptr to the pointer's value.
The first version of the program that we have examined can be written
in a more concise way, given that these two instructions, which consist
in allocating memory and storing a value within it,
can actually be written as a single line with this syntax.
To make it shorter still, I can replace these two lines of code
by a single line, this one.
In this line, I start by declaring the pointer,
except that instead of starting by initializing it to nullptr and then
assigning to it the result of "new int(20)", I simply
put the value of "new int(20)" directly into px.
This means that I spare one statement.
When you write your first programs with pointers,
and even for the following ones, it is likely that, from time to time,
you will encounter a dreadful error, the "segmentation fault", which will cause
your program to crash. What is it?
Typically, "segmentation fault"-type errors will occur
when we try, via a pointer, to access a memory area
which was not reserved.
If we look at this example, this statement
declares a px pointer but does not reserve any allocated memory area.
There is no initialization, no new, no nothing.
So here, the contents of px are unknown and here, what we are trying to do
is to access the content pointed to by px,
which does not exist, since we never allocated it, and
to store a value of 20 in it.
Obviously, this is impossible and it will result in a segmentation fault
error, causing your program to crash.
The correct solution would of course be to allocate some memory
to associate to the px pointer, which is done like so,
at execution time. So we allocate the memory area, and at that moment,
our px pointer will contain the address of this newly-allocated
memory area.
So of course, once this memory area exists, we can
access it with no trouble, to store a value of 20 in it.
So now, this statement will execute without any errors.
We have just seen that it is essential to allocate before using;
some advice follows, good practice concerning
initialization of pointers.
It is recommended to always initialize pointers,
even just to the nullptr value.
Thus, if, when we declare the pointer, we do not yet know
where it will point to, it is recommended to initialize it
by using nullptr, which means that the pointers points to nothing,
but that it is known explicitly.
And thanks to this initialization, it becomes possible to implement
a certain number of safeguards. For example, before accessing
a memory area pointed to by a pointer, I can now
take care to check if this pointer
does indeed point to something or not.
Thus, it is possible, thanks to this initialization, to test
whether the pointer points to something before accessing this area,
as I could do here.
So we see that, thanks to this initialization, a certain number
of safeguards can be implemented to protect access to memory areas
pointed to by pointers.
Explora nuestro catálogo
Inscríbete de manera gratuita y obtén recomendaciones personalizadas, actualizaciones y ofertas.
Coursera brinda acceso universal a la mejor educación del mundo, al asociarse con las mejores universidades y organizaciones, para ofrecer cursos en línea.
© 2018 Coursera Inc. Todos los derechos reservados.
