[문제 풀기] boxing, unboxing과 인터페이스에 대하여

1. boxing과 unboxing이 왜 나쁜가? 언제 일어나는가?

boxing은 값형 변수를 참조형 변수로 형 변환하는 경우에 스택 영역에 있던 데이터를 힙 영역으로 로드하는 것을 의미한다.

unboxing은 참조형 변수를 값형 변수로 형 변환하는 경우에 힙 영역에 있던 데이터를 스택 영역으로 로드한 것을 의미한다.

 

대표적으로 object 클래스로 매개변수를 전달 받을 때, 그 매개변수로 기본 데이터형이 전달되어서 발생하는 경우이다.

 

boxing의 경우, 불필요하게 스택 영역의 데이터를 힙 영역에 올리기 위해 메모리 공간을 확보하고 데이터를 올리는 일련의 과정을 수행되어야한다는 점에서 나쁘다고 이야기할 수 있고,

unboxing의 경우, 형 변환이 수행되는 과정에서 올바른 형 변환을 하고 있는지 컴파일 타임에서 타입 검사를 하지 않으며 런타임에 타입 검사를 하기에 프로그램이 런타임 중에 종료되는 현상을 발생할 수 있어 나쁘다고 이야기할 수 있다.

 

2. 나만의 배열을 만들어 복사, 인덱스 참조, 정렬, 이진탐색을 구현하라.

using System;

namespace ConsoleApp6
{
    class MyArray
    {
        public static void Copy(int[] sour, int[] dest, int length)
        {
            for (int i = 0; i < length; i++)
            {
                dest[i] = sour[i];
            }
        }
        public static void Copy(int[] sour, int sourStart, int[] dest, int destStart, int length)
        {
            for(int i = 0; i < length; i++)
            {
                dest[destStart + i] = sour[sourStart + i];
            }
        }
        public static int IndexOf(int[] array, int number)
        {
            for(int idx = 0; idx < array.Length; idx++)
            {
                if(array[idx] == number)
                {
                    return idx;
                }
            }

            return -1;
        }
        public static void Sort(int[] array)
        {
            for (int idx = 0; idx < array.Length - 1; idx++)
            {
                for(int innerIdx = 0; innerIdx < array.Length - 1 - idx; innerIdx++)
                {
                    if (array[innerIdx] >= array[innerIdx + 1])
                    {
                        int temp = array[innerIdx];
                        array[innerIdx] = array[innerIdx + 1];
                        array[innerIdx + 1] = temp;
                    }
                }
            }
        }

        public static int BinarySearch(int[] array, int number)
        {
            int mid = array.Length / 2;
            int min = 0;
            int max = array.Length - 1;
            while(true)
            {
                if (array[mid] == number)
                    return mid;

                if (min > max)
                    return -1;

                if(array[mid] > number) // 왼쪽
                {
                    max = mid - 1;
                    mid = (min + max) / 2;
                }
                else if(array[mid] < number) // 오른쪽
                {
                    min = mid + 1;
                    mid = (min + max) / 2;
                }
            }
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            int[] array = { 10, 30, 50, 20, 40, 100, -50};
            int[] dest = new int[array.Length];

            MyArray.Copy(array, dest, array.Length);
            MyArray.Copy(array, 0, dest, 0, array.Length);

            Console.WriteLine("copy");
            foreach (var number in dest)
            {
                Console.WriteLine(number);
            }

            Console.WriteLine();
            Console.WriteLine("indexOf");
            var find = MyArray.IndexOf(array, 100);
            Console.WriteLine(find);
            find = MyArray.IndexOf(array, 30);
            Console.WriteLine(find);

            Console.WriteLine();
            Console.WriteLine("sort");
            MyArray.Sort(array);

            foreach (var number in array)
            {
                Console.WriteLine(number);
            }

            Console.WriteLine();
            Console.WriteLine("binarySearch");
            find = MyArray.BinarySearch(array, 10);
            Console.WriteLine(find);
            find = MyArray.BinarySearch(array, 30);
            Console.WriteLine(find);
            find = MyArray.BinarySearch(array, 40);
            Console.WriteLine(find);
            find = MyArray.BinarySearch(array, 20);
            Console.WriteLine(find);
            find = MyArray.BinarySearch(array, -50);
            Console.WriteLine(find);
        }
    }
}

3. 인터페이스를 이용하여 CompareTo를 재정의하라.

using System;

namespace ExerciseArray
{
    // 매개변수보다 더 작으면 음수
    // 매개변수와 같으면 0
    // 매개변수보다 더 크면 양수
    class MyClass : IComparable
    {
        public string name;
        public int number;

        // number 기준 비교
        //public int CompareTo(Object obj)
        //{
        //    MyClass temp = obj as MyClass;
        //    return number - temp.number;
        //}
        // name 기준 비교
        public int CompareTo(Object obj)
        {
            MyClass temp = obj as MyClass;
            return name.CompareTo(temp.name);
        }
        

        public override string ToString()
        {
            return $"name : {name} / number : {number} ";
        }

        public static void Sort(MyClass[] array)
        {
            for (int idx = 0; idx < array.Length - 1; idx++)
            {
                for (int innerIdx = 0; innerIdx < array.Length - 1 - idx; innerIdx++)
                {
                    if (array[innerIdx].CompareTo(array[innerIdx + 1]) == 1)
                    {
                        MyClass temp = array[innerIdx];
                        array[innerIdx] = array[innerIdx + 1];
                        array[innerIdx + 1] = temp;
                    }
                }
            }
        }

    }


    class Program
    {
        public static void Main()
        {
            var array = new MyClass[10];
            var rnd = new Random();

            for (var i = 0; i < array.Length; ++i)
            {
                int rndNum1 = rnd.Next(0, 999);
                int rndNum2 = rnd.Next(0, 999);
                array[i] = new MyClass() { name = rndNum1.ToString(), number = rndNum2 };
            }

            MyClass.Sort(array);

            // number 기준으로 오름차순 정렬
            foreach (var obj in array)
            {
                Console.WriteLine(obj); // name: ??? / number: ???
            }
        }
    }
}