why reference ?

[William Xuuu]

Hi,

References introduced make things much more complicated. e.g.

int a;
void f(int &n);
void g(int *p);

Isn't g(&a) much more clear than f(a), when we would change the value of
the lvalue a ?

Are there any efficiency differences ?

Is reference a must in c++ ?

thanks.

--
William Xuuu

[Karl Heinz Buchegger]

William Xuuu wrote:

Hi,

References introduced make things much more complicated. e.g.

int a;
void f(int &n);
void g(int *p);

Isn't g(&a) much more clear than f(a), when we would change the value of
the lvalue a ?
Clearity is in the eye of the beholder :-)
Seriously. It depends. In your above example it definitly is
not clear to the caller if

f(a)

will change 'a' or not.

But in practice this is much less an issue then you think. Mostly
because in real life functions are not called 'f' and arguments are
not called 'a'. In

j = CalcFibonacci( InputNumber );

will the function CalcFibonacci alter the passed argument? While
there is no 100% guarantee, bets are good, that it won't.

Same for eg. the prototype

void Deposit( Account& TheAccount, long Amount );

Now guess: Will The Account be changed when the function is called.
If you read the callers code:

Account CustomerAccount;
long Amount;

CustomerAccount = AskForCustomer();
Amount = AskForAmount();

Deposit( CustomerAccount, Amount );

When you read that code, and have no idea that the first argument
to Deposit is passed by reference, would you expect CustomerAccount
to change? Sure I would! If I deposit something on an account, then
the amount associated with that account changes.

Are there any efficiency differences ?
When you pass a pointer, it is the functions responsibility to at
least check that the passed pointer is not 0. On the other hand,
if you pass per reference AND the function gets inlined, you open
a lot of possibilities for the compiler for optimizations.

Is reference a must in c++ ?

Yes. Otherwise writing custom operators would not be possible.
Granted, we could live without that feature (although it is a
nice one) and then AFAIK there would be no killer argument for
not dropping references.

--
Karl Heinz Buchegger
kb******@gascad.at

[Tim Love]

William Xuuu <wi**********@163.com> writes:

Hi, References introduced make things much more complicated. See
http://www.parashift.com/c++-faq-lite/references.html
Is reference a must in c++ ?

In some situations, yes I think so.

[Thomas Barth]

>

Are there any efficiency differences ?

Is reference a must in c++ ?

Reference variables can be created for local use as aliases
for other variables within a function. Reference variables must
be initialized in their declarations, and they cannot be reassigned
as aliases to other variables. Once a reference variable is
declared as an alias for another variable, all operations performed
on the alias actually are performed on the variable.
As a former java-coder I can say that pointers are needless :-)

Thomas B.

[Tilman Kuepper]

Hi William,

Isn't g(&a) much more clear than f(a), when we would change
the value of the lvalue a ?

Are there any efficiency differences ?

If a function has to change a variable via a pointer, the function
has to check for null-pointers first. For example...

void Change(int* pVal)
{
if(pVal)
*pVal = 123;
else
throw SomeException;
}

Okay, but perhaps you are writing a function where it is
not allowed to pass null-pointers as parameters. In this
case you have to add some documentation to your function
where this pre-condition is described. You should still
use assert() before accessing the pointer, though...

With references all this is not necessary. If you declare
a function like...

void Change(int& val);

....then it is simply not possible to call this function with a
null-pointer.

Tilman

[John Harrison]

"William Xuuu" <wi**********@163.com> wrote in message
news:87************@163.com...

Hi,

References introduced make things much more complicated. e.g.

int a;
void f(int &n);
void g(int *p);

Isn't g(&a) much more clear than f(a), when we would change the value of
the lvalue a ?

Are there any efficiency differences ?

Is reference a must in c++ ?

Try writing an assignment operator using a pointer.

class X
{
X& operator=(const X* rhs);
};

Then you would then have to write

X x, y;
x = &y;

Do you think that is good style?

References and pointers are different. The main difference is that a
reference once initialised cannot be made to refer to something else. This
is often exactly what you want, and makes using references very common, it
also makes the syntax simpler.

