Re: Some syntax question

From:

"Raj" <Rajan.Munuswamy@gmail.com>

Newsgroups:

microsoft.public.vc.language

Date:

19 Feb 2007 03:55:39 -0800

Message-ID:

<1171886139.206850.42290@v33g2000cwv.googlegroups.com>

On Feb 19, 11:43 am, "Jacky" <j...@knight.com> wrote:

Do these 3 functions do the same thing?
void increment (int &aa) { aa++; }
int next(int p) { return p+1; }
void incr(int *p) { *(p)++; }

void g()
{
    int x = 1;
    increment(x); // x = 2
    x = next(x); // x = 3
    incr(&x); // x = 4}

What situations should I choose which type of statements?
Any pros and cons for each?
Thanks

"Jacky" <j...@knight.com> =BC=B6=BCg=A9=F3=B6l=A5=F3=B7s=BBD:%23vcy%231%2=

3UHHA....@TK2MSFTNGP06.phx.gbl...

"Jacky" <j...@knight.com> =BC=B6=BCg=A9=F3=B6l=A5=F3=B7s=BBD:Os8Gwy%23U=

HHA....@TK2MSFTNGP03.phx.gbl...

Adding some quoto too
"C++ Programming Language pg84"
"We can allocate and use "variables" that do not have names, and it is
possible to assign to
strange-looking expressions (e.g. *p[a+10] = 7). Consequently, there=

is a

need for a name
for "something in memory". This is the simplest and most fundamental
notion for an
object. The word lvalue was originally coined to mean "something that =

can

be on
the left-hand side of an assignment". However, not every lvalue may be
used on the
left-hand side of an assignment; an lvalue can refer to a constant. An
lvalue that has not been
declared const is often called a modifiable lvalue. This simple and
low-level notion
of an object should not be confused with the notions of class object a=

object
of polymorphic type...."
I was confused about this.
Thanks

Sorry for misaligned texts.
Jack

"Jacky" <j...@knight.com> =BC=B6=BCg=A9=F3=B6l=A5=F3=B7s=BBD:ujt5wj%23=

UHHA.4...@TK2MSFTNGP03.phx.gbl...

"Heinz Ozwirk" <SPAMhozw...@arcor.de> =BC=B6=BCg=A9=F3=B6l=A5=F3=B7s=

=BBD:45d84589$0$15952$9b4e6...@newsspool4.arcor-online.net...

"Jacky" <j...@knight.com> schrieb im Newsbeitrag
news:Oj0Cu$0UHHA.1000@TK2MSFTNGP05.phx.gbl...

I quoted
"Initialization of a reference is trivial when the initializer is an
lvalue (an object whose
address you can take. The initializer for a "plain" T& must be an
lvalue of type T"
What exactly is the lvalue?

Basically, an l-value is something that can be used at the left side=

an assignment statement. For an exact definition, you have to consult
the C++ standard. Also, it is not enough that a reference must be
initialized with an l-value. It must also be an l-value with a match=

ing

type.

int i;
int& ri = i; // fine, i is an l-value of type int, ri is a
reference

Why would you call this an l-value? i is on the RHS of the assignment
statement...
:(

to an int
double& rd = i; // error, i is not a double

Some ASCIIart may help :)
double &dr = 1; // error

You cannot assign a value to the number 1, so you cannot initialize a
plain reference with it.

const double& cdr = 1; //ok

This one is fine. Not because 1 suddenly is an l-value, but because =

cdr

is not a plain reference. It is a const reference (a reference to a
constant object). The compiler is supposed to create a temporary
object, initialize it with 1 and bind the reference to that temporar=

However, only const references can be bound to temporary objects.

HTH
Heinz- Hide quoted text -

- Show quoted text -

1. When u pass a parameter as Pass By Value, copy of the variable
would be created in the function body. If you pass array of int then
think how big your stack would have grown...so it is to use pass by
pointer or pass by reference than pass by value.

2. Reference is implicit pointer. So, either u could opt for pass by
pointer or pass by reference which are mostrly the same size in the
stack and no copy is created.

-Rajan