Tag: pass-by-reference

Method Overloading vs Method Overriding

http://dis.dankook.ac.kr/lectures/hci10/entry/Method-Overloading-vs-Method-Overriding

Method Overloading: 동일한 함수명에 매개변수가 다른 함수를 둘 이상 정의하는 것으로, 동일한 함수 기능을 수행하지만 다른 매개변수의 경우를 처리할 때 사용

Method Overriding: 상속받은 파생 클래스에서 동일한 함수명에 동일한 매개변수로 정의하여 함수를 재정의하는 것으로 상속되어진 함수의 기능을 변경해서 재사용하고 싶을 때 사용

class Point : IEquatable<Point>, IComparable<Point>
{
// static member field
protected static int count = 0;
// instance member field
protected int x, y;
// property
public int X
{
get { return this.x; }
set { this.x = value; }
}
public int Y
{
get { return this.y; }
set { this.y = value; }
}
public static int Count
{
get { return count; } // error: this.count 는 사용할 수 없음
}
// constructor & destructor
public Point() : this(0, 0) { }
public Point(int x, int y) { this.x = x; this.y = y; count++; }
~Point() { count–; }
// method
public void SetPosition(int x, int y) { this.x = x; this.y = y; }
public void Move(int x, int y) { this.x += x; this.y += y; }
// override method
public override string ToString() { return (String.Format(“({0}, {1})”, x, y)); }
// virtual method
public virtual void Print() { Console.WriteLine(“X={0} Y={1}”, x, y); }public virtual void Sum(Point other) { x += other.X; y += other.Y; }
// static method
public static int GetCount() { return count; }
// operator++ overload
public static Point operator++(Point p) { ++p.x; ++p.y; return p; }
// operator== overload
public static bool operator==(Point p1, Point p2) { return p1.Equals(p2); }
// operator!= overload
public static bool operator!=(Point p1, Point p2) { return !p1.Equals(p2); }
public override int GetHashCode() { return x ^ y; }
public override bool Equals(object obj)
{
if (!(obj is Point))
return false;
return Equals((Point)obj);
}

// IEquatable
public virtual bool Equals(Point other)
{
if (object.ReferenceEquals(this, other)) // if reference is the same
return true;
return (this.x == other.x && this.y == other.y);
}
// IComparable
public int CompareTo(Point other)
{
if (this.x > other.x)
{
return 1;
}
else if (this.x < other.x)
{
return -1;
}
else
{
return 0;
}
}

}

class Point3D : Point, IEquatable<Point3D>
{

// instance member field
protected int z;

// property
public int Z
{
get { return this.z; }
set { this.z = value; }
}

// constructor & destructor
public Point3D() : this(0, 0, 0) { }
public Point3D(int x, int y, int z) : base(x, y) { this.z = z; }
~Point3D() { }

public void SetPosition(int x, int y, int z) { base.SetPosition(x, y); this.z = z; }
public void Move(int x, int y, int z) { base.Move(x, y); this.z += z; }

// override method
public override string ToString() { return (String.Format(“({0}, {1}, {2})”, x, y, z)); }
public override void Print() { Console.WriteLine(“X={0} Y={1} Z={2}”, x, y, z); }
public override void Sum(Point other)
{

if (other is Point3D)
Sum((Point3D)other);
else base.Sum(other);
}


// overload method
public void Sum(Point3D other) { x += other.X; y += other.Y; z += other.Z; }
// operator++ overload
public static Point3D operator++(Point3D p) { ++p.x; ++p.y; ++p.z; return p; }
// operator== overload
public static bool operator ==(Point3D p1, Point3D p2) { return p1.Equals(p2); }
// operator!= overload
public static bool operator !=(Point3D p1, Point3D p2) { return !p1.Equals(p2); }
public override int GetHashCode() { return x ^ y ^ z; }
public override bool Equals(object obj)
{

if (!(obj is Point3D))

return false;

return Equals((Point3D)obj);
}
public override bool Equals(Point other)
{

if (other is Point3D))

return Equals((Point3D)other);

else

return base.Equals(other);

}