john

[Gernot Frisch]

As a former java-coder I can say that pointers are needless :-)

double GetFirstNegative(double* pNums)
{
while(*pNums>0.0) ++pNums;
return *pNums;
}

Try that with references and compare the assembly generated.

[Arijit]

Gernot Frisch wrote:

double GetFirstNegative(double* pNums)
{
while(*pNums>0.0) ++pNums;
return *pNums;
}

Try that with references and compare the assembly generated.

How about:

double GetFirstNegative(double* pNums)
{
int i=0;
while(pNums[i]>0.0)
++i;
return pNums[i];
}

No pointers, no references. Agreed, has an extra variable.

It is very rare in C++ that a pointer is truly needed. Almost all the
time you can get around using references or [].
--
X-Privat Project - http://www.newsserver.it/

[Thomas Barth]

Hi

double GetFirstNegative(double* pNums)
{
int i=0;
while(pNums[i]>0.0)
++i;
return pNums[i];
}

Pointer free, array passed by reference

double getFirstNegative(double arr[]) {
Thomas B.

[Jon Bell]

In article <87************@163.com>,
William Xuuu <wi**********@163.com> wrote:

References introduced make things much more complicated. e.g.

That depends on your point of view. :-)

I came to C++ from Fortran and Pascal, which use reference semantics
(although not the same syntax as C++ of course) for passing data to
functions. I find references to be natural to use, whereas pointers are
cumbersome and error-prone.

--
Jon Bell <jt*******@presby.edu> Presbyterian College
Dept. of Physics and Computer Science Clinton, South Carolina USA

[Thomas Barth]

And you should always consider the size of an array

double getFirstNegative(double arr[], int &iSize) {
double dValue = 0.0;
for (int i = 0; i < iSize && dValue == 0.0; i++) {
if(arr[i] < 0.0) dValue = arr[i];
}
return dValue;
}

I am not a friend of code compression :-) Your code versions
would throw an OutOfBound-exception

Thomas B.

[Julián Albo]

William Xuuu wrote:

int a;
void f(int &n);
void g(int *p);

Isn't g(&a) much more clear than f(a), when we would change the value of
the lvalue a ?

Yes, but if you name the function evaluate_something instead of f things
will be much more clear.

--
Salu2

[Andrew Koenig]

"Julián Albo" <JU********@terra.es> wrote in message
news:2v*************@uni-berlin.de...

William Xuuu wrote:

int a;
void f(int &n);
void g(int *p);

Isn't g(&a) much more clear than f(a), when we would change the value of
the lvalue a ?

Yes, but if you name the function evaluate_something instead of f things
will be much more clear.

For example:

std::cin >> a;

Isn't this clearer than having to write

std::cin >> &a;

?

[Lionel B]

John Harrison wrote:

References and pointers are different. The main difference is that a
reference once initialised cannot be made to refer to something else.

....and perhaps equally important (as several posters have pointed out),
a reference *must* be initialised.

And hence may be assumed to refer to something sensible... oops, maybe
not:

int* p = new int(5);
int& i = *p;
delete p;

I note that the following program:

<CODE>

#include <iostream>

int main()
{
int* p = new int(5);
int& i = *p;
std::cout << "i = " << i << '\n';
delete p;
p = new int(6);
std::cout << "i = " << i << '\n';
delete p;
return 0;
}

</CODE>

outputs:

i = 5;
i = 6;

on my system - but I suspect that this is actually UB and it is
fortuitous that the second new allocated the same address as the
first...

--
Lionel B

[Arijit]

Thomas Barth wrote:

And you should always consider the size of an array

double getFirstNegative(double arr[], int &iSize) {
double dValue = 0.0;
for (int i = 0; i < iSize && dValue == 0.0; i++) {
if(arr[i] < 0.0) dValue = arr[i];
}
return dValue;
}

I am not a friend of code compression :-) Your code versions
would throw an OutOfBound-exception

Thomas B.

I was replying to Gernot's post. I made as minimal changes as possible
to the program to get to it work without pointers.

Actually, my code will not throw any exception, the whole thing will
just crash. On Linux, probably the famous "Segmentation fault. Core dumped."

