Dans la faq en anglais de Steve Summit, on peut lire :
--------------
It is important to realize that a reference like x [3] generates
different code depending on whether x is an array or a pointer. Given
the declarations above, when the compiler sees the expression a[3], it
emits code to start at the location ``a,'' move three past it, and
fetch the character there. When it sees the expression p[3], it emits
code to start at the location ``p,'' fetch the pointer value there,
add three to the pointer, and finally fetch the character pointed to.
--------------
C'est à dire que le compilo se comporte différement selon si x est un
tableau ou un pointeur, dans une expression du type a[3] ou p[3].
Cependant, un peu plus loin, on peut lire :
--------------
An lvalue of type array-of-T which appears in an expression decays
(with three exceptions) into a pointer to its first element; the type
of the resultant pointer is pointer-to-T.
(The exceptions are when the array is the operand of a sizeof or &
operator, or is a string literal initializer for a character array.)
--------------
Cela implique que, si a est un tableau, dans une expression du type
a[3], a est automatiquement converti en pointeur sur l'adresse du
premier élément de a.
(Si j'ai bien compris)
N'y a-t-il pas contradiction?
PS : je m'arrache les cheveux en criant comme un ours, ce qui fait
peur à ma voisine de bureau. Elle n'en dort plus la nuit, ce qui lui
impose de prendre de l'ecstasy tous les matins pour garder le rythme,
et ça c'est pas bon pour sa santé. Ce post est donc une question de
vie ou de mort.
Cette action est irreversible, confirmez la suppression du commentaire ?
Signaler le commentaire
Veuillez sélectionner un problème
Nudité
Violence
Harcèlement
Fraude
Vente illégale
Discours haineux
Terrorisme
Autre
Richard Delorme
... sur les tableaux et les pointeurs.
Dans la faq en anglais de Steve Summit, on peut lire :
-------------- It is important to realize that a reference like x [3] generates different code depending on whether x is an array or a pointer. Given the declarations above, when the compiler sees the expression a[3], it emits code to start at the location ``a,'' move three past it, and fetch the character there. When it sees the expression p[3], it emits code to start at the location ``p,'' fetch the pointer value there, add three to the pointer, and finally fetch the character pointed to.
Ce qu'il veut dire c'est qu'un pointeur est une variable qui occupe une place en mémoire pour stocker une adresse, tandis que pour tableau, on ne stocke que les éléments :
+----------+ | p +---+ +----------+ | .... | la valeur dans p est l'adresse de p[0] +----------+ | | p[0] + <-+ +----------+ | p[1] + +----------+ | p[2] + +----------+ | + +----------+
-------------- C'est à dire que le compilo se comporte différement selon si x est un tableau ou un pointeur, dans une expression du type a[3] ou p[3].
Cependant, un peu plus loin, on peut lire :
-------------- An lvalue of type array-of-T which appears in an expression decays (with three exceptions) into a pointer to its first element; the type of the resultant pointer is pointer-to-T.
(The exceptions are when the array is the operand of a sizeof or & operator, or is a string literal initializer for a character array.) -------------- Cela implique que, si a est un tableau, dans une expression du type a[3], a est automatiquement converti en pointeur sur l'adresse du premier élément de a. (Si j'ai bien compris)
N'y a-t-il pas contradiction?
Non. Il dit juste que a prend le type pointeur-vers-T dans certain cas, mais a ne devient pas une variable qui occupe de la mémoire pour autant. D'ailleurs il indique l'exception pour l'opérateur & sur un tableau : &a == a == &a[0] qui montre bien que a n'occupe pas de place en mémoire en soi.
PS : je m'arrache les cheveux en criant comme un ours, ce qui fait peur à ma voisine de bureau. Elle n'en dort plus la nuit, ce qui lui impose de prendre de l'ecstasy tous les matins pour garder le rythme, et ça c'est pas bon pour sa santé. Ce post est donc une question de vie ou de mort.
oulala... c'est à ce point...
-- Richard
... sur les tableaux et les pointeurs.
Dans la faq en anglais de Steve Summit, on peut lire :
--------------
It is important to realize that a reference like x [3] generates
different code depending on whether x is an array or a pointer. Given
the declarations above, when the compiler sees the expression a[3], it
emits code to start at the location ``a,'' move three past it, and
fetch the character there. When it sees the expression p[3], it emits
code to start at the location ``p,'' fetch the pointer value there,
add three to the pointer, and finally fetch the character pointed to.
Ce qu'il veut dire c'est qu'un pointeur est une variable qui occupe une
place en mémoire pour stocker une adresse, tandis que pour tableau, on
ne stocke que les éléments :
+----------+
| p +---+
+----------+ |
.... | la valeur dans p est l'adresse de p[0]
+----------+ |
| p[0] + <-+
+----------+
| p[1] +
+----------+
| p[2] +
+----------+
| +
+----------+
--------------
C'est à dire que le compilo se comporte différement selon si x est un
tableau ou un pointeur, dans une expression du type a[3] ou p[3].
Cependant, un peu plus loin, on peut lire :
--------------
An lvalue of type array-of-T which appears in an expression decays
(with three exceptions) into a pointer to its first element; the type
of the resultant pointer is pointer-to-T.
(The exceptions are when the array is the operand of a sizeof or &
operator, or is a string literal initializer for a character array.)
--------------
Cela implique que, si a est un tableau, dans une expression du type
a[3], a est automatiquement converti en pointeur sur l'adresse du
premier élément de a.
(Si j'ai bien compris)
N'y a-t-il pas contradiction?
Non. Il dit juste que a prend le type pointeur-vers-T dans certain cas,
mais a ne devient pas une variable qui occupe de la mémoire pour autant.
D'ailleurs il indique l'exception pour l'opérateur & sur un tableau :
&a == a == &a[0]
qui montre bien que a n'occupe pas de place en mémoire en soi.
PS : je m'arrache les cheveux en criant comme un ours, ce qui fait
peur à ma voisine de bureau. Elle n'en dort plus la nuit, ce qui lui
impose de prendre de l'ecstasy tous les matins pour garder le rythme,
et ça c'est pas bon pour sa santé. Ce post est donc une question de
vie ou de mort.
Dans la faq en anglais de Steve Summit, on peut lire :
-------------- It is important to realize that a reference like x [3] generates different code depending on whether x is an array or a pointer. Given the declarations above, when the compiler sees the expression a[3], it emits code to start at the location ``a,'' move three past it, and fetch the character there. When it sees the expression p[3], it emits code to start at the location ``p,'' fetch the pointer value there, add three to the pointer, and finally fetch the character pointed to.
Ce qu'il veut dire c'est qu'un pointeur est une variable qui occupe une place en mémoire pour stocker une adresse, tandis que pour tableau, on ne stocke que les éléments :
+----------+ | p +---+ +----------+ | .... | la valeur dans p est l'adresse de p[0] +----------+ | | p[0] + <-+ +----------+ | p[1] + +----------+ | p[2] + +----------+ | + +----------+
-------------- C'est à dire que le compilo se comporte différement selon si x est un tableau ou un pointeur, dans une expression du type a[3] ou p[3].
Cependant, un peu plus loin, on peut lire :
-------------- An lvalue of type array-of-T which appears in an expression decays (with three exceptions) into a pointer to its first element; the type of the resultant pointer is pointer-to-T.
(The exceptions are when the array is the operand of a sizeof or & operator, or is a string literal initializer for a character array.) -------------- Cela implique que, si a est un tableau, dans une expression du type a[3], a est automatiquement converti en pointeur sur l'adresse du premier élément de a. (Si j'ai bien compris)
N'y a-t-il pas contradiction?
Non. Il dit juste que a prend le type pointeur-vers-T dans certain cas, mais a ne devient pas une variable qui occupe de la mémoire pour autant. D'ailleurs il indique l'exception pour l'opérateur & sur un tableau : &a == a == &a[0] qui montre bien que a n'occupe pas de place en mémoire en soi.
PS : je m'arrache les cheveux en criant comme un ours, ce qui fait peur à ma voisine de bureau. Elle n'en dort plus la nuit, ce qui lui impose de prendre de l'ecstasy tous les matins pour garder le rythme, et ça c'est pas bon pour sa santé. Ce post est donc une question de vie ou de mort.
oulala... c'est à ce point...
-- Richard
Emmanuel Delahaye
D'ailleurs il indique l'exception pour l'opérateur & sur un tableau : &a == a == &a[0]
L'égalité en valeur est vraie, mais pas en type. Le type de '&a' n'est pas le même que celui de '&a[0]' qui lui, a le même type que 'a'. Suis-je bien clair ? Je me le demande...
-- Emmanuel
"C is a sharp tool"
D'ailleurs il indique l'exception pour l'opérateur & sur un tableau :
&a == a == &a[0]
L'égalité en valeur est vraie, mais pas en type. Le type de '&a' n'est
pas le même que celui de '&a[0]' qui lui, a le même type que 'a'.
Suis-je bien clair ? Je me le demande...
D'ailleurs il indique l'exception pour l'opérateur & sur un tableau : &a == a == &a[0]
L'égalité en valeur est vraie, mais pas en type. Le type de '&a' n'est pas le même que celui de '&a[0]' qui lui, a le même type que 'a'. Suis-je bien clair ? Je me le demande...
-- Emmanuel
"C is a sharp tool"
Horst Kraemer
On 22 Jul 2004 02:42:47 -0700, (yoxoman) wrote:
... sur les tableaux et les pointeurs.
Dans la faq en anglais de Steve Summit, on peut lire :
-------------- It is important to realize that a reference like x [3] generates different code depending on whether x is an array or a pointer. Given the declarations above, when the compiler sees the expression a[3], it emits code to start at the location ``a,'' move three past it, and fetch the character there. When it sees the expression p[3], it emits code to start at the location ``p,'' fetch the pointer value there, add three to the pointer, and finally fetch the character pointed to. -------------- C'est à dire que le compilo se comporte différement selon si x est un tableau ou un pointeur, dans une expression du type a[3] ou p[3].
Cependant, un peu plus loin, on peut lire :
-------------- An lvalue of type array-of-T which appears in an expression decays (with three exceptions) into a pointer to its first element; the type of the resultant pointer is pointer-to-T.
(The exceptions are when the array is the operand of a sizeof or & operator, or is a string literal initializer for a character array.) -------------- Cela implique que, si a est un tableau, dans une expression du type a[3], a est automatiquement converti en pointeur sur l'adresse du premier élément de a. (Si j'ai bien compris)
N'y a-t-il pas contradiction?
Bonne observation ;-) En principe oui, mais il faut faire une différence entre la définition formelle des éléments du langage et des actions d'un compilateur réel. Le compilateur n'est pas obligé de suivre pas par pas les définitions formelles du langage. Il doit fournir un *résultat* qui est identique au résultat qu'il aurait produit s'il avait suivi littéralement les définitions. C'est la fameuse "règle du comme si" (as-if rule).
-- Horst
On 22 Jul 2004 02:42:47 -0700, yoxoman@aol.com (yoxoman) wrote:
... sur les tableaux et les pointeurs.
Dans la faq en anglais de Steve Summit, on peut lire :
--------------
It is important to realize that a reference like x [3] generates
different code depending on whether x is an array or a pointer. Given
the declarations above, when the compiler sees the expression a[3], it
emits code to start at the location ``a,'' move three past it, and
fetch the character there. When it sees the expression p[3], it emits
code to start at the location ``p,'' fetch the pointer value there,
add three to the pointer, and finally fetch the character pointed to.
--------------
C'est à dire que le compilo se comporte différement selon si x est un
tableau ou un pointeur, dans une expression du type a[3] ou p[3].
Cependant, un peu plus loin, on peut lire :
--------------
An lvalue of type array-of-T which appears in an expression decays
(with three exceptions) into a pointer to its first element; the type
of the resultant pointer is pointer-to-T.
(The exceptions are when the array is the operand of a sizeof or &
operator, or is a string literal initializer for a character array.)
--------------
Cela implique que, si a est un tableau, dans une expression du type
a[3], a est automatiquement converti en pointeur sur l'adresse du
premier élément de a.
(Si j'ai bien compris)
N'y a-t-il pas contradiction?
Bonne observation ;-) En principe oui, mais il faut faire une
différence entre la définition formelle des éléments du langage et des
actions d'un compilateur réel. Le compilateur n'est pas obligé de
suivre pas par pas les définitions formelles du langage. Il doit
fournir un *résultat* qui est identique au résultat qu'il aurait
produit s'il avait suivi littéralement les définitions. C'est la
fameuse "règle du comme si" (as-if rule).
Dans la faq en anglais de Steve Summit, on peut lire :
-------------- It is important to realize that a reference like x [3] generates different code depending on whether x is an array or a pointer. Given the declarations above, when the compiler sees the expression a[3], it emits code to start at the location ``a,'' move three past it, and fetch the character there. When it sees the expression p[3], it emits code to start at the location ``p,'' fetch the pointer value there, add three to the pointer, and finally fetch the character pointed to. -------------- C'est à dire que le compilo se comporte différement selon si x est un tableau ou un pointeur, dans une expression du type a[3] ou p[3].
Cependant, un peu plus loin, on peut lire :
-------------- An lvalue of type array-of-T which appears in an expression decays (with three exceptions) into a pointer to its first element; the type of the resultant pointer is pointer-to-T.
(The exceptions are when the array is the operand of a sizeof or & operator, or is a string literal initializer for a character array.) -------------- Cela implique que, si a est un tableau, dans une expression du type a[3], a est automatiquement converti en pointeur sur l'adresse du premier élément de a. (Si j'ai bien compris)
N'y a-t-il pas contradiction?
Bonne observation ;-) En principe oui, mais il faut faire une différence entre la définition formelle des éléments du langage et des actions d'un compilateur réel. Le compilateur n'est pas obligé de suivre pas par pas les définitions formelles du langage. Il doit fournir un *résultat* qui est identique au résultat qu'il aurait produit s'il avait suivi littéralement les définitions. C'est la fameuse "règle du comme si" (as-if rule).
-- Horst
Yves ROMAN
... sur les tableaux et les pointeurs.
Dans la faq en anglais de Steve Summit, on peut lire :
-------------- It is important to realize that a reference like x [3] generates different code depending on whether x is an array or a pointer. Given the declarations above, when the compiler sees the expression a[3], it emits code to start at the location ``a,'' move three past it, and fetch the character there. When it sees the expression p[3], it emits code to start at the location ``p,'' fetch the pointer value there, add three to the pointer, and finally fetch the character pointed to. -------------- C'est à dire que le compilo se comporte différement selon si x est un tableau ou un pointeur, dans une expression du type a[3] ou p[3].
Mais ca semble plutot concerner des variables de type tableau et pointeur, puisqu'il va l'adresse contenue a l'adresse de 'p'
Cependant, un peu plus loin, on peut lire :
-------------- An lvalue of type array-of-T which appears in an expression decays (with three exceptions) into a pointer to its first element; the type of the resultant pointer is pointer-to-T.
(The exceptions are when the array is the operand of a sizeof or & operator, or is a string literal initializer for a character array.) -------------- Cela implique que, si a est un tableau, dans une expression du type a[3], a est automatiquement converti en pointeur sur l'adresse du premier élément de a. (Si j'ai bien compris)
Mais pas une variable pointeur : une valeur de type pointeur contenant l'adresse du premier element du tableau. La premiere etape du premier paragraphe dans le cas du pointeur ne peut s'appliquer, et on a directement l'adresse contenue dans le 'pointeur' sans aller le lire (Je sais pas si quelqu'un a compris ce que je voulais dire, mais bon...)
N'y a-t-il pas contradiction?
PS : je m'arrache les cheveux en criant comme un ours, ce qui fait peur à ma voisine de bureau. Elle n'en dort plus la nuit, ce qui lui impose de prendre de l'ecstasy tous les matins pour garder le rythme, et ça c'est pas bon pour sa santé. Ce post est donc une question de vie ou de mort.
... sur les tableaux et les pointeurs.
Dans la faq en anglais de Steve Summit, on peut lire :
--------------
It is important to realize that a reference like x [3] generates
different code depending on whether x is an array or a pointer. Given
the declarations above, when the compiler sees the expression a[3], it
emits code to start at the location ``a,'' move three past it, and
fetch the character there. When it sees the expression p[3], it emits
code to start at the location ``p,'' fetch the pointer value there,
add three to the pointer, and finally fetch the character pointed to.
--------------
C'est à dire que le compilo se comporte différement selon si x est un
tableau ou un pointeur, dans une expression du type a[3] ou p[3].
Mais ca semble plutot concerner des variables de type tableau et pointeur,
puisqu'il va l'adresse contenue a l'adresse de 'p'
Cependant, un peu plus loin, on peut lire :
--------------
An lvalue of type array-of-T which appears in an expression decays
(with three exceptions) into a pointer to its first element; the type
of the resultant pointer is pointer-to-T.
(The exceptions are when the array is the operand of a sizeof or &
operator, or is a string literal initializer for a character array.)
--------------
Cela implique que, si a est un tableau, dans une expression du type
a[3], a est automatiquement converti en pointeur sur l'adresse du
premier élément de a.
(Si j'ai bien compris)
Mais pas une variable pointeur : une valeur de type pointeur contenant l'adresse
du premier element du tableau. La premiere etape du premier paragraphe dans le
cas du pointeur ne peut s'appliquer, et on a directement l'adresse contenue dans
le 'pointeur'
sans aller le lire
(Je sais pas si quelqu'un a compris ce que je voulais dire, mais bon...)
N'y a-t-il pas contradiction?
PS : je m'arrache les cheveux en criant comme un ours, ce qui fait
peur à ma voisine de bureau. Elle n'en dort plus la nuit, ce qui lui
impose de prendre de l'ecstasy tous les matins pour garder le rythme,
et ça c'est pas bon pour sa santé. Ce post est donc une question de
vie ou de mort.
Dans la faq en anglais de Steve Summit, on peut lire :
-------------- It is important to realize that a reference like x [3] generates different code depending on whether x is an array or a pointer. Given the declarations above, when the compiler sees the expression a[3], it emits code to start at the location ``a,'' move three past it, and fetch the character there. When it sees the expression p[3], it emits code to start at the location ``p,'' fetch the pointer value there, add three to the pointer, and finally fetch the character pointed to. -------------- C'est à dire que le compilo se comporte différement selon si x est un tableau ou un pointeur, dans une expression du type a[3] ou p[3].
Mais ca semble plutot concerner des variables de type tableau et pointeur, puisqu'il va l'adresse contenue a l'adresse de 'p'
Cependant, un peu plus loin, on peut lire :
-------------- An lvalue of type array-of-T which appears in an expression decays (with three exceptions) into a pointer to its first element; the type of the resultant pointer is pointer-to-T.
(The exceptions are when the array is the operand of a sizeof or & operator, or is a string literal initializer for a character array.) -------------- Cela implique que, si a est un tableau, dans une expression du type a[3], a est automatiquement converti en pointeur sur l'adresse du premier élément de a. (Si j'ai bien compris)
Mais pas une variable pointeur : une valeur de type pointeur contenant l'adresse du premier element du tableau. La premiere etape du premier paragraphe dans le cas du pointeur ne peut s'appliquer, et on a directement l'adresse contenue dans le 'pointeur' sans aller le lire (Je sais pas si quelqu'un a compris ce que je voulais dire, mais bon...)
N'y a-t-il pas contradiction?
PS : je m'arrache les cheveux en criant comme un ours, ce qui fait peur à ma voisine de bureau. Elle n'en dort plus la nuit, ce qui lui impose de prendre de l'ecstasy tous les matins pour garder le rythme, et ça c'est pas bon pour sa santé. Ce post est donc une question de vie ou de mort.
Jean-Noël Mégoz
"Emmanuel Delahaye" a écrit dans le message de news:
D'ailleurs il indique l'exception pour l'opérateur & sur un tableau : &a == a == &a[0]
L'égalité en valeur est vraie, mais pas en type. Le type de '&a' n'est pas le même que celui de '&a[0]' qui lui, a le même type que 'a'. Suis-je bien clair ? Je me le demande...
Si, si.
"Emmanuel Delahaye" <emdel@YOURBRAnoos.fr> a écrit dans le message de
news:mn.b3157d47911e1806.15512@YOURBRAnoos.fr...
D'ailleurs il indique l'exception pour l'opérateur & sur un tableau :
&a == a == &a[0]
L'égalité en valeur est vraie, mais pas en type. Le type de '&a' n'est
pas le même que celui de '&a[0]' qui lui, a le même type que 'a'.
Suis-je bien clair ? Je me le demande...
"Emmanuel Delahaye" a écrit dans le message de news:
D'ailleurs il indique l'exception pour l'opérateur & sur un tableau : &a == a == &a[0]
L'égalité en valeur est vraie, mais pas en type. Le type de '&a' n'est pas le même que celui de '&a[0]' qui lui, a le même type que 'a'. Suis-je bien clair ? Je me le demande...
Si, si.
guignot
yoxoman wrote:
Elle n'en dort plus la nuit, ce qui lui impose
Personnellement, j'aurais une solution plus simple et naturelle à proposer, mais tu vas dire que j'ai l'esprit mal tourné.
yoxoman wrote:
Elle n'en dort plus la nuit, ce qui lui
impose
Personnellement, j'aurais une solution plus simple et naturelle à proposer,
mais tu vas dire que j'ai l'esprit mal tourné.
"guignot" a écrit dans le message de news:cdp33h$sth$
yoxoman wrote:
Elle n'en dort plus la nuit, ce qui lui impose
Personnellement, j'aurais une solution plus simple et naturelle à proposer,
mais tu vas dire que j'ai l'esprit mal tourné.
Dormir le jour ?
yoxoman
Yves ROMAN wrote in message news:...
Cela implique que, si a est un tableau, dans une expression du type a[3], a est automatiquement converti en pointeur sur l'adresse du premier élément de a. (Si j'ai bien compris)
Mais pas une variable pointeur : une valeur de type pointeur contenant l'adresse du premier element du tableau.
Hummm. Je crois qu'il y a quelque chose que je devrais comprendre, ici. Cependant, je ne saisis pas tout : une valeur qui contient une adresse? Qu'est-ce qu'une valeur? Je présume (peut-être à tort) que c'est ce que contient une variable, mais dans ce cas, comment une valeur peut-elle contenir quelque chose?
Désolé pour mon inculture, mais je ne trouve pas de référence là dessus.
La premiere etape du premier paragraphe dans le cas du pointeur ne peut s'appliquer, et on a directement l'adresse contenue dans le 'pointeur' sans aller le lire (Je sais pas si quelqu'un a compris ce que je voulais dire, mais bon...)
*argh*
Yves ROMAN <yves.roman@NO.unilog.SPAM.fr> wrote in message news:<40FFF127.E4D87B43@NO.unilog.SPAM.fr>...
Cela implique que, si a est un tableau, dans une expression du type
a[3], a est automatiquement converti en pointeur sur l'adresse du
premier élément de a.
(Si j'ai bien compris)
Mais pas une variable pointeur : une valeur de type pointeur contenant l'adresse
du premier element du tableau.
Hummm. Je crois qu'il y a quelque chose que je devrais comprendre,
ici. Cependant, je ne saisis pas tout : une valeur qui contient une
adresse?
Qu'est-ce qu'une valeur? Je présume (peut-être à tort) que c'est ce
que contient une variable, mais dans ce cas, comment une valeur
peut-elle contenir quelque chose?
Désolé pour mon inculture, mais je ne trouve pas de référence là
dessus.
La premiere etape du premier paragraphe dans le
cas du pointeur ne peut s'appliquer, et on a directement l'adresse contenue dans
le 'pointeur'
sans aller le lire
(Je sais pas si quelqu'un a compris ce que je voulais dire, mais bon...)
Cela implique que, si a est un tableau, dans une expression du type a[3], a est automatiquement converti en pointeur sur l'adresse du premier élément de a. (Si j'ai bien compris)
Mais pas une variable pointeur : une valeur de type pointeur contenant l'adresse du premier element du tableau.
Hummm. Je crois qu'il y a quelque chose que je devrais comprendre, ici. Cependant, je ne saisis pas tout : une valeur qui contient une adresse? Qu'est-ce qu'une valeur? Je présume (peut-être à tort) que c'est ce que contient une variable, mais dans ce cas, comment une valeur peut-elle contenir quelque chose?
Désolé pour mon inculture, mais je ne trouve pas de référence là dessus.
La premiere etape du premier paragraphe dans le cas du pointeur ne peut s'appliquer, et on a directement l'adresse contenue dans le 'pointeur' sans aller le lire (Je sais pas si quelqu'un a compris ce que je voulais dire, mais bon...)
*argh*
Emmanuel Delahaye
Mais pas une variable pointeur : une valeur de type pointeur contenant l'adresse du premier element du tableau.
Hummm. Je crois qu'il y a quelque chose que je devrais comprendre, ici. Cependant, je ne saisis pas tout : une valeur qui contient une adresse?
Mauvaise formulation.
"Une valeur représentant une adresse."
Qu'est-ce qu'une valeur? Je présume (peut-être à tort) que c'est ce que contient une variable,
C'est ça, ou une expression constante.
-- Emmanuel The C-FAQ: http://www.eskimo.com/~scs/C-faq/faq.html
"C is a sharp tool"
Mais pas une variable pointeur : une valeur de type pointeur contenant
l'adresse du premier element du tableau.
Hummm. Je crois qu'il y a quelque chose que je devrais comprendre,
ici. Cependant, je ne saisis pas tout : une valeur qui contient une
adresse?
Mauvaise formulation.
"Une valeur représentant une adresse."
Qu'est-ce qu'une valeur? Je présume (peut-être à tort) que c'est ce
que contient une variable,
C'est ça, ou une expression constante.
--
Emmanuel
The C-FAQ: http://www.eskimo.com/~scs/C-faq/faq.html