// IEquatable
public bool Equals(Point3D other)
{

if (object.ReferenceEquals(this, other))
return true;
return this.x == other.x && this.y == other.y && this.z == other.z;
}
// IComparable
public int CompareTo(Point3D other)
{
if (this == other)
{
return 0;
}
else if (this.x < other.x)
{
return -1;
}
else if ((this.x == other.x) && (this.y < other.y))
{

return -1;
}

else if ((this.x == other.x) && (this.y == other.y) && (this.z < other.z))
{

return -1;
}

else
{

return 1;
}
}

}

class PointTest
{
// pass-by-value (value type)
static void Swap(int p1, int p2)
{
int p;
p = p1;
p1 = p2;
p2 = p;
}
// pass-by-reference (value type)
static void Swap(ref int p1, ref int p2)
{
int p;
p = p1;
p1 = p2;
p2 = p;
}
// pass-by-value (reference type)
static void Swap(int[] p1, int[] p2)
{
int[] p;
p = p1;
p1 = p2;
p2 = p;
}
// pass-by-value (reference type)
static void Swap(ref int[] p1, ref int[] p2)
{
int[] p;
p = p1;
p1 = p2;
p2 = p;
}
static void Swap(ref Point p1, ref Point p2)
{
Point p;
p = p1;
p1 = p2;
p2 = p;
}
static void Swap(ref Point3D p1, ref Point3D p2)
{
Point3D p;
p = p1;
p1 = p2;
p2 = p;
}
static void Main(string[] args)
{
// value type: pass-by-value/pass-by-reference
int i = 5, j = 10;
Console.WriteLine(“Before: i={0}, j={1}”, i, j); // i=5, j=10
Swap(i, j);
Console.WriteLine(“After Swap(i,j): i={0}, j={1}”, i, j); // i=5, j=10
Swap(ref i, ref j);
Console.WriteLine(“After Swap(ref i, ref j): i={0}, j={1}”, i, j); // i=10, j=5
// reference type: pass-by-value/pass-by-reference
int[] arr1 = { 1, 2, 3 };
int[] arr2 = { 4, 5, 6, 7, 8 };
Console.WriteLine(“Before array pass-by-value swap: “);
Console.Write(“arr1: “);
foreach (int a in arr1) Console.Write(“{0} “, a); // arr1: 1 2 3
Console.WriteLine();
Console.Write(“arr2: “);
foreach (int a in arr2) Console.Write(“{0} “, a); // arr2: 4 5 6 7 8
Console.WriteLine();
Swap(arr1, arr2);
Console.WriteLine(“After Swap(arr1, arr2): “);
Console.Write(“arr1: “);
foreach (int a in arr1) Console.Write(“{0} “, a); // arr1: 1 2 3
Console.WriteLine();
Console.Write(“arr2: “);
foreach (int a in arr2) Console.Write(“{0} “, a); // arr2: 4 5 6 7 8
Console.WriteLine();
Swap(ref arr1, ref arr2);
Console.WriteLine(“After Swap(ref arra1, ref arr2): “);
Console.Write(“arr1: “);
foreach (int a in arr1) Console.Write(“{0} “, a); // arr1: 4 5 6 7 8
Console.WriteLine();
Console.Write(“arr2: “);
foreach (int a in arr2) Console.Write(“{0} “, a); // arr2: 1 2 3
Console.WriteLine();
// Point
Console.Write(“p1: “);
Point p1 = new Point();
p1.Print(); // Point.Print() (0, 0)
Console.Write(“p2: “);
Point p2 = new Point();
p2.Print(); // Point.Print() (0, 0)
p1.SetPosition(10, 10); // Point.SetPosition(int, int)
Console.Write(“p1 SetPosition: “);
p1.Print(); // Point.Print() (10, 10)
p1.Move(20, 50); // Point.Move(int, int)
Console.Write(“p1 Move: “);
Console.WriteLine(“p1=” + p1); // Point.ToString() (30, 60)
p2.SetPosition(20, 30); // Point.SetPosition(int, int)
Console.Write(“p2 SetPosition: “);
p2.Print(); // Point.Print() (20, 30)
//포인터 객체 교환함수 호출
Console.WriteLine(“\nSwap”);
Swap(ref p1, ref p2);
Console.WriteLine(“p1: {0}”, p1); // Point.ToString() (20, 30)
Console.WriteLine(“p2: {0}”, p2); // Point.ToString() (30, 60)
Console.WriteLine();
Console.WriteLine(“p1.m_nX={0}, p1.m_nY={1}, Point.GetCount()={2}”, p1.X, p1.Y, Point.Count);
Console.WriteLine(“p2.m_nX={0}, p2.m_nY={1}, Point.GetCount()={2}”, p2.X, p2.Y, Point.Count);
// Point3D
Console.Write(“p3: “);
Point3D p3 = new Point3D();
p3.Print(); // Point3D.Print() (0, 0, 0)
Console.Write(“p4: “);
Point3D p4 = new Point3D();
p4.Print(); // Point3D.Print() (0, 0, 0)
Console.WriteLine();
p3.SetPosition(10, 20); // Point3D.SetPosition(int,int)
Console.Write(“p3 SetPosition: “);
p3.Print(); // Point3D.Print() (10, 20, 0)
p3.SetPosition(30, 40, 50); // Point3D.SetPosition(int,int,int)
Console.Write(“p3 SetPosition: “);
p3.Print(); // Point3D.Print() (30, 40, 50)
++p3; // Point3D.operator++
Console.Write(“++p3: “);
p3.Print(); // Point3D.Print() (31, 41, 51)
p3.Move(20, 30, 40); // Point3D.Move(int,int,int)
Console.Write(“p3 Move: “);
p3.Print(); // Point3D.Print() (51, 71, 91)
p3.Move(10, 10); // Point3D.Move(int,int)
Console.Write(“p3 Move: “);
Console.WriteLine(p3); // Point3D.ToString() (61, 81, 91)
Console.WriteLine();
p4.SetPosition(100, 200, 300); // Point3D.SetPosition(int,int,int)
Console.Write(“p4 SetPosition: “);
p4.Print(); // Point3D.Print() (100, 200, 300)
p4.Move(10, 10, 10); // Point.Move(int, int,int)
Console.Write(“p4 Move: “);
p4.Print(); // Point3D.Print() (110, 210, 310)
//SUM
Console.WriteLine(“\nSUM”);
p3.Sum(p4); // Point3D.Sum(Point3D) (61+110, 81+210, 91+310)
p3.Print(); // Point3D.Print() (171, 291, 401)
//포인터 객체 교환함수 호출
Console.WriteLine(“\nSwap”);
Swap(ref p3, ref p4); // (171,291,401) <-> (110,210,310)
Console.WriteLine(“p1: {0}”, p3); // Point3D.ToString() (110,210,310)
Console.WriteLine(“p2: {0}”, p4); // Point3D.ToString() (171,291,401)
Console.WriteLine();
Console.WriteLine(“p3.m_nX={0}, p3.m_nY={1}, p3.m_nZ={2}, Point.GetCount()={3}”, p3.X, p3.Y, p3.Z, Point.GetCount());
Console.WriteLine(“p4.m_nX={0}, p4.m_nY={1}, p4.m_nZ={2}, Point.count={3}”, p4.X, p4.Y, p4.Z, Point.Count);
if (p3 == p4) Console.WriteLine(“p3 == p4”); // Point3D.operator==
if (p3 != p4) Console.WriteLine(“p3 != p4”); // Point3D.operator!=
Console.Write(“p5: “);
// polymorphism
Point p5 = p3; // upcasting – P5는 Point 타입인 Point3D 객체
p5.Print(); // Point3D.Print() (late binding) (110,210,310)
p5.SetPosition(10,20); // Point.SetPosition(int,int)
p5.Print(); // Point3D.Print() (late binding) (10,20,310)
((Point3D)p5).SetPosition(10,20,30); // downcasting – Point3D.SetPosition(int,int,int)

p5.Print(); // Point3D.Print() (late binding) (10,20,30)
Console.Write(“p6: “);
Point p6 = new Point3D(110, 210, 310); // upcasting – p6도 Point 타입인 Point3D 객체
p6.Print(); // Point3D.Print() (late binding) (110,210,310)
p5.Sum(p6); // Point3D.Sum(Point) (late binding) (10+110, 20+210, 30+310)
p5.Print(); // Point3D.Print() (late binding) (110,230,340)
p6.Print(); // Point3D.Print() (late binding) (110,210,310)
Point3D p7 = (Point3D)p5; // downcasting
Console.WriteLine(p7); // Point3D.ToString()
Point3D p8 = p5 as Point3D;
Console.WriteLine(p7); // Point3D.ToString()
if (p7 == p8) Console.WriteLine(“p7 == p8”); // p7 == p8
}
}

 