-Arijit

[Thomas Barth]

Actually, my code will not throw any exception, the whole thing will just crash. On Linux, probably the famous "Segmentation
fault. Core dumped."

It's embarrassing that a coder presents code that "just crashs". Do you know
exception handling? Remember, the topic of this thread-child is that pointers
are needless. You showed us a crashy solution with a pointer.
Shake your head and wake up!

Thomas B.

[Arijit]

Thomas Barth wrote:

Actually, my code will not throw any exception, the whole thing will just crash. On Linux, probably the famous "Segmentation
fault. Core dumped."

It's embarrassing that a coder presents code that "just crashs". Do you know
exception handling? Remember, the topic of this thread-child is that pointers
are needless. You showed us a crashy solution with a pointer.
Shake your head and wake up!

Thomas B.

I know exception handling. The point is that no exceptions will be
thrown in this case. And I showed a solution without explicit pointers.
No out-of-bound exception will be generated, even when you access
elements outside the array bounds.

And you miss the whole point of my reply. The message I replied to had
this ->
double GetFirstNegative(double* pNums)
{
while(*pNums>0.0) ++pNums;
return *pNums;
}

Try that with references and compare the assembly generated.
Which I changed to ->
double GetFirstNegative(double* pNums)
{
int i=0;
while(pNums[i]>0.0)
++i;
return pNums[i];
}

No pointers, no references. Agreed, has an extra variable.

I probably should have written double GetFirstNegative(double pNum[]),
but thats besides the point. What I tried to do was the change the code
already posted to work without pointers, while keeping the structure of
the original code unaltered. Thats why I did not use range checking,
because the original code didn't have it. And the way the code is
written, range checking is unnecessary if you use sentinels.
-Arijit

[Thomas Barth]

>

I probably should have written double GetFirstNegative(double pNum[]), but thats besides the point. What I tried to do was the
change the code already posted to work without pointers, while keeping the structure of the original code unaltered. Thats why I
did not use range checking,

Who said to keep the structure of the code? :-) Of course you have
to change the programming style as well, if you want to pass on pointers.
That's the deal with it.

Have a nice evening :)

Thomas B.

[Markus Elfring]

> Are there any efficiency differences ?

Do you check the pointer in g() for a non-zero value?
This safety check can be avoided and omitted by the passing of the
arguments by reference.

[Old Wolf]

"Thomas Barth" <th******@mail.isis.de> wrote:
Arijit wrote:

double GetFirstNegative(double* pNums)
{
int i=0;
while(pNums[i]>0.0)
++i;
return pNums[i];
}

No pointers, no references. Agreed, has an extra variable.

This still uses a pointer. pNums is a pointer. The fact that
there is no '*' symbol in the code does not change this.
pNums[i] is the same as: *(pNums + i)
Pointer free, array passed by reference

double getFirstNegative(double arr[]) {

In this case, arr is a pointer. This is identical to the
original declaration.

To pass an array by reference you need to write:
double foo( double (&arr)[10] )

[E. Robert Tisdale]

William Xuuu wrote:

References introduced make things much more complicated. e.g.

int a;
void f(int &n);
void g(int *p);
Don't do that!

Pass by value, const reference or const pointer
and return by value:

int f(const int& n) {
return n + 1;
}

int g(const int* p) {
return *p + 1;
}
Isn't g(&a) much more clear than f(a),
When we would change the value of the lvalue a?

Are there any efficiency differences?

Is reference a must in C++?

[William Xuuu]

"John Harrison" <jo*************@hotmail.com> writes:

Try writing an assignment operator using a pointer.

class X
{
X& operator=(const X* rhs);
};

Then you would then have to write

X x, y;
x = &y;

Do you think that is good style?
Hmm, i see your point. But the assignment operator is different from a
general method, we don't generally call it as x.operator=(&y). Meanwhile in
my e.g., i'd say g(&a) is better than f(a), right? So, there are some
things in c++ that reference performs more elegant than pointer, not
all. That's all.
References and pointers are different. The main difference is that a
reference once initialised cannot be made to refer to something else. This
is often exactly what you want, and makes using references very common, it
also makes the syntax simpler.

One has to master two things now, compared with one before. I can't agree.

--
William Xuuu

[Cheng Mo]

Hi,
I am new to C++.
In Java, it is possible to define one class to be "final" so no other
class can inherit it.
I am wondering whether or not there is some mechanism in C++ do the same
job. Besides putting all constructors privte, any other solution?

[Victor Bazarov]

"Cheng Mo" <mo******@com.motorola> wrote...

I am new to C++.
In Java, it is possible to define one class to be "final" so no other
class can inherit it.
I am wondering whether or not there is some mechanism in C++ do the same
job. Besides putting all constructors privte, any other solution?

http://www.research.att.com/~bs/bs_f...#no-derivation

[John Harrison]

>

References and pointers are different. The main difference is that a
reference once initialised cannot be made to refer to something else.
This
is often exactly what you want, and makes using references very common,
it
also makes the syntax simpler.

One has to master two things now, compared with one before. I can't agree.

Fair enough, you're free not to use the parts of C++ that don't appeal to
you. You can just use them for parameters to overloaded operators and copy
constructors (where they are essential).

It took me along while to get used to references but now I use them all the
time.

john

[Ulf Wikstr?m]

William Xuuu <wi**********@163.com> wrote in message news:<87************@163.com>...

Hi,

References introduced make things much more complicated. e.g.

int a;
void f(int &n);
void g(int *p);

Isn't g(&a) much more clear than f(a), when we would change the value of
the lvalue a ?

Are there any efficiency differences ?

Is reference a must in c++ ?

thanks.

The reason that Stroustup introduced references into C++ was actually
operator overloading.
For example, in the assignment operator, the return type must be a
reference.

[Branimir Maksimovic]

Cheng Mo <mo******@com.motorola> wrote in message news:<cn**********@avnika.corp.mot.com>...

Hi,
I am new to C++.
In Java, it is possible to define one class to be "final" so no other
class can inherit it.
I am wondering whether or not there is some mechanism in C++ do the same
job. Besides putting all constructors privte, any other solution?

// put this in header file:
// header_file.h
// -----------------------------
#ifndef HEADER_FILE_H
#define HEADER_FILE_H
class BaseOfFinalClass{
public:
// ...some interface functions eg
virtual void function1()=0;
virtual ~BaseOfFinalClass(){}
};

BaseOfFinalClass* makeFinalClass();
#endif
// ------------------------------

// put your final class in implementation file:

// implementation_file.cpp
// ------------------------
#include "header_file.h"
class FinalClass: public BaseOfFinalClass{
public:
// ... implementation functions
virtual void function1(){ /* ... */ }
};

BaseOfFinalClass* makeFinalClass()
{
return new FinalClass;
}
// ------------------------

Greetings, Bane.

[Arijit]

Old Wolf wrote:

"Thomas Barth" <th******@mail.isis.de> wrote:
Arijit wrote:

double GetFirstNegative(double* pNums)
{
int i=0;
while(pNums[i]>0.0)
++i;
return pNums[i];
}

No pointers, no references. Agreed, has an extra variable.

This still uses a pointer. pNums is a pointer. The fact that
there is no '*' symbol in the code does not change this.
pNums[i] is the same as: *(pNums + i)
I meant no explicit pointers are used. I indeed tried to write the
program without * . I consider using [] to dereference a pointer not
using pointers. You can never eliminate implicit pointers. For example,
references are usually implemented as pointers.
Pointer free, array passed by reference

double getFirstNegative(double arr[]) {

This was not written by me.
In this case, arr is a pointer. This is identical to the
original declaration.

To pass an array by reference you need to write:
double foo( double (&arr)[10] )

Yes. But will there be any difference in usage of arr in the two cases ?

-Arijit

[Default User]

Cheng Mo wrote:

Hi,
I am new to C++.

I think you are new to newsgroups as well, as you posted your
completely irrelevant message in reply to someone else. Learn how to
use Thunderbird to start new threads rather than piggy-back on existing
ones.

Brian