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 : déclaration et opérateurs de base
Loading...
En provenance du cours de École Polytechnique Fédérale de Lausanne
Initiation à la programmation (en C++)
224 notes
Explore Related Videos
At Coursera, you will find the best lectures in the world. Here are some of our personalized recommendations for you
À partir de la leçon
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.
Rencontrer les enseignants
Jean-Cédric ChappelierDr.
School of Computer and Communication Sciences
Jamila SamDr
School of Computer and Communication Sciences
With our address book analogy,
you now know of most of the operations we can do
on pointers.
In this episode, we will go over all these operations
one after the other and discuss
how to use them in C++ language syntax.
To declare a variable in C++, we know we can
use the following syntax.
So, name of the type, for example "int" for integers
followed by the identifier associated to the variable, i.e "x".
For a pointer, the notation is the same, except that the type
will indicate that it is a pointer to a particular data type.
So for example if I want to declare a pointer
on an integer, the associated type will be: "int*"
to mean "pointer to an integer", followed by the name of the pointer,
so of the pointer-type variable we are creating.
Similarly, if I want to declare a pointer on a "double"
I will use the following syntax.
I will write "double*" as the type
followed by the identifier for the variable, "ptr".
So here, I declared a variable named "ptr", the type of which is pointer
on a variable of type "double".
This is for simple declaration. If I want to initialize at the same time,
the syntax is analogous to the one I used up until now.
For example, if I want to write, declare and initialize a variable "x"
of integer type, initialized to 4, I use the following syntax.
Well, the syntax is quite analogous for pointers.
I must indicate in parentheses the value of the pointer.
And this value must be an address.
So here are three examples of declaration-initialization situations
on pointer-type variables.
Here, we are taking a bit of ahead start on what will follow in this episode
and the following ones, by seeing
how to obtain the address of a given memory area,
in this case the address of the memory area named "i", the variable "i";
and how to dynamically allocate a memory area
capable of storing data of a certain type, in this case an integer.
So of course, we will review these concepts
in much further detail when the time comes.
First line here, I am declaring-initializing
a "ptr" variable of type pointer to integer
So the "ptr" variable can contain the address of an integer
and we initialize this variable using a special value
which is "nullptr" meaning that the "ptr" pointer
points to nothing.
So remember our address book analogy.
Here, we have a page of our address book which is empty,
which is initialized to nothing, which contains nothing.
Second instruction, I initialize a "ptr" pointer
using the address of an existing memory area,
of a variable which exists in memory.
We will come back to this later.
And here, I initialize my pointer using the address of
a dynamically allocated memory area.
These concepts will be the focus of the following episodes
and of the rest of this sequence.
By the way, please note that the special value "nullptr" can be assigned
to any type of pointer -- be it a pointer to a "double",
pointer to an integer, pointer to any other type
of data defined in C++.
In either case, it means that
the pointer points to nothing.
C++ provides two fundamental operators
for pointer manipulation.
The '&' operator (ampersand), and the '*' operator (star).
The role of the '&' operator is to return the memory address
of the value of a variable.
Let's see what this means on a real example.
Here, we have a small program which starts by declaring
a variable 'x' of integer type, and initializes it to 3.
We know that to each variable of a program,
an address in memory is assigned.
Let's name this address "adr".
Then, we declare a second variable "px"
which is of type pointer-to-integer.
Meaning that it is capable of containing the address
of a memory area containing an integer.
So we have this situation.
And here, we will start by initializing the variable "px"
using the special value "nullptr".
Which basically means that "px"
is capable of pointing to a memory area containing an integer,
but that at this moment, it points towards nothing.
It points to nothing at all.
Now, the third line of the program.
And this is where our "&" operator comes in.
We assign, to the variable "px", the address of the variable "x".
We have seen that this address here is "adr",
so this is what we end up with.
We will assign the address of the variable "x" to "px".
We are establishing the link between pointer and pointed-to area
with this assignment.
So to sum up, "px" returns the address associated to the variable "x".
The '*' operator allows us to get the value pointed to
by a pointer-type variable.
Earlier, we learned about the '&' operator.
So "&x", where "x" is a variable,
will return the address of "x" in memory.
Now, imagine that we have a pointer "px".
This pointer points to, contains the address of, a memory area
containing a certain value, for example 3.
And we wish to find the value pointed to by using the pointer.
For this, we need to use the '*' operator
applied to a pointer-type variable. This is what will allow us
to get the value pointed to by this pointer.
So if we go over our small example from the previous episode again,
we go through the first instructions
and we find ourselves in the following situation.
A variable "x" initialized to a value of 3, of integer type and which has an address.
A second variable "px" which is of pointer-to-integer type
which we begin by initializing to "nullptr",
meaning that it points to nothing.
And to which we then assign the address of "x"
which will establish the link between pointer
and pointed-to variable.
Then, last instruction, and this is where we call
our famous little '*' operator
which will allow us to establish the link between pointer
and pointed-to value.
So here, we have "*px".
we use the '*' operator on the pointer, which will allow us to get,
through the pointer, the value pointed to by this pointer.
Now, imagine that I have a variable of type "int"
named "i" which contains a certain value and which has an address in memory.
If I write "&i", I will get a value of type pointer-to-int
which is the address "adr".
Now, if I write " *&i ",
I will apply the '*' operator to this pointer
which will return the value stored at that address,
which is 3.
So writing " *&i " is exactly equivalent to writing "i"
since I directly access the value contained in "i".
C++ has the reputation of being a language with a somewhat complicated syntax.
The '*' and '&' operators which we have just seen
are a first example of that.
In fact, depending on the context in which they are used, these operators
do not necessarily always mean the same thing.
Let's see why.
There are now two contexts in which we use the '&' operator.
The first context is when the ampersand follows a type name
and the second is when the &
precedes the name of a pointer-type variable.
In the first case, we will use the '&' to declare
a reference, either when we pass
a variable by reference to a function, or when we declare a reference on its own.
For example, I can declare a variable "i" of integer type
and I can declare a reference
to this variable named "id".
This simply means that "id" is now
another name for the variable "i".
So, first context of use,
we use the "&" to indicate that we are declaring a reference.
Second context of use: when the ampersand symbol
precedes a variable name. We have just seen
that in this case, we will simply obtain
the address of this variable.
And this address can of course be assigned to a pointer-type variable
to establish the link between a pointer and a pointed-to variable.
So here, we have a context of use which
is completely different from the first and which
leads us to a totally different situation.
So, first potential for confusion: two possible contexts for use
of the ampersand which means different things in C++.
Second example where C++ uses the same symbol
to represent two different things: the star '*'.
Indeed, we saw earlier that
when a '*' follows a type name as it is the case here,
it is simply used to declare a variable of pointer type.
For example, if I write something like this in a program,
I am declaring a variable named "id"
and this variable is defined as having a pointer-to-int type
thanks to this '*'.
This means that it can store, potentially,
the address of a memory area containing an integer.
Like so.
So "id"
is a variable of pointer type
declared using '*'.
If, however, the '*' precedes the name of a variable,
this supposes that the variable considered
is a pointer-type variable.
And the '*' will serve to return the value pointed to by the pointer.
And here, this is the situation we are in.
We have a pointer-type variable which contains
the address of a certain memory area, which contains a value.
Let's say that this variable is an integer.
So "*id" will simply return the value of 3,
the value pointed to by the "id" pointer.
So here, the '*' serves to find the value pointed to by a pointer.
It is a context of use
which is quite different from what we have seen up until now.
Explorer notre catalogue
Rejoignez-nous gratuitement et obtenez des recommendations, des mises à jour et des offres personnalisées.
Coursera propose un accès universel à la meilleure formation au monde,
en partenariat avec des universités et des organisations du plus haut niveau, pour proposer des cours en ligne.
© 2019 Coursera Inc. Tous droits réservés.