Parameter Passing: pass by value vs pass by reference vs pass by output

http://dis.dankook.ac.kr/lectures/hci10/entry/pass-by-value와-pass-by-reference와-pass-by-output-비교

 

pass value type by value (값형식을 값에 의한 전달)

static void Square1(int x)
{
x *= x;
Console.WriteLine(“The value inside the method: {0}”, x);
}
static void Main()
{
int i = 5;
Console.WriteLine(“i={0}”, i);
Square1(i);
Console.WriteLine(“i={0}”, i);
}
//i=5
//The value inside the method: 25
//i=5

 

pass reference type by value (참조형식을 값에 의한 전달)
-copy of reference가 전달

static void ChangeArray1(int[] arr)
{
arr[0]=888; // arr -> myArray이므로 원본 배열의 첫번째 값은 888로 변경
Console.WriteLine(“arr=” + string.Join(“,”, arr)); // .NET4만 동작
//Console.WriteLine(“arr=” + string.Join(“,”, Array.ConvertAll(arr, x => x.ToString()))); // .NET4  Earlier
arr = new int[5] {-3, -1, -2, -3, -4}; // local 변수로 새롭게 할당하여 지정
Console.WriteLine(“arr=” + string.Join(“,”, arr)); // .NET4
}
static void Main()
{
int[] myArray = {1, 4, 5};
Console.WriteLine(“myArray=” + string.Join(“,”, myArray)); // .NET4
ChangeArray1(myArray);
Console.WriteLine(“myArray=” + string.Join(“,”, myArray)); // .NET4
}
//myArray=1, 4, 5
//arr=888, 4, 5
//arr=-3, -1, -2, -3, -4
//myArray=888, 4, 5

 

 

