functions - pass by reference - pass by pointer - increment++ issue

I decided to learn a little more about passing values to functions via a pretty thorough C++ tutorial. So, using the onlinecompiler.net compiler, I wrote a simple program to call two identical functions. The difference between the 2 is one uses pass by reference, one pass by address.

I have already used this construct in my first (almost complete) C program.

int func (TCHAR* st1, TCHAR* st2, TCHAR* st3, int *start, int *end)

*start = somelocallydefinedint;

-----------------------------

main ()

int start, end;
x = func (st1, st2, st3, &start, &end);

----------------------------

During my test of today, I found that:

*start++;

does not work as expected. Seems I need:

(*start)++;

Which is ironic in that I have one function in my current program that receives a pointer to a WIN32_FIND_DATA struct and in that, the (*struct).fieldinsidestruct syntax must be used.

So, the other way:

int func (........, int &start, int &end)

seems to have the advantage in that, within the function, I don't have to use pesky asterisks and I can also do a start++ with no issues.

The question then becomes: for integers, is there any reason to use the first example of * references vs. the latter, seemingly more concise, & references?

(*struct).fieldinsidestruct is equivalent to the short-form struct->fieldinsidestruct
Yes you need to use parenthesis for (*start)++ because otherwise postfix increment happens too early.

Quote:

---

Originally Posted by jlewand

The question then becomes: for integers, is there any reason to use the first example of * references vs. the latter, seemingly more concise, & references?

---

The most important reason is that C does not have C++-style references :)

If you were programming in C++ instead, then passing a pointer would still make sense if the parameter were optional (in which case a null pointer could be passed).

Quote:

---

Originally Posted by jlewand

The question then becomes: for integers, is there any reason to use the first example of * references vs. the latter, seemingly more concise, & references?

---

I consider it a bug to declare a function parameter (in C++ obviously) as a reference (with &) if the value is modified in the function. The problem is, you can't tell by looking at the function call if it is pass by reference or pass by value--you have to go back and look at the function or its prototype or just remember. And there are far too many things to remember already.

I've taken to commenting other people's code which I chance to touch, and my own code if I have to call such a function. I make the call look like this:

Code:

---

int func(int& var);      // Declared somewhere like this

x = func(/*&ref*/var);  // My comment draws attention to the gotcha

---

Quote:

---

Originally Posted by KenJackson

I consider it a bug to declare a function parameter (in C++ obviously) as a reference (with &) if the value is modified in the function. The problem is, you can't tell by looking at the function call if it is pass by reference or pass by value--you have to go back and look at the function or its prototype or just remember. And there are far too many things to remember already.

---

This is a weakness of non-const references, but I don't consider it a bug: I prefer to have a required out parameter be a reference than a pointer, otherwise the check for a null pointer has to be performed or there is the risk of undefined behaviour, and the latter would be a genuine bug.