What can pointers do that other things can't do?

[Michael Bell]

I am trying to put my learning effort into the most useful things.
What do pointers do that other things can't?

Michael Bell

--

[Tomasz bla Fortuna]

Dnia Sun, 02 Dec 2007 14:07:10 GMT
Michael Bell <mi*****@beaver bell.co.uknapis a³(a):

I am trying to put my learning effort into the most useful things.
What do pointers do that other things can't?

Well, they can... point? I guess you should get some C-related book.
Without pointers in C you won't be even able to operate on text
(strings).

Have you read c-faq?

best regards,
--
Tomasz bla Fortuna
jid: bla(at)af.gliwi ce.pl
pgp: 0x90746E79 @ pgp.mit.edu
www: http://bla.thera.be

[=?UTF-8?B?RXJpayBXaWtzdHLDtm0=?=]

On 2007-12-02 15:07, Michael Bell wrote:

I am trying to put my learning effort into the most useful things.
What do pointers do that other things can't?

I suppose that with other things you mean references (anything else will
be too much like comparing apples to oranges, comparing pointers with
references is more like apples and pears: at least there are some
similarities). There are a number of differences:

Pointers can be null-pointers (pointing to nothing) whereas a reference
always (should) referees to something. You can always test if a pointer
is a null-pointer but you can not tell if a reference refers to a valid
object.

Pointers are "objects" in their own right and you can create a pointer
to a pointer (taking the address of a pointer) while you can never
create a pointer to a reference or a reference to a reference.

You can change what a pointer points to, you can never change what a
reference refers to.

You can perform arithmetic operations on a pointer, i.e. if p is a
pointer to the first element of an array then (p + 5) refers to the 6th
element of the same array.

From the programs point of view there is no difference between a
reference to an object and the object itself, you can treat the
reference (perform the same operations, use as arguments, etc.) in the
same way as the object. A pointer on the other hand is just an object
that points to some other object and operations performed on the pointer
does not affect the object it points to.

--
Erik Wikström

[Salt_Peter]

On Dec 2, 9:07 am, Michael Bell <mich...@beaver bell.co.ukwrote :

I am trying to put my learning effort into the most useful things.
What do pointers do that other things can't?

Michael Bell

--

A pointer is an address to nothing_at_all until it actually points to
something valid.

int* p;

p is a pointer with a residual value (garbage address). Nobody cares
what value p might hold now.
Since the statement does not invoke a (primitive) constructor, its an
invalid address to nothing.
The danger in the statement above is pretending that the pointer is
valid (a dangling pointer).

int n(99);
int* p = &n;

Ah, now a ctor was invoked. The pointer is now initialized with a
variable's address. There is no distinction between n or *p at this
point. Whats the difference you ask? Pointer p could be modified to
point to yet another object.

int m(77);
p = &m; // reseated pointer

Which brings us to the topic of references. You can't reseat a
reference. Its permanently bound to its target.
The syntax isn't the same at all.

int j;
int& ref = j; // ref is permanently bound
// ref = m; // error
ref = 55; // ok, j is now set to 55

___
All this to state:
a) Use a reference instead of a pointer whenever you can. Its the best
insecticide i know.
b) If you must use a pointer, always initialize it (if you can't give
it a valid address yet - then null it)

[Juha Nieminen]

Michael Bell wrote:

I am trying to put my learning effort into the most useful things.
What do pointers do that other things can't?

Well, for example creating a linked list (with all kinds of
operations, such as removing an element in constant time) would be quite
difficult without pointers. (Perhaps not impossible, but certainly more
awkward.)

[James Fang]

On Dec 2, 10:07 pm, Michael Bell <mich...@beaver bell.co.ukwrote :

I am trying to put my learning effort into the most useful things.
What do pointers do that other things can't?

Michael Bell

--

CPP Pointer can be used to do anything, as in the assembly level most
of data fetching opperations are done with "pointers".

The only thing constraints pointer's ability is the memory protection
mechanism provided by the processor, which is managed by the operating
system. You can only read/write the address area which is allowed by
the operating system.

[Michael Bell]

In message <47************ **********@news .tdc.fi>
Juha Nieminen <no****@thanks. invalidwrote:

Michael Bell wrote:

>I am trying to put my learning effort into the most useful things.
What do pointers do that other things can't?

Well, for example creating a linked list (with all kinds of
operations, such as removing an element in constant time) would be quite
difficult without pointers. (Perhaps not impossible, but certainly more
awkward.)