pass value type by reference (값형식을 참조에 의한 전달)
–ref 키워드 사용

static void Square2(ref int x)
{
x *= x;
Console.WriteLine(“The value inside the method: {0}”, x);
}
static void Main()
{
int i = 5;
Console.WriteLine(“i={0}”, i);
Square2(ref i);
Console.WriteLine(“i={0}”, i);
}
//i=5
//The value inside the method: 25
//i=25

 

pass reference type by reference (참조형식을 참조에 의한 전달)
–ref 키워드 사용

static void ChangeArray2(ref int[] arr)
{
arr[0]=888; // 원본 배열의 첫번째 값은 888로 변경
Console.WriteLine(“arr=” + string.Join(“,”, arr)); // .NET4만 동작
arr = new int[5] {-3, -1, -2, -3, -4}; // 원본 배열이 다시 변경
Console.WriteLine(“arr=” + string.Join(“,”, arr)); // .NET4만 동작
}
static void Main()
{
int[] myArray = {1, 4, 5};
Console.WriteLine(“myArray=” + string.Join(“,”, myArray)); // .NET4
ChangeArray2(ref myArray);
Console.WriteLine(“myArray=” + string.Join(“,”, myArray)); // .NET4
}
// myArray=1, 4, 5
// arr=888, 4, 5
// arr=-3, -1, -2, -3, -4
// myArray=-3, -1, -2, -3, -4

 

pass value type by output (값형식을 output에 의한 전달)
–out 키워드 사용

static void Square3(int x, out int result)
{
result = x*x;
Console.WriteLine(“The value inside the method: {0}”, result);
}
static void Main()
{
int i = 5;
Console.WriteLine(“i={0}”, i);
int result;
Square3(i, out result);
Console.WriteLine(“result={0}”, result);
}
//i=5
//The value inside the method: 25
//result=25

 

pass reference type by output (참조형식을 output에 의한 전달)
–out 키워드 사용

static void ChangeArray3(out int[] arr)
{
//arr[0]=888; // use of unassigned out parameter ‘arr’ ERROR
arr = new int[5] {-3, -1, -2, -3, -4}; // 원본 배열이 변경
Console.WriteLine(“arr=” + string.Join(“,”, arr)); // .NET4
}
static void Main()
{
int[] myArray = {1, 4, 5};
Console.WriteLine(“myArray=” + string.Join(“,”, myArray)); // .NET4
ChangeArray3(out myArray);
Console.WriteLine(“myArray=” + string.Join(“,”, myArray)); // .NET4
}
//myArray=1, 4, 5
//arr=-3, -1, -2, -3, -4
//myArray=-3, -1, -2, -3, -4