Re: const type qualifier after function name
On Sep 5, 5:31 pm, terminator <farid.mehr...@gmail.com> wrote:
On Sep 5, 2:38 pm, "Victor Bazarov" <v.Abaza...@comAcast.net> wrote:
terminator wrote:
On Sep 5, 10:51 am, James Kanze <james.ka...@gmail.com> wrote:
On Sep 5, 3:52 am, "Victor Bazarov" <v.Abaza...@comAcast.net> wrote:
minseo...@hanafos.com wrote:
'const' refers to the object for which it is called. Inside that
function 'this' pointer has the type 'T const * const' (as opposed
to the regular 'T * const').
Just a very technical (and not very important) nit: the this
pointer is an rvalue (of non-class type), so top level
cv-qualifiers are ignored: the type of this is T* or T const*,
and the reason you can't modify it it because it is an rvalue,
and not because of const-ness.
With all respect I should ask in what way it is an rvalue?
You cannot take its address, you cannot modify it, you cannot initialise
a reference with it.
That's true for rvalues with built-in types (including this,
which always has a pointer type), but the issue becomes more
complicated for user defined (class) types.
rvalues are not none-modifiable:
f().g();//g modifies
I can initialize const refs(rvalue ref in next generation of
compilers)with rvalues:
class A f();
const A& ar=f();
You can do that today.
probably the only thing I can`t do with an rvalue is taking its
address.
And what is the this pointer in g(), above, in your first
example, if not the address of an rvalue? If I overload
operator& to return this in a class type, even something like:
A* pa = &f() ;
becomes legal. The distinction for class types is very, very
tenuous.
So if we define an rvalue as an intrinsically none-addressible
object 'this' can be considered a const rvalue which
exceptionally,
The point of my initial posting is precisely that this is *not*
const, because top-level const doesn't apply to rvalues of
non-class type.
does not initialize any kind of reference.
You can use this to initialize a reference:
class DontDoThisEvenIfItIsLegal
{
public:
void f()
{
DontDoThisEvenIfItIsLegal* const& rp( this ) ;
} ;
} ;
is perfectly legal (albeit useless, and rather confusing).
Formally, it creates a temporary of type
DontDoThisEvenIfItIsLegal*, initializes it with this, and then
binds the reference to the temporary.
But that does not mean that 'this' is not 'const', because the
only source of none- modifiablity is constness.
Not really. The only source of non-modifiablity is what the
standard says isn't modifiable. In C, for example, string
literals are not const, but you still aren't allowed to modify
them.
Further more, do you mean that the following
does not compile?
class A{
void F(){
const A * const & c_to_cA_ptr_ref = this ;
};
};
Of course it does. You can use an rvalue to initialize a
reference to a const.
I try to fancy that 'this' is a compiler defined function but
it has inconsistent syntax and looks more like a C# read-only
property than anything else.
It's a keyword: an rvalue expression which has a specific type
and value in a given context. That's really all you can say
about it.
--
James Kanze (GABI Software) email:james.ka...@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