Thank you for this. It has told me something of value: that it is
worth my time and effort to learn about pointers.

Michael Bell
--

[Michael Bell]

In message <cd************ *************** *******@s8g2000 prg.googlegrou
ps.com>
Salt_Peter <pj*****@yahoo. comwrote:

On Dec 2, 9:07 am, Michael Bell <mich...@beaver bell.co.ukwrote :

>I am trying to put my learning effort into the most useful things.
What do pointers do that other things can't?

Michael Bell

--

A pointer is an address to nothing_at_all until it actually points to
something valid.

int* p;

p is a pointer with a residual value (garbage address). Nobody cares
what value p might hold now.
Since the statement does not invoke a (primitive) constructor, its an
invalid address to nothing.
The danger in the statement above is pretending that the pointer is
valid (a dangling pointer).

int n(99);
int* p = &n;

Ah, now a ctor was invoked. The pointer is now initialized with a
variable's address. There is no distinction between n or *p at this
point. Whats the difference you ask? Pointer p could be modified to
point to yet another object.

int m(77);
p = &m; // reseated pointer

Which brings us to the topic of references. You can't reseat a
reference. Its permanently bound to its target.
The syntax isn't the same at all.

int j;
int& ref = j; // ref is permanently bound
// ref = m; // error
ref = 55; // ok, j is now set to 55

___
All this to state:
a) Use a reference instead of a pointer whenever you can. Its the best
insecticide i know.
b) If you must use a pointer, always initialize it (if you can't give
it a valid address yet - then null it)

This is jargon I don't know. Does "reseat" mean to point a pointer at
some other address? That seems to the meaning of

int m(77);
p = &m; // reseated pointer

What exactly is going on here?

int j;

j has been declared. No problems about that!

int& ref = j; // ref is permanently bound

What has happened here?

// ref = m; // error
ref = 55; // ok, j is now set to 55

Sorry, I just don't understand.

Michael Bell

--

[Matthias Buelow]

Michael Bell wrote:

Thank you for this. It has told me something of value: that it is
worth my time and effort to learn about pointers.

If it's worth wasting people's time on Usenet, it's certainly worth
learning about yourself.

[Salt_Peter]

On Dec 3, 7:23 am, Michael Bell <mich...@beaver bell.co.ukwrote :

In message <cddd48b2-aa1e-4ced-b180-703c22738...@s8 g2000prg.google grou
ps.com>
Salt_Peter <pj_h...@yahoo. comwrote:

On Dec 2, 9:07 am, Michael Bell <mich...@beaver bell.co.ukwrote :

I am trying to put my learning effort into the most useful things.
What do pointers do that other things can't?

Michael Bell

--

A pointer is an address to nothing_at_all until it actually points to
something valid.
int* p;
p is a pointer with a residual value (garbage address). Nobody cares
what value p might hold now.
Since the statement does not invoke a (primitive) constructor, its an
invalid address to nothing.
The danger in the statement above is pretending that the pointer is
valid (a dangling pointer).
int n(99);
int* p = &n;
Ah, now a ctor was invoked. The pointer is now initialized with a
variable's address. There is no distinction between n or *p at this
point. Whats the difference you ask? Pointer p could be modified to
point to yet another object.
int m(77);
p = &m; // reseated pointer
Which brings us to the topic of references. You can't reseat a
reference. Its permanently bound to its target.
The syntax isn't the same at all.
int j;
int& ref = j; // ref is permanently bound
// ref = m; // error
ref = 55; // ok, j is now set to 55
___
All this to state:
a) Use a reference instead of a pointer whenever you can. Its the best
insecticide i know.
b) If you must use a pointer, always initialize it (if you can't give
it a valid address yet - then null it)

This is jargon I don't know. Does "reseat" mean to point a pointer at
some other address? That seems to the meaning of

reseat means to give it another address of course

>

int m(77);
p = &m; // reseated pointer

What exactly is going on here?

the Variable m is initialized to 77 and that variable exists somewhere
in memory (where exactly the programmer doesn't care). That location
is its address which is what p is storing for you.

>

int j;

j has been declared. No problems about that!int& ref = j; // ref is permanently bound

What has happened here?

Thats not how you will learn. You are asking the right question to the
wrong person. Look up references, study the pros and cons about
pointers. Code, code and then code again until you get it.

>

// ref = m; // error
ref = 55; // ok, j is now set to 55

Sorry, I just don't understand.

Consider changing that, get a relevent book. The faq can help too.

>
Michael Bell

--- Hide quoted text -

- Show quoted text -