一本介绍C指针的书--指针的类型及数组2.2
Earlier when discussing the term "lvalue" I cited K&R-2 where it stated:
"An object is a named region of storage; an lvalue is an expression
referring to an object".
This raises an interesting problem. Since my_array is a named region of storage, why is
my_array in the above assignment statement not an lvalue? To resolve this problem,
some refer to my_array as an "unmodifiable lvalue".
Modify the example program above by changing
ptr = &my_array[0];
to
ptr = my_array;
and run it again to verify the results are identical.
Now, let's delve a little further into the difference between the names ptr and my_array
as used above. Some writers will refer to an array's name as a constant pointer. What do
we mean by that? Well, to understand the term "constant" in this sense, let's go back to
our definition of the term "variable". When we declare a variable we set aside a spot in
memory to hold the value of the appropriate type. Once that is done the name of the
variable can be interpreted in one of two ways. When used on the left side of the
assignment operator, the compiler interprets it as the memory location to which to move
that value resulting from evaluation of the right side of the assignment operator. But,
when used on the right side of the assignment operator, the name of a variable is
interpreted to mean the contents stored at that memory address set aside to hold the value
of that variable.
With that in mind, let's now consider the simplest of constants, as in:
int i, k;
i = 2;
Here, while i is a variable and then occupies space in the data portion of memory, 2 is a
constant and, as such, instead of setting aside memory in the data segment, it is imbedded
directly in the code segment of memory. That is, while writing something like k = i; tells
the compiler to create code which at run time will look at memory location &i to
determine the value to be moved to k, code created by i = 2; simply puts the 2 in the code
and there is no referencing of the data segment. That is, both k and i are objects, but 2 is
not an object.
Similarly, in the above, since my_array is a constant, once the compiler establishes
where the array itself is to be stored, it "knows" the address of my_array[0] and on
seeing:
ptr = my_array;
it simply uses this address as a constant in the code segment and there is no referencing
of the data segment beyond that.
This might be a good place explain further the use of the (void *) expression used in
Program 1.1 of Chapter 1. As we have seen we can have pointers of various types. So far
we have discussed pointers to integers and pointers to characters. In coming chapters we
will be learning about pointers to structures and even pointer to pointers.
Also we have learned that on different systems the size of a pointer can vary. As it turns
out it is also possible that the size of a pointer can vary depending on the data type of the
object to which it points. Thus, as with integers where you can run into trouble
attempting to assign a long integer to a variable of type short integer, you can run into
trouble attempting to assign the values of pointers of various types to pointer variables of
other types.
To minimize this problem, C provides for a pointer of type void. We can declare such a
pointer by writing:
void *vptr;
A void pointer is sort of a generic pointer. For example, while C will not permit the
comparison of a pointer to type integer with a pointer to type character, for example,
either of these can be compared to a void pointer. Of course, as with other variables, casts
can be used to convert from one type of pointer to another under the proper
circumstances. In Program 1.1. of Chapter 1 I cast the pointers to integers into void
pointers to make them compatible with the %p conversion specification. In later chapters
other casts will be made for reasons defined therein.
Well, that's a lot of technical stuff to digest and I don't expect a beginner to understand all
of it on first reading. With time and experimentation you will want to come back and re-read the first 2 chapters. But for now, let's move on to the relationship between pointers,
character arrays, and strings.
"An object is a named region of storage; an lvalue is an expression
referring to an object".
This raises an interesting problem. Since my_array is a named region of storage, why is
my_array in the above assignment statement not an lvalue? To resolve this problem,
some refer to my_array as an "unmodifiable lvalue".
Modify the example program above by changing
ptr = &my_array[0];
to
ptr = my_array;
and run it again to verify the results are identical.
Now, let's delve a little further into the difference between the names ptr and my_array
as used above. Some writers will refer to an array's name as a constant pointer. What do
we mean by that? Well, to understand the term "constant" in this sense, let's go back to
our definition of the term "variable". When we declare a variable we set aside a spot in
memory to hold the value of the appropriate type. Once that is done the name of the
variable can be interpreted in one of two ways. When used on the left side of the
assignment operator, the compiler interprets it as the memory location to which to move
that value resulting from evaluation of the right side of the assignment operator. But,
when used on the right side of the assignment operator, the name of a variable is
interpreted to mean the contents stored at that memory address set aside to hold the value
of that variable.
With that in mind, let's now consider the simplest of constants, as in:
int i, k;
i = 2;
Here, while i is a variable and then occupies space in the data portion of memory, 2 is a
constant and, as such, instead of setting aside memory in the data segment, it is imbedded
directly in the code segment of memory. That is, while writing something like k = i; tells
the compiler to create code which at run time will look at memory location &i to
determine the value to be moved to k, code created by i = 2; simply puts the 2 in the code
and there is no referencing of the data segment. That is, both k and i are objects, but 2 is
not an object.
Similarly, in the above, since my_array is a constant, once the compiler establishes
where the array itself is to be stored, it "knows" the address of my_array[0] and on
seeing:
ptr = my_array;
it simply uses this address as a constant in the code segment and there is no referencing
of the data segment beyond that.
This might be a good place explain further the use of the (void *) expression used in
Program 1.1 of Chapter 1. As we have seen we can have pointers of various types. So far
we have discussed pointers to integers and pointers to characters. In coming chapters we
will be learning about pointers to structures and even pointer to pointers.
Also we have learned that on different systems the size of a pointer can vary. As it turns
out it is also possible that the size of a pointer can vary depending on the data type of the
object to which it points. Thus, as with integers where you can run into trouble
attempting to assign a long integer to a variable of type short integer, you can run into
trouble attempting to assign the values of pointers of various types to pointer variables of
other types.
To minimize this problem, C provides for a pointer of type void. We can declare such a
pointer by writing:
void *vptr;
A void pointer is sort of a generic pointer. For example, while C will not permit the
comparison of a pointer to type integer with a pointer to type character, for example,
either of these can be compared to a void pointer. Of course, as with other variables, casts
can be used to convert from one type of pointer to another under the proper
circumstances. In Program 1.1. of Chapter 1 I cast the pointers to integers into void
pointers to make them compatible with the %p conversion specification. In later chapters
other casts will be made for reasons defined therein.
Well, that's a lot of technical stuff to digest and I don't expect a beginner to understand all
of it on first reading. With time and experimentation you will want to come back and re-read the first 2 chapters. But for now, let's move on to the relationship between pointers,
character arrays, and strings.