Re: const type qualifier after function name
On Sep 5, 10:51 pm, James Kanze <james.ka...@gmail.com> wrote:
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.
yesterday I could do this to:
A& ar=f();
so,today we are much more limited.
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.
I meant intrinsic addressing, not using a member to extract the
address from inside scope to global.
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.
I know.But I assume it to be an auto defined member.
Intuitively, you can think of an lvalue as an expression that
designates an object in memory, and an rvalue as an expression
that just has a value, without an underlying object. Thus, to
assign *to* something, you need an lvalue---since you have to
modify the object, it must exist somewhere. But you can assign
from an rvalue; all you need is the value. (This is
historically where the names come from: an lvalue was something
that could appear to the left of an assignment, whereas an
rvalue could only appear to the right.
general speaking 'const' objects can not appear to the left side of
assignment(except for some odd classes that do define it on const
objects).should we consider every const an rvalue then?
But that is a radical
oversimplification in today's language.) Roughly speaking, if
the expression has an address, and would have one even if it
were of a primitive type, then it is an lvalue.
rvalues used to be either literals or function return values in C. But
you mean that since the declaration of C++ 'this' has formed a single-
membered categury of rvalues. That looks odd to me ,I can fancy 'this'
as a pointer-return member function that results in an rvalue but that
is not consistent with function call syntax in C++.
Finally, I should ask if there is any practical distinction between R
& L in C++ today?
regards,
FM.