October | 2010 | HCI 2010

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; }

// ToString method override
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); }
// 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 bool Equals(Point other)
{
if (this.x == other.x && this.y == other.y)
return true;
return false;
}

// 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 ToString method
public override string ToString() { return (String.Format(“({0}, {1}, {2})”, x, y, z)); }
// overrided method
public override void Print() { Console.WriteLine(“X={0} Y={1} Z={2}”, x, y, 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);
}

// IEquatable
public bool Equals(Point3D other)
{
if (this.x == other.x && this.y == other.y && this.z == other.z)
return true;
return false;
}
}

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);

Swap(i, j);
Console.WriteLine(“After integer pass-by-value swap: i={0}, j={1}”, i, j);

Swap(ref i, ref j);
Console.WriteLine(“After integer pass-by-reference Swap: i={0}, j={1}”, i, j);

// 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);
Console.WriteLine();
Console.Write(“arr2: “);
foreach (int a in arr2)
Console.Write(“{0} “, a);
Console.WriteLine();

Swap(arr1, arr2);
Console.WriteLine(“After array pass-by-value swap: “);
Console.Write(“arr1: “);
foreach (int a in arr1)
Console.Write(“{0} “, a);
Console.WriteLine();
Console.Write(“arr2: “);
foreach (int a in arr2)
Console.Write(“{0} “, a);
Console.WriteLine();

Swap(ref arr1, ref arr2);
Console.WriteLine(“After array pass-by-reference swap: “);
Console.Write(“arr1: “);
foreach (int a in arr1)
Console.Write(“{0} “, a);
Console.WriteLine();
Console.Write(“arr2: “);
foreach (int a in arr2)
Console.Write(“{0} “, a);
Console.WriteLine();

Console.Write(“p1: “);
Point p1 = new Point();
Console.Write(“p2: “);
Point p2 = new Point();

// Point
p1.SetPosition(10, 10); // 변수 값 지정
Console.Write(“p1 SetPosition: “);
p1.Print(); // 현재 좌표 출력
p1.Move(20, 50); // 좌표 변경 (점의 위치 이동)
Console.Write(“p1 Move: “);
p1.Print(); // 현재 좌표 출력
Console.WriteLine(“p1=” + p1);

p2.SetPosition(20, 30); // 변수 값 지정
Console.Write(“p2 SetPosition: “);
p2.Print(); // 현재 좌표 출력

//포인터 객체 교환함수 호출
Console.WriteLine(“\nSwap”);
Swap(ref p1, ref p2);
Console.WriteLine(“p1: {0}”, p1);
Console.WriteLine(“p2: {0}”, p2);

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();
Console.Write(“p4: “);
Point3D p4 = new Point3D();

Console.WriteLine();
p3.SetPosition(10, 20);
Console.Write(“p3 SetPosition: “);
      p3.Print(); // 현재 좌표 출력
p3.SetPosition(30, 40, 50);
Console.Write(“p3 SetPosition: “);
p3.Print(); // 현재 좌표 출력
++p3;
Console.Write(“++p3: “);
   p3.Print(); // 현재 좌표 출력
p3.Move(20, 30, 40); // 좌표 변경 (점의 위치 이동)
Console.Write(“p3 Move: “);
      p3.Print(); // 현재 좌표 출력
p3.Move(10, 10); // 좌표 변경 (점의 위치 이동)
Console.Write(“p3 Move: “);
Console.WriteLine(p3); // p3는 Point클래스의 ToString이 호출

Console.WriteLine();
p4.SetPosition(100, 200, 300);
Console.Write(“p4 SetPosition: “);
p4.Print(); // 현재 좌표 출력
p4.Move(10, 10, 10); // 좌표 변경 (점의 위치 이동)
Console.Write(“p4 Move: “);
p4.Print(); // 현재 좌표 출력

//포인터 객체 교환함수 호출
Console.WriteLine(“\nSwap”);
Swap(ref p3, ref p4);
Console.WriteLine(“p1: {0}”, p3);
Console.WriteLine(“p2: {0}”, p4);

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”);
if (p3 != p4)
Console.WriteLine(“p3 != p4”);

Console.Write(“p5: “);
Point p5 = p3;
p5.Print(); // 현재 좌표 출력 p5는 Point3D – polymorphism
Console.Write(“p6: “);
Point p6 = new Point3D(110, 210, 310); // p6도 Point3D
p6.Print(); // Point3D의 Print가 호출 (late binding) – polymorphism
Point3D p7 = (Point3D)p5;
Console.WriteLine(p7); // p7는 Point3D클래스의 ToString이 호출
if (p7 == p5)
Console.WriteLine(“p7 == p5”);
if (p7 == p6)
Console.WriteLine(“p7 == p6”);
}
}

protected
-protected 접근 지정자를 사용한 멤버 필드와 메소드는 파생 클래스에서는 사용가능하나 클래스 외부에서는 호출하지 못함

ProtectedTest.cs

static
-static field는 전역 데이터로 클래스당 하나만 할당됨
-클래스명.정적필드명 형태로 사용
-static method는 class method나 static member field 조작을 위한 메소드
-static method는 instance field는 접근 불가능

Point.cs

Static.cs

StaticTest.cs

constructor
-default constructor (기본 생성자)
-constructor overloading (생성자 오버로딩) 생성자를 여러 가지 형태로 정의
-constructor initializer (생성자 초기화 목록) 생성자들 사이의 정의가 비슷한 경우 코드를 간략하게 만들기 위해 사용

InitializerTest.cs

-private constructor (private 생성자) 정적 멤버만 포함하는 클래스에서 사용하며 클래스가 인스턴스화 될 수 없음을 분명히 하기 위해 private 접근 지정자를 사용
-static constructor (static 생성자) 정적 데이터 멤버를 초기화하는데 사용

destructor
-객체가 소멸될 때 필요한 정리 작업을 정의하는 부분

HCI 2010

Monthly Archives: October 2010

C# Formatting Numeric String

C# ArrayList

C# Generic Class vs. C++ Template Class

Point Class Assembly

Method Overloading vs. Method Overriding

Delegate & Event

Interface

Class & Inheritance

Class

lecture7

Just another Kyoung Shin Park’s Lectures Sites site