Thread: Your ("Pass-By-Ref") Opinion Please

Hi. I read something interesting in Bjarne Stroustroup's book. He discourages using functions that modify call-by-reference arguments. He claims that they make programs hard to read.

I was surprised by this. I didn't learn this, and always learned that to modify a variable one had to use reference arguments. Passing-by-value provided one with a copy (I assume this involves the Copy Constructor), which does not persist.

Later Mr. Stroustroup declares, "Be suspicious of non-const reference arguments; if you want the function to modify its arguments, use pointers and value return instead."

I would like to hear some opinions about this. Namely, do you feel that these make programs hard to read, and are they best avoided? Also, how would one "use pointers and value return instead," to accomplish this objective?

Thanks for the feedback. Steve

Search the board, it has been discussed numerious times.

Well java doesn't allow passing by reference, so I guess the C++ creator and Sun saw something wrong with passing by reference. I created an example in C to show yall that I believe passing by reference is OK only if the functions are privately used by the specific program, but if the function is used a lot, I believe it's best for compatability to pass by value. Also, I find myself trapped with a memory leak when passing by value using a pointer (I move the pointer away from malloc'ed material):

Code:

#include <stdio.h>
#include <stdlib.h>

// Change the string in reference
void changeString1 (char **s);

// Change the string through value & return
char *changeString2 (const char *s);

int main (void)
{
  // Create a string you want to change in a function
  char *s = malloc (255 * sizeof (*s));

  // Change string by reference
  changeString1 (&s);
  puts (s);

  // Change string by value
  strcpy (s, changeString2 (s));
  puts (s);

  return 0;
}

// Change the string in reference
void changeString1 (char **s)        // The string that we use to find what we return
{
  // Change the string
  strcpy ((*s), "Birds sing");
}

// Change the string through value & return
char *changeString2 (const char *s)   // The string that we use to find what we return
{
  // Create a string to return
  char *sc = malloc (255 * sizeof (*sc));

  // Use the input value to discover what to set the return string as
  if (!strcmp (s, "Birds sing"))
    strcpy (sc, "Yes that's correct");
  else
    strcpy (sc, "Birds sing");
  return sc;
}

C does not have pass by reference. It only has pass by value.

Well, as a beginner-to-intermediate student, I was surprised to read this. I guess because I am moving into an intermediate level in my studies, I am coming across this. It doesn't seem to me (of course, I could be assuming) that beginner-level courses and books state this. I just completed a second-level C++ course in a science-oriented college. The professor wanted us to use Stroustroup's book. I tried to use it as a reference, but was overwhelmed! Later, a friend of mine who is a brilliant Applied Mathematician, recommended that I "read the book a few times, you'll know C++ pretty well by then." I don't know C. I did a search for "pass by reference" and came up with a lot! Alas, I didn't feel that my specific question was answered though. OK, thanks again. Steve

OK, here's my attempt at "using pointers and value return:"

Code:

#include<iostream>

using namespace std;

int f(int* i)
{
    *i=(*i)+=40;
    return *i;
}

int main()
{
  int j=90;
  int* i = &j;
  cout<<f(i)<<endl;
  cout<<*i<<endl;
  
  cin.get();
  return 0;
}

~Steve

Originally Posted by Thantos

C does not have pass by reference. It only has pass by value.

Originally Posted by Sake

>Well java doesn't allow passing by reference
Sure it does. Any class object in Java is passed by reference.

omg this is the 500th time I've lied today.

>> Later Mr. Stroustroup declares, "Be suspicious of non-const reference arguments; if you want the function to modify its arguments, use pointers and value return instead." <<

I agree with Stroustroup. It makes code harder to read. Reading C++ code, it is not unusual to be surprised that a variable has been altered and then have to search up the code to find the culprit function.

Code:

doSomething(myInt); /* Can this function alter myInt? */
doSomething(&myInt); /* I know this function can alter myInt. */

C# handles this by requiring that the caller must use the ref keyword for pass by reference arguments:

Code:

doSomething(ref myInt);

Originally Posted by Sake

>Well java doesn't allow passing by reference
Sure it does. Any class object in Java is passed by reference.

Actually it doesn't. In java you work on object pointers and pass them around by value.

In almost every situation this will work out exactly the same but there are some situations where the results are different.

(damn, should learn to read threads till the very end before posting)