Default Initialization of reference variables in methods

Quote:

---

To keep a program readable, it is often best to avoid functions that modify their arguments.

---

Quote:

---

Well...basically that is the reason why I pass pointers while functions modify their arguments and const-references otherwise...

---

Just avoiding functions that modify their arguments is NOT enough to keep a program readable. You have to stay away from using references as function parameters at all, const or not.

References are one of the biggest obstacle in code readability. They are implemented like pointers but they look like objects.
Especially when you pass it in to a function call. Is it pass the object by copying, or is it passed by reference? You never know.

Also keep in mind references do NOT guarantee it actually point to a valid object. It may force you to always initialize when declare reference, but you could initialize it with the wrong thing or even a null pointer.

Quote:

---

Originally posted by AnthonyMai
...
Also keep in mind references do NOT guarantee it actually point to a valid object. It may force you to always initialize when declare reference, but you could initialize it with the wrong thing or even a null pointer.

---

And the same isn't possible with pointers?

Quote:

---

Just avoiding functions that modify their arguments is NOT enough to keep a program readable. You have to stay away from using references as function parameters at all, const or not.

---

Bull.

Quote:

---

Is it pass the object by copying, or is it passed by reference? You never know.

---

Of course you know. You look at the fuction declaration. The need to know wether something is passed by value or by const reference is only of interest to optimization.

Quote:

---

Also keep in mind references do NOT guarantee it actually point to a valid object. It may force you to always initialize when declare reference, but you could initialize it with the wrong thing or even a null pointer.

---

This is true for anything passed in, and would require the client to do something invalid. Wether a reference or not, it's not possible for a method to test for these kinds of things. You can safely assume that a passed reference is valid.

There's absolutely nothing wrong with using const references. For non-const references, some people prefer pointers for clarity.

Jeff

With pointer you can at least easily check to see if the pointer is null, and people commonly do the check. With references it is not easily to do such check, and people NEVER do the check.

Interesting...

How would you pass a NULL reference with C++ code ?

Quote:

---

Just avoiding functions that modify their arguments is NOT enough to keep a program readable. You have to stay away from using references as function parameters at all, const or not.

---

For passing structs or classes it definitely beats passing as value. I would like to know how you would write an "=" operator for a class then... Hum or is operator overloading also an inherently bad idea ?

Quote:

---

With pointer you can at least easily check to see if the pointer is null, and people commonly do the check. With references it is not easily to do such check, and people NEVER do the check.

---

To do this, the client would need to dereference a NULL pointer, which results in undefined behavior according to the standard. If the program blows up as a result, it's no fault of the reference parameter.

Jeff

Quote:

---

Is it pass the object by copying, or is it passed by reference? You never know.

---

Quote:

---

Of course you know. You look at the fuction declaration. The need to know wether something is passed by value or by const reference is only of interest to optimization.

---

Really? Whether something ia passed by value or by reference only matters with optimization? I hope it doesn't take too long for you to realize why that statement is completely wrong.

How is readability when once in every three line you have to open op a different source file to figure out whether the function call is passed by value or passed by reference?

Quote:

---

Originally posted by AnthonyMai
With pointer you can at least easily check to see if the pointer is null, and people commonly do the check. With references it is not easily to do such check, and people NEVER do the check.

---

See jfaust's reply.

In addition, if you are going to be misusing references, what's so hard about checking for NULL:

Code:

---

void fn(int &n)
{
  if (&n == NULL)
      return;

  ...
}

---

Quote:

---

Really? Whether something ia passed by value or by reference only matters with optimization? I hope it doesn't take too long for you to realize why that statement is completely wrong.

---

Well, I said by "const reference" and not by "reference", both having very different meanings. I guess I should have said if the item is copy constructable and constructing it has no strange side-effects. Assuming those things, which is a pretty safe assumption, it's an optimization issue.

Jeff

Quote:

---

