Re: ISO standards
{ Please limit your posting to 70 columns or so preferably,
or less than 80 columns absolutely, to prevent jagged text. -mod }
"LR" <lruss@superlink.net> wrote in message
news:47af8672$0$32500$cc2e38e6@news.uslec.net...
Jeffrey Baker wrote:
I think you are referring to the pointer, ptr having its own address
which
is
in simile with array.
I'm not quite sure what you mean by the above, but ptr has its own
address because it's a variable, whereas array is not. That is,
ptr = array; // ok
array = ptr; // not ok
I am a bit clearer about arrays and pointers. Haven't read as far as I
would
like. Maybe after this writing... To answer your question the examples
shows
that
array[0] points to the first element [0] and the value of ptr is the
address of
where the data is. Both array[0] and ptr show the same address that hold
the same data. The difference is that 'array' always points to the first
element since
the address of the array is constant, like the pointer is but isn't the
first element.
It only likes to point keeping its static compiled place. This is what
separates arrays and pointers
A pointer will point to other elements and the array will stay pointing to
the first
element. The pointer will point to different address. The array is
contiguous because it is static at compile time.
Pointers are dynamic in nature. Because the array and pointer can both
express the same data there
a simile. I never said it is useful! It is a trivial point. A pointer
references the array not the opposite.
Here is a counter:
#include <iostream>
using namespace std;
int main()
{
int array[] = {1,2,3,4,5,6,7,8,9,0};
int *ptr = array;
cout << "The value of ptr = " << ptr << endl; // address of the
where
the value is stored.
cout << "The address of ptr = " << &ptr << endl;
cout << "The 'value' of array = " << array << endl;
cout << "The address of array = " << &array << endl;
cout << "The address of array[0] = " << &array[0] << endl;
cout << "++ptr; " << endl;
++ptr;
cout << "The address of ptr = " << &ptr << endl; // address is the
same as
above.
cout << "The value of the ptr = " << ptr << endl;
cout << "The address of array[1] = " << &array[1] << endl;
return 0;
}
The address of &ptr is the same after ++ptr increments; like 'int array'
that points to the first element stays the same.
array can't be incremented either.
array++; // not ok
That is why it isn't a array is an array and not a pointer.
Maybe try this snippet and see if array and ptr are the same or different:
std::cout << sizeof(array) << std::endl;
std::cout << sizeof(array[0]) << std::endl;
std::cout << sizeof(ptr) << std::endl;
std::cout << sizeof(ptr[0]) << std::endl;
The sizof(array) is giving the total of all integers while the element [0]
is
showing only the size of the type integer. The pointer at its own address
and
where it points to is equivalent to its type which is integer.
The value of the ptr matches the addess of the array[1].
It shows the address of where the data is and is incremented once: ++ptr.
The address of ptr is still at its static place when compiled.
These are both the address in which the value of array[1] is located.
Yes, as ptr, not as &ptr.
The array is a collection of addresses that are pointed to.
I'm not quite sure that that means. When I think of collection of
addresses, I think of something like:
int a,b,c;
std::set<int*> s;
s.insert(&a);
s.insert(&b);
s.insert(&c);
The array is a contiguous set of address of type int. It is static at
compile time.
Pointer addresses are dynamic and can be contiguous or not. It isn't
specified at
compile time. Only the pointer and type is static at compile time. The
example might
yield contiguous data - a,b,c. Except if a is given a set of values. a = 1;
a = 2; a = 3....a = n.
I think of arrays as being a contiguous section of memory containing
objects. But that's not very formal.
The array is a higher form of the language.
In what sense of higher?
The difference of machine language to basic language.
C & C++ to a lesser extent, are medium level languages.
Suppose I write,
int *ptr = array;
1[ptr] = 6;
ptr[2] = 7;
Is that higher level?
What is 1[ptr] = 6? 1 is an integer.
ptr[2] = 7 ok unless ptr is - int const ptr;
They are both used differently.
They sure are. It would be very unlikely that you could do this
usefully with ptr instead of array,
for(unsigned int i=0; i<sizeof(array)/sizeof(array[0]); i++) {
std::cout << array[i] << std::endl;
}
The pointer can use sizeof(....) / (...)
They are paradoxes in the language. Not a conflict.
I'm not clear on what the paradox you refer to is.
They are both true to the same without being the same.
Best regards,
Jeff
--
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]