Pass by Reference as "essential" to swap method exposed as a lie

[raylopez99]

In the otherwise excellent book C# 3.0 in a Nutshell by Albahari et
al. (3rd edition) (highly recommended--it's packed with information,
and is a desktop reference book) the following statement is made: (p.
39: "The ref modifier is essential in implementing a swap method")

This is untrue. The following program demonstrates it. See how
method "func4Swap" does a swap of two int variables without using ref,
but using a 'helper' class and using only pass by value

However, ref is important when using 'new' in the method calling the
variables to be used (not shown here), or, if you want to permanently
change the variables passed from inside the class doing the passing
(see func1 method and swap1 method below). In fact, I'm not sure you
can do a swap without using ref and without using a 'helper' class as
in the below.

RL

// OUTPUT AT END

// Pass by reference, Pass by Value demonstrated // October 15, 2008

using System;
using System.Collecti ons.Generic;
using System.Linq;
using System.Text;
using System.Runtime. InteropServices ;
namespace console1
{
class Program
{
static void Main(string[] args)
{
////////////////////////////////////////////
// show pass by ref

PassByRef01 myPBRclas1 = new PassByRef01();

Console.WriteLi ne("I. i,j's and k,m's are: {0}, {1}, {2}, {3}",
myPBRclas1.i, myPBRclas1.j, myPBRclas1.k,my PBRclas1.m);
myPBRclas1.func 2(myPBRclas1.i, myPBRclas1.j);
Console.WriteLi ne("II. i,j's and k,m's are: {0}, {1}, {2}, {3}",
myPBRclas1.i, myPBRclas1.j, myPBRclas1.k, myPBRclas1.m);
myPBRclas1.func 1(ref myPBRclas1.k, ref myPBRclas1.m);
Console.WriteLi ne("III. i,j's and k,m's are: {0}, {1}, {2}, {3}",
myPBRclas1.i, myPBRclas1.j, myPBRclas1.k, myPBRclas1.m);

PassByRef01 placeHolderPass ByRef01cl = new PassByRef01();

placeHolderPass ByRef01cl.func3 (myPBRclas1);
Console.WriteLi ne("IV. i,j's and k,m's are: {0}, {1}, {2}, {3}",
myPBRclas1.i, myPBRclas1.j, myPBRclas1.k, myPBRclas1.m);

placeHolderPass ByRef01cl.func2 (myPBRclas1.k, myPBRclas1.m);
Console.WriteLi ne("V. i,j's and k,m's are: {0}, {1}, {2}, {3}",
myPBRclas1.i, myPBRclas1.j, myPBRclas1.k, myPBRclas1.m);
Console.WriteLi ne("VI. i,j's and k,m's are: {0}, {1}, {2}, {3}",
myPBRclas1.i, myPBRclas1.j, myPBRclas1.k, myPBRclas1.m);
Console.WriteLi ne("reset values");
myPBRclas1.k = 100;
myPBRclas1.m = 200;
Console.WriteLi ne("1. k,m's are: {0}, {1}", myPBRclas1.k,
myPBRclas1.m);
placeHolderPass ByRef01cl.func4 Swap(myPBRclas1 );
Console.WriteLi ne("2. i,j's and k,m's are: {0}, {1}",myPBRclas1 .k,
myPBRclas1.m);
Console.WriteLi ne("now use 'traditional' swap");
placeHolderPass ByRef01cl.func4 TraditionalSwap (ref myPBRclas1);
Console.WriteLi ne("3. i,j's and k,m's are: {0}, {1}",
myPBRclas1.k, myPBRclas1.m);
Console.WriteLi ne("now use traditional swap from inside of class
(no helper class used)");
myPBRclas1.swap 1(ref myPBRclas1.k, ref myPBRclas1.m);
Console.WriteLi ne("4. i,j's and k,m's are: {0}, {1}",
myPBRclas1.k, myPBRclas1.m);
}

}
}
/////////////////
using System;
using System.Collecti ons.Generic;
using System.Linq;
using System.Text;

namespace console1
{
class PassByRef01
{
public int k, m;
int _i, _j;
public PassByRef01()
{
_i = 10;
_j = 11;
k = 1;
m = 2;
}
public void swap1(ref int a, ref int b)
{
int temp = a;
a = b;
b = temp;
}

public void func1(ref int a, ref int b)
{
a = 1111;
b = 2222;
Console.WriteLi ne("inside func1, k,m's are: {0}, {1}", k,
m);
}
public void func2(int a, int b)
{
a = 1110000; //since ref not used, this assignment never
made for k,m
b = 2220000;
Console.WriteLi ne("inside func2, k,m's are: {0}, {1}",
k,m);
}

public void func3(PassByRef 01 x)
{
x.k = 66;
x.m = 67;
Console.WriteLi ne("inside func3, k,m's are: {0}, {1}", k,
m);
}

public void func4Traditiona lSwap(ref PassByRef01 y)
{
int temp;
temp = y.k;
y.k = y.m;
y.m = temp;
}

public void func4Swap(PassB yRef01 x)
{
int temp1, temp2;
temp1 = x.k;
temp2 = x.m;
x.m = temp1;
x.k = temp2;

Console.WriteLi ne("inside func3, k,m's are: {0}, {1} and
x.k, x.m are: {2}, {3}", k, m, x.k, x.m);
}
public int i //cannot pass by ref a property
{
get { return _i; }
set { _i = value; }
}
public int j
{
get { return _j; }
set { _j = value; }
}
}

}
/////////////////////// OUTPUT

I. i,j's and k,m's are: 10, 11, 1, 2
inside func2, k,m's are: 1, 2
II. i,j's and k,m's are: 10, 11, 1, 2
inside func1, k,m's are: 1111, 2222
III. i,j's and k,m's are: 10, 11, 1111, 2222
inside func3, k,m's are: 1, 2
IV. i,j's and k,m's are: 10, 11, 66, 67
inside func2, k,m's are: 1, 2
V. i,j's and k,m's are: 10, 11, 66, 67
VI. i,j's and k,m's are: 10, 11, 66, 67
reset values
1. k,m's are: 100, 200
inside func3, k,m's are: 1, 2 and x.k, x.m are: 200, 100
2. i,j's and k,m's are: 200, 100
now use 'traditional' swap
3. i,j's and k,m's are: 100, 200
now use traditional swap from inside of class (no helper class used)
4. i,j's and k,m's are: 200, 100
Press any key to continue . . .

[Marc Gravell]

You've done this to death already; and you're still quite, quite
wrong. Ref applies only to the arguments - i.e. "x".

Marc

[raylopez99]

On Oct 15, 5:50*am, Marc Gravell <marc.grav...@g mail.comwrote:

You've done this to death already; and you're still quite, quite
wrong. Ref applies only to the arguments - i.e. "x".

Marc

Semantics my friend. You are clearly wrong.

What part of this code don't you understand?
public void func4Swap(PassB yRef01 x)
{
int temp1, temp2;
temp1 = x.k;
temp2 = x.m;
x.m = temp1;
x.k = temp2;
Console.WriteLi ne("inside func3, k,m's are: {0}, {1} and
x.k, x.m are: {2}, {3}", k, m, x.k, x.m);
}
It works to change x.m to x.k. That was the exercise.

All the words in the world and all the spin won't change this
verisimilitude.

RL

[Peter Morris]

You are not passing using the "ref" qualifier but you are passing a
reference which may be changed.

To prove you are correct the only way would be to write code which passes
this test:

[TestMethod]
public void ProvePassByRefe renceIsEsstenti alIsALie()
{
int value1 = 1;
int value2 = 2;

Swap(value1, value2);

Assert.AreEqual (2, value1);
Assert.AreEqual (1, value2);
}

You are not allowed to change the test source code at all. You will not be
able to do it, I am certain.

PS: Saying it is a "lie" is ridiculous. At worst it would be a mistake, not
a lie!

Pete
====
http://mrpmorris.blogspot.com
http://www.capableobjects.com

[Marc Gravell]

It works to change x.m to x.k. *That was the exercise.

Only to you. In the context of the book, the exercise was undoubtedly
to swap the values of the *arguments*, not to swap two fields on a
single (class) argument.

Anyway, that is me done on this thread...

Marc

[=?Utf-8?B?Q2lhcmFuIE8nJ0Rvbm5lbGw=?=]

Your example is not swapping parameters. If i had an array and wanted to swap
two elements in it. I could not just call your function. I would have to
create you class, copy the references from the array to the class's
variables, call the function and then copy the references back. That is
entirely useless, You might as well do the swap inline as it would be less
code and more efficient.
To do a pure swap function which switches the value of the reference
variables passed as parameters you need to use the ref keyword. Why are you
always trying to find a different way to do this?
--
Ciaran O''Donnell
http://wannabedeveloper.spaces.live.com
"raylopez99 " wrote:

On Oct 15, 5:50 am, Marc Gravell <marc.grav...@g mail.comwrote:

You've done this to death already; and you're still quite, quite
wrong. Ref applies only to the arguments - i.e. "x".

Marc

Semantics my friend. You are clearly wrong.

What part of this code don't you understand?
public void func4Swap(PassB yRef01 x)
{
int temp1, temp2;
temp1 = x.k;
temp2 = x.m;
x.m = temp1;
x.k = temp2;
Console.WriteLi ne("inside func3, k,m's are: {0}, {1} and
x.k, x.m are: {2}, {3}", k, m, x.k, x.m);
}
It works to change x.m to x.k. That was the exercise.

All the words in the world and all the spin won't change this
verisimilitude.

RL

[raylopez99]

On Oct 15, 6:45*am, Ciaran O''Donnell
<CiaranODonn... @discussions.mi crosoft.comwrot e:

Your example is not swapping parameters. If i had an array and wanted to swap
two elements in it. I could not just call your function. I would have to
create you class, copy the references from the array to the class's
variables, call the function and then copy the references back. That is
entirely useless, You might as well do the swap inline as it would be less
code and more efficient.

Thanks for the reply. BTW how do you do anything 'inline' in C#? In C
++ I had the convention down pat but if you can post a short example
it would be helpful for me.

To do a pure swap function which switches the value of the reference
variables passed as parameters you need to use the ref keyword. Why are you
always trying to find a different way to do this?

I'm just showing how using encapsulation you can get around a lot of
bugaboos in C# (this also holds for private variables, because in a
way 'properties' is such an encapsulation).

Now the best answer for the 'traditionalist s' was given by Marc and
Peter Morris--you simply redefine your problem so your 'definition'
holds. But, in a way, I stood that principle on its head and
redefined it to suit my needs.

After all, if you are a master coder (and I'm not yet, with about 2
solid months of C# experience) you can find exceptions to every rule.

RL

[Jon Skeet [C# MVP]]

On Oct 15, 3:22*pm, raylopez99 <raylope...@yah oo.comwrote:

<snip>

Now the best answer for the 'traditionalist s' was given by Marc and
Peter Morris--you simply redefine your problem so your 'definition'
holds. *But, in a way, I stood that principle on its head and
redefined it to suit my needs.

Yes - you redefined the problem. What you've done may indeed be
useful, but in no way proves the book wrong.

Jon

[Peter Morris]

>>
Now the best answer for the 'traditionalist s' was given by Marc and
Peter Morris--you simply redefine your problem so your 'definition'
holds.
<<

I didn't redefine the problem.
01: I haven't seen the original text in the book.
02: I used my brain and guessed what the book is saying, and that is you
cannot change "parameter values" from the caller's point of view unless you
use "ref".

>>

After all, if you are a master coder (and I'm not yet, with about 2
solid months of C# experience) you can find exceptions to every rule.
<<

Or, put another way, what I lack in skill I more than make up for in denial
;-)

--
Pete
====
http://mrpmorris.blogspot.com
http://www.capableobjects.com

[=?Utf-8?B?S0g=?=]

That's a lot of work to 'swap' two ints; try ...

int a = 3;
int b = 5;

a ^= b;
b ^= a;
a ^= b;

// a = 5, b = 3
"raylopez99 " wrote:

In the otherwise excellent book C# 3.0 in a Nutshell by Albahari et
al. (3rd edition) (highly recommended--it's packed with information,
and is a desktop reference book) the following statement is made: (p.
39: "The ref modifier is essential in implementing a swap method")

This is untrue. The following program demonstrates it. See how
method "func4Swap" does a swap of two int variables without using ref,
but using a 'helper' class and using only pass by value

However, ref is important when using 'new' in the method calling the
variables to be used (not shown here), or, if you want to permanently
change the variables passed from inside the class doing the passing
(see func1 method and swap1 method below). In fact, I'm not sure you
can do a swap without using ref and without using a 'helper' class as
in the below.

RL

// OUTPUT AT END

// Pass by reference, Pass by Value demonstrated // October 15, 2008

using System;
using System.Collecti ons.Generic;
using System.Linq;
using System.Text;
using System.Runtime. InteropServices ;
namespace console1
{
class Program
{
static void Main(string[] args)
{
////////////////////////////////////////////
// show pass by ref

PassByRef01 myPBRclas1 = new PassByRef01();

Console.WriteLi ne("I. i,j's and k,m's are: {0}, {1}, {2}, {3}",
myPBRclas1.i, myPBRclas1.j, myPBRclas1.k,my PBRclas1.m);
myPBRclas1.func 2(myPBRclas1.i, myPBRclas1.j);
Console.WriteLi ne("II. i,j's and k,m's are: {0}, {1}, {2}, {3}",
myPBRclas1.i, myPBRclas1.j, myPBRclas1.k, myPBRclas1.m);
myPBRclas1.func 1(ref myPBRclas1.k, ref myPBRclas1.m);
Console.WriteLi ne("III. i,j's and k,m's are: {0}, {1}, {2}, {3}",
myPBRclas1.i, myPBRclas1.j, myPBRclas1.k, myPBRclas1.m);

PassByRef01 placeHolderPass ByRef01cl = new PassByRef01();

placeHolderPass ByRef01cl.func3 (myPBRclas1);
Console.WriteLi ne("IV. i,j's and k,m's are: {0}, {1}, {2}, {3}",
myPBRclas1.i, myPBRclas1.j, myPBRclas1.k, myPBRclas1.m);

placeHolderPass ByRef01cl.func2 (myPBRclas1.k, myPBRclas1.m);
Console.WriteLi ne("V. i,j's and k,m's are: {0}, {1}, {2}, {3}",
myPBRclas1.i, myPBRclas1.j, myPBRclas1.k, myPBRclas1.m);
Console.WriteLi ne("VI. i,j's and k,m's are: {0}, {1}, {2}, {3}",
myPBRclas1.i, myPBRclas1.j, myPBRclas1.k, myPBRclas1.m);
Console.WriteLi ne("reset values");
myPBRclas1.k = 100;
myPBRclas1.m = 200;
Console.WriteLi ne("1. k,m's are: {0}, {1}", myPBRclas1.k,
myPBRclas1.m);
placeHolderPass ByRef01cl.func4 Swap(myPBRclas1 );
Console.WriteLi ne("2. i,j's and k,m's are: {0}, {1}",myPBRclas1 .k,
myPBRclas1.m);
Console.WriteLi ne("now use 'traditional' swap");
placeHolderPass ByRef01cl.func4 TraditionalSwap (ref myPBRclas1);
Console.WriteLi ne("3. i,j's and k,m's are: {0}, {1}",
myPBRclas1.k, myPBRclas1.m);
Console.WriteLi ne("now use traditional swap from inside of class
(no helper class used)");
myPBRclas1.swap 1(ref myPBRclas1.k, ref myPBRclas1.m);
Console.WriteLi ne("4. i,j's and k,m's are: {0}, {1}",
myPBRclas1.k, myPBRclas1.m);
}

}
}
/////////////////
using System;
using System.Collecti ons.Generic;
using System.Linq;
using System.Text;

namespace console1
{
class PassByRef01
{
public int k, m;
int _i, _j;
public PassByRef01()
{
_i = 10;
_j = 11;
k = 1;
m = 2;
}
public void swap1(ref int a, ref int b)
{
int temp = a;
a = b;
b = temp;
}

public void func1(ref int a, ref int b)
{
a = 1111;
b = 2222;
Console.WriteLi ne("inside func1, k,m's are: {0}, {1}", k,
m);
}
public void func2(int a, int b)
{
a = 1110000; //since ref not used, this assignment never
made for k,m
b = 2220000;
Console.WriteLi ne("inside func2, k,m's are: {0}, {1}",
k,m);
}

public void func3(PassByRef 01 x)
{
x.k = 66;
x.m = 67;
Console.WriteLi ne("inside func3, k,m's are: {0}, {1}", k,
m);
}

public void func4Traditiona lSwap(ref PassByRef01 y)
{
int temp;
temp = y.k;
y.k = y.m;
y.m = temp;
}

public void func4Swap(PassB yRef01 x)
{
int temp1, temp2;
temp1 = x.k;
temp2 = x.m;
x.m = temp1;
x.k = temp2;

Console.WriteLi ne("inside func3, k,m's are: {0}, {1} and
x.k, x.m are: {2}, {3}", k, m, x.k, x.m);
}
public int i //cannot pass by ref a property
{
get { return _i; }
set { _i = value; }
}
public int j
{
get { return _j; }
set { _j = value; }
}
}

}
/////////////////////// OUTPUT

I. i,j's and k,m's are: 10, 11, 1, 2
inside func2, k,m's are: 1, 2
II. i,j's and k,m's are: 10, 11, 1, 2
inside func1, k,m's are: 1111, 2222
III. i,j's and k,m's are: 10, 11, 1111, 2222
inside func3, k,m's are: 1, 2
IV. i,j's and k,m's are: 10, 11, 66, 67
inside func2, k,m's are: 1, 2
V. i,j's and k,m's are: 10, 11, 66, 67
VI. i,j's and k,m's are: 10, 11, 66, 67
reset values
1. k,m's are: 100, 200
inside func3, k,m's are: 1, 2 and x.k, x.m are: 200, 100
2. i,j's and k,m's are: 200, 100
now use 'traditional' swap
3. i,j's and k,m's are: 100, 200
now use traditional swap from inside of class (no helper class used)
4. i,j's and k,m's are: 200, 100
Press any key to continue . . .