A question about pointer

[Bo Yang]

As long as I write c++ code, I am worry about the
pointer. The more the system is, the dangerous the pointer
is I think.
I must pass pointers erverywhere, and is there a way to
ensure that every object pointered by any pointer will
be deleted and only be deleted once?

[Salt_Peter]

Default User wrote:

Th*******@gmail .com wrote:

Howard wrote:

"Salt_Peter " <pj*****@yahoo. comwrote in message
news:11******** **************@ 80g2000cwy.goog legroups.com...

>

Your goal is to write an entire program without using a pointer
directly. Not even one.
Note that references do just fine if polymorphism is required.
Its easier than you think. Since no naked pointers means no bugs
and no aspirins.
>
Hmm... no pointers means no bugs, eh? Interesting...
>
int main()
{
int a[1];
a[1] = 1;
}
>
No bugs? :-)

Aren't arrays really just pointers anyway?

No.
Brian

Oh yes, they most definitely are, through and through. Case in point:
the code above.
And the undefined behaviour that follows.

#include <iostream>
#include <ostream>

int main()
{
int array[1];
std::cout << "array = " << array << std::endl;
int* p = array;
std::cout << "p = " << p << std::endl;

array[1] = 1;
std::cout << "array + 1 = " << array + 1 << std::endl;
std::cout << "array[1] = " << array[1] << std::endl;
std::cout << "p + 1 is " << p + 1 << std::endl;
std::cout << "*(p + 1) = " << *(p + 1) << std::endl;

array[100] = 1;
std::cout << "array + 100 = " << array + 100 << std::endl;
std::cout << "p + 100 = " << p + 100 << std::endl;
std::cout << "array[100] = " << array[100] << std::endl;
std::cout << "*(p + 100) = " << *(p + 100) << std::endl;
}

/*
array = 0x7fff92835240
p = 0x7fff92835240
p + 1 is 0x7fff92835244
array + 1 = 0x7fff92835244
array[1] = 1
*(p + 1) = 1
array + 100 = 0x7fff928353d0
p + 100 = 0x7fff928353d0
array[100] = 1
*(p + 100) = 1
*/

And the compiler doesn't even blink.

[Salt_Peter]

Andre Kostur wrote:

"Salt_Peter " <pj*****@yahoo. comwrote in
news:11******** **************@ 73g2000cwn.goog legroups.com:

Howard wrote:

"Salt_Peter " <pj*****@yahoo. comwrote in message
news:11******** **************@ 80g2000cwy.goog legroups.com...



Your goal is to write an entire program without using a pointer
directly. Not even one.
Note that references do just fine if polymorphism is required.
Its easier than you think. Since no naked pointers means no bugs
and no aspirins.

Hmm... no pointers means no bugs, eh? Interesting...

int main()
{
int a[1];
a[1] = 1;
}

No bugs? :-)

-Howard

Thanks for the perfect example: in the above - a - decays to a
pointer. Try:

std::vector< int v(1);
v.at(1) = 1; // std::range_erro r thrown

How about v[1]?

sorry, also a pointer: usually implemented with:

reference operator[](size_type n)
{
return *(begin() + n);
}

[Thatchman]

Thanks for the perfect example: in the above - a - decays to a
pointer. Try:

std::vector< int v(1);
v.at(1) = 1; // std::range_erro r thrown

How about v[1]?

I don't believe the [] operator does bounds checking in vectors, while
the at() function does.

[Andre Kostur]

>Hmm... no pointers means no bugs, eh? Interesting...

>>
int main()
{
int a[1];
a[1] = 1;
}

No bugs? :-)

-Howard

Thanks for the perfect example: in the above - a - decays to a
pointer. Try:

std::vector< int v(1);
v.at(1) = 1; // std::range_erro r thrown

How about v[1]?

sorry, also a pointer: usually implemented with:

reference operator[](size_type n)
{
return *(begin() + n);
}

That's stuff controlled by the implementor of the runtime, not the user.
If you want to continue that argument, at is probably implemented as:

reference at(size_type n)
{
if (n < capacity)
return *(begin() + n);

throw std::out_of_ran ge();
}
If you want to continue that argument to it's conclusion, it's impossible
to write a (non-trivial) C++ program without pointers. Everything (class
instances) has a this pointer. std::list<has pointers internally. So
does std::map<and std::auto_ptr<> . Every one of your string literals
decays to a pointer.

[Howard]

"Salt_Peter " <pj*****@yahoo. comwrote in message
news:11******** **************@ 73g2000cwn.goog legroups.com...

>
Howard wrote:

>"Salt_Peter " <pj*****@yahoo. comwrote in message
news:11******* *************** @80g2000cwy.goo glegroups.com.. .

>

>
Your goal is to write an entire program without using a pointer
directly. Not even one.
Note that references do just fine if polymorphism is required.
Its easier than you think. Since no naked pointers means no bugs and no
aspirins.

Hmm... no pointers means no bugs, eh? Interesting...

int main()
{
int a[1];
a[1] = 1;
}

No bugs? :-)

-Howard

Thanks for the perfect example: in the above - a - decays to a pointer.
Try:

std::vector< int v(1);
v.at(1) = 1; // std::range_erro r thrown

no naked pointers means no bugs and no aspirins

Whether or not an implementation (or even ALL implementations ) implement an
array as a pointer, is irrelevant. Your statement was regarding "naked"
pointers. Are you now saying "no pointers of any kind, and no arrays, and
nothing which may be implemented as a pointer, means no bugs and no
aspirins"? Or perhaps "no code means no bugs and no aspirins"? :-)

-Howard

[Default User]

Salt_Peter wrote:

>
Default User wrote:

Th*******@gmail .com wrote:

>
Howard wrote:
"Salt_Peter " <pj*****@yahoo. comwrote in message
news:11******** **************@ 80g2000cwy.goog legroups.com...
>

>
Your goal is to write an entire program without using a
pointer directly. Not even one.
Note that references do just fine if polymorphism is required.
Its easier than you think. Since no naked pointers means no
bugs and no aspirins.

Hmm... no pointers means no bugs, eh? Interesting...

int main()
{
int a[1];
a[1] = 1;
}

No bugs? :-)

Aren't arrays really just pointers anyway?

No.

Oh yes, they most definitely are, through and through. Case in point:
the code above.

Nope. In some cases, array names are converted to pointers to the first
element. However, arrays are not pointers.

Look into the sizeof and & operators.


Brian

[Salt_Peter]

Andre Kostur wrote:

Hmm... no pointers means no bugs, eh? Interesting...

int main()
{
int a[1];
a[1] = 1;
}

No bugs? :-)

-Howard

Thanks for the perfect example: in the above - a - decays to a
pointer. Try:

std::vector< int v(1);
v.at(1) = 1; // std::range_erro r thrown

How about v[1]?

sorry, also a pointer: usually implemented with:

reference operator[](size_type n)
{
return *(begin() + n);
}

That's stuff controlled by the implementor of the runtime, not the user.
If you want to continue that argument, at is probably implemented as:

reference at(size_type n)
{
if (n < capacity)
return *(begin() + n);

throw std::out_of_ran ge();
}
If you want to continue that argument to it's conclusion, it's impossible
to write a (non-trivial) C++ program without pointers. Everything (class
instances) has a this pointer. std::list<has pointers internally. So
does std::map<and std::auto_ptr<> . Every one of your string literals
decays to a pointer.

Everything is eventually a pointer or using one somewhere. Thats a
given.
Pointers are far from being useless, programs wouldn't function without
them.
In fact, pointers are quick/fast - assuming they are used correctly.

Take the OP's quest as a matter in point. Can you see his dilemna?
I can, and their are solutions - thats my point.

I'll bet that if we were to dissect his code he's got plain mutable
pointers all over the place instead of constant pointers to immutable
variables. I'll bet he's using naked pointers where he should implement
constant references. I'm also willing to bet that he can replace all or
most allocations with smart_pointers and/or load elements into STL
templated containers.

The issue is not wheter we have the choice to use them or not. We
don't.
The choice we do have, is how we use them.

[Salt_Peter]

Howard wrote:

"Salt_Peter " <pj*****@yahoo. comwrote in message
news:11******** **************@ 73g2000cwn.goog legroups.com...

Howard wrote:

"Salt_Peter " <pj*****@yahoo. comwrote in message
news:11******** **************@ 80g2000cwy.goog legroups.com...



Your goal is to write an entire program without using a pointer
directly. Not even one.
Note that references do just fine if polymorphism is required.
Its easier than you think. Since no naked pointers means no bugs and no
aspirins.

Hmm... no pointers means no bugs, eh? Interesting...

int main()
{
int a[1];
a[1] = 1;
}

No bugs? :-)

-Howard

Thanks for the perfect example: in the above - a - decays to a pointer.
Try:

std::vector< int v(1);
v.at(1) = 1; // std::range_erro r thrown

no naked pointers means no bugs and no aspirins

Whether or not an implementation (or even ALL implementations ) implement an
array as a pointer, is irrelevant. Your statement was regarding "naked"
pointers. Are you now saying "no pointers of any kind, and no arrays, and
nothing which may be implemented as a pointer, means no bugs and no
aspirins"? Or perhaps "no code means no bugs and no aspirins"? :-)

-Howard

Let me answer your question this way, after all, you brought arrays
into the topic for some reason.

If a client asked me to implement a safe solution that must absolutely
use arrays, i'ld probably wrap a primitive array in a class and
implement range-checking through some exception mechanism. I'm certain
you'ld do the same. Why? Cause its a relatively simple solution which
will/should provide the safety requirement.

In other words, to answer the OP's question, there are alternatives
other than having to manage a bunch of pointers directly. Those
alternatives, for the most part, will not complicate the code. In many
cases, they will simplify it. Example: boost::shared_p tr<or
std::deque, etc.

That doesn't mean don't use pointers. Thats impossible. That doesn't
mean you can't use them safely.

Instead of the all-too common:
void foo(int* p_n) {... }
....use...
void foo(int const * const p_n) { ... }
....or in the case *p_n needs to be mutable...
void foo(int* const p_n) { ... }
.... and even better ...
void foo(const int& r_n) { ... }
void foo(int& r_n) { ... }

And we can go on and on.

[Saurabh Nirkhey]

Apart from all the solutions suggested above, You can use Smart
Pointers, you can make your own class of pointers with constructors
and destructors and prevent memory leaks.

Iterators too are a good alternative .
While designing classes you can associate iterators with them.

Iterators are much safer way of referrencing and dereferrencing things
in a c++ program.
You can use the following link to read about iterators.

http://cppreference.com/iterators.html

I suggest you to search google for "smart pointers" and " iterators" .
Hope this helps.

Saurabh :-)

[Howard]

"Salt_Peter " <pj*****@yahoo. comwrote in message
news:11******** **************@ j72g2000cwa.goo glegroups.com.. .

>
Howard wrote:

>"Salt_Peter " <pj*****@yahoo. comwrote in message
news:11******* *************** @73g2000cwn.goo glegroups.com.. .

>
Howard wrote:
"Salt_Peter " <pj*****@yahoo. comwrote in message
news:11******* *************** @80g2000cwy.goo glegroups.com.. .

Your goal is to write an entire program without using a pointer
directly. Not even one.
Note that references do just fine if polymorphism is required.
Its easier than you think. Since no naked pointers means no bugs and
no
aspirins.

Hmm... no pointers means no bugs, eh? Interesting...

int main()
{
int a[1];
a[1] = 1;
}

No bugs? :-)

-Howard

Thanks for the perfect example: in the above - a - decays to a pointer.
Try:

std::vector< int v(1);
v.at(1) = 1; // std::range_erro r thrown

>no naked pointers means no bugs and no aspirins

Whether or not an implementation (or even ALL implementations ) implement
an
array as a pointer, is irrelevant. Your statement was regarding "naked"
pointers. Are you now saying "no pointers of any kind, and no arrays,
and
nothing which may be implemented as a pointer, means no bugs and no
aspirins"? Or perhaps "no code means no bugs and no aspirins"? :-)

-Howard

Let me answer your question this way, after all, you brought arrays
into the topic for some reason.

Geez... You said, and I quote again: "no naked pointers means no bugs and no
aspirins". So I presented a simple program with _no_ naked pointers, but an
obvious bug. I then followed that with a "smiley face", indicating I was
joking with you, pointing out the (to me) obvious humor inherent in such a
statement. If you don't get it by now, forget it.

-Howard