Re: Never ever use a raw pointer when a smart pointer can do the same
job
On Aug 17, 6:09 pm, Noah Roberts <roberts.n...@gmail.com> wrote:
James Kanze wrote:
On Aug 15, 12:49 am, Ian Collins <ian-n...@hotmail.com> wrote:
James Kanze wrote:
Certainly, the application uses a lot of other pointers, but
not directly---I don't consider std::vector a smart pointer,
for example, or std::map.
True. But they do share one attribute with smart pointers:
they manage dynamic memory.
But that's irrelevant, since they don't provide the interface or
the services of a pointer.
Sure they do.
There must be some degree of misunderstanding here. The
interface of a pointer consists of a small number of operations:
unary *, ->, and the various addition and subtraction operations
(+, +=, ++, -, -=, and --), plus the [] operator, which is
mapped into + followed by *. The only one of these supported by
std::vector is []. Most smart pointers (intelligently) don't
support the addition and subtraction operators, but from what
I've always understood, the definition of a "smart pointer" is a
class which supports unary * and ->. Those seem to be the
operations which characterize a pointer in most people's minds.
When applied to a particular use of pointers: as addresses to
arrays, the std::vector object very much does provide this
service.
OK. I see what you mean. In cases where you'd write something
like:
T* array = new T[ n ] ;
// use array as an array, even though it is a pointer.
delete [] array ;
, you can (and should) replace the T* with std::vector< T >.
I've just never thought of this as "using a pointer"; in my
mind, it's not so much a case of std::vector emulating a
pointer, as one of pointers in C emulating an array. (I've
always considered this a major design flaw of C, but that's
neither here nor there.) To me, in this case, it doesn't feel
like I'm using a pointer, so I don't think of its replacement as
a smart pointer. (Of course, I've never actually written
anything like this in C++---one of the first classes I ever
wrote was ArrayOf. Back when I was working in C, such code,
using malloc/free instead of new/delete, was common, however.
But even then, I just didn't think of it as a pointer.)
Any function that accepts a pointer to T and then
treats that pointer as an array can be modified to accept a
std::vector simply by changing the parameter. However, it
does this "smartly" and there is much more information
available from the std::vector than there is from the pointer.
Agreed. I just think of this as an "array" with implicit
reference semantics, even in C.
There is no smart pointer that can or should provide ALL the
services a pointer can be used to provide.
Certainly not. One of the advantages of smart pointers is that
you can't use pointer arithmetic on them:-). And that smart
pointers and arrays are two different, more or less unrelated
things (with no implicit conversion of arrays to pointers, and
no possibility to use a pointer as an array).
In the end, it's a question of vocabulary. We both pretty much
agree that dynamically allocated arrays should usually be
replaced with std::vector. My impression is that in most
people's minds, "smart pointer" is associated with classes that
support unary* and -> (like std::vector<>::iterator), and not
with other classes. But it is admittedly a pretty arbitrary
definition. (Unless, like me, you think that the idea of
pointers supporting [] a dumb idea, so that anything which
emulates that can't be "smart".)
--
James Kanze (GABI Software) email:james.kanze@gmail.com
Conseils en informatique orient=E9e objet/
Beratung in objektorientierter Datenverarbeitung
9 place S=E9mard, 78210 St.-Cyr-l'=C9cole, France, +33 (0)1 30 23 00 34