I would like to know how you would write an "=" operator for a class then... Hum or is operator overloading also an inherently bad idea ?

---

Operator overloading some times is a VERY BAD idea. It hides something that you should be aware of, which could surprise you if you are not careful.

Look at this simple code line code:

Code:

---

    c = a + b;

---

Simple enough? You would assume a and b would not change. And c becomes what a + b is, depends on what eaxtly a + b is, when the object is none-POD.

WRONG!!!!!!!!

The following code changes BOTH c AND a, although seemingly a and b should not be changed in "c = a + b".

Code:

---

#include <stdio.h>

class A
{
public:
    int m_val;
    A(int val = 0):m_val(val){};
    ~A() {}

    A& operator = (const A& v2) {m_val = v2.m_val; return *this;}
    A& operator + (const A& v2) {m_val += v2.m_val; return *this;}

    operator int () {return m_val;}
};

int main(int argc, char* argv[])
{
    A  a(1),b(2),c(3);

    printf("Before: a = %d b = %d c = %d\r\n", a, b, c);

    c = a + b;

    printf("After: a = %d b = %d c = %d\r\n", a, b, c);

    return 0;
}

---

The output is
Before: a = 1 b = 2 c = 3
After: a = 3 b = 2 c = 3

Quote:

---

I guess I should have said if the item is copy constructable and constructing it has no strange side-effects. Assuming those things, which is a pretty safe assumption, it's an optimization issue.

---

You do should have said that. And NO those things are NOT a pretty safe assumptions. Calling a construction DO have side effects which are often inportant and can not be ignored.

Quote:

---

The following code changes BOTH c AND a, although seemingly a and b should not be changed in "c = a + b".

---

This is simply because of a badly written operator+. operator+ should return a const value, as in "const A operator+(const A& v2) const", and should not modify the class. The return value should be const to prevent strangeness like "a+b=c".

Quote:

---

Calling a construction DO have side effects which are often inportant and can not be ignored.

---

Wrong. They CAN have side-effects, but most often don't. I don't consider memory allocation a side-effect. If you are dealing with such a class that has side-effects, you must be careful in everything that you do, including passing those things as parameters. But usually these considerations can be safely ignored.

Jeff

Quote:

---

This is simply because of a badly written operator+. operator+ should return a const value, as in "const A operator+(const A& v2) const", and should not modify the class. The return value should be const to prevent strangeness like "a+b=c".

---

Totally wrong. Just added "const" to my sample code and the test result is the same.

Please try again to give a valid explaination.

Quote:

---

Originally posted by AnthonyMai

Code:

---

#include <stdio.h>

class A
{
public:
    // ...
    A& operator + (const A& v2) {m_val += v2.m_val; return *this;}
    // ...
};

---

---

I'm just going to add to what jfaust said and ask WHY you are
assigning to m_val in your operator+(). That's not what
operator+() does. What you wrote was what operator=+()
for your class would have been.

I choose to make operator+ a non-member function for reasons
such as this. Heck, Stroustrup advises this, too, in Section
11.3.1 of The C++ Programming Language.

Edit: formatting

--Paul

Quote:

---

Originally posted by AnthonyMai


Totally wrong. Just added "const" to my sample code and the test result is the same.

Please try again to give a valid explaination.

---

Try something like this:

Code:

---

#include <stdio.h>

class A
{
public:
    int m_val;
    A(int val = 0):m_val(val){};
    ~A() {}

    A& operator = (const A& v2) {m_val = v2.m_val; return *this;}

    operator int () {return m_val;}
};

A operator+(const A& lhs, const A& rhs)
{
  return A(lhs.m_val + rhs.m_val);
}

int main(int argc, char* argv[])
{
    A  a(1),b(2),c(3);

    printf("Before: a = %d b = %d c = %d\r\n", a, b, c);

    c = a + b;

    printf("After: a = %d b = %d c = %d\r\n", a, b, c);

    return 0;
}

---

--Paul