c# 함수 기초

2016. 2. 25. 18:36

https://blog.naver.com/nagne2011/220638119382

 

 class Program
    {
        static void Test1()
        {
            Console.WriteLine("hellow");
        }
        /// <summary>
        /// 3줄짜리 주석, 파라미터에 대한 내용을 적을 수 있다 (자동으로 작성된다)
        /// </summary>
        /// <param name="i"></param>
        /// <param name="j"></param>
        static void Test2(int i, int j)
        {
            Console.WriteLine("test2 : {0}, {1}", i,j);
        }
 
        /// <summary>
        /// 리턴 타입에 대한 설명도 쓸수있다.
        /// </summary>
        /// <param name="num"></param>
        /// <returns></returns>
        static int Test3(int num)
        {
 
            return num + 1;
        }
 
        static void Test4(ref int num)   
//struct타입인 int는 num을 복사하여 넘겨주는데, 이를 참조로 바꾸기 위해서
// ref를 붙여주면 연산이 간단해진다
        {
            Console.WriteLine("test4 : {0}", num);
            num++;
        }
        static void Test5(out int num)     //출력용으로 사용한다고 고정, 맴버변수에 항상 할당이 되어있어야한다
        {
            num = 10;
        }
 
        //연속된 함수 생성
        static void Work_01()
        {
            Console.WriteLine("주문 받겠습니다.");
        }
        static void Work_02()
        {
            Console.WriteLine("계산 하겠습니다.");
        }
        static void Work_03()
        {
            Console.WriteLine("기다려 주세요.");
        }
        static void Work_04()
        {
            Console.WriteLine("벨을 울림.");
        }
 
        static void Work_05(int i)
        {
            Console.WriteLine("테스트.");
        }
        
        //델리게이트 함수
        delegate void Work();
 
 
 
        static void Main(string[] args)
        {
            Test1();
 
            Test2(10, 5);
 
            Console.WriteLine("test3 : {0}", Test3(10));
 
            int test = 20;              //메모리상으로 할당이 된것만 넘겨줄 수 있다.
            Test4(ref test);            //참조로 넘겨주었으니 참조로 받는다
            Console.WriteLine("After test4 : {0}", test);
 
            int test3 = 0;
            Test5(out test3);                           //출력값을 10으로 고정
            Console.WriteLine("test5 : {0}", test3);    //값이 10으로 바뀐다
            
            
            //델리게이트
            //: 함수를 연속해서 계속쓸 수 있다
            Work work = new Work(Work_01);
            //함수 추가
            work += new Work(Work_02);
            work += new Work(Work_03);
            work += new Work(Work_04);
            //함수 시작
            work();
            //함수 제거
            work -= Work_03;
            work();
            //예외상황
            //work += new Work(Work_05); -> 다른것들(01~04)과 멤버변수가 일치하여야 한다
 
            myTest_01 mt1 = new myTest_01();
            myTest_01 mt2 = mt1;            //얕은 복사 : 참조만 넘겨준다
            myTest_01 mt3 = mt1.DeppCopy(); //깊은 복사 : 그대로 복하산다
            mt1.PrintNumber();      //10 20 30
            mt1.i = 20;
            mt1.PrintNumber();      //20 20 30
            mt2.PrintNumber();      //20 20 30
            mt3.PrintNumber();      //10 20 30
 
            mt1.WorkSet(Work_01);
            mt1.work();
            mt1.WorkSet(Work_02);
            mt1.work();
 
           // for (int i = 0; i < 100; ++i )
           // {
           //     myTest_01 forTest = new myTest_01();       //100번 찍히겠지만.. 매우 나쁜 코드다
           //     forTest.PrintNumber();
           // }
 
            //프로퍼티
            Console.WriteLine("K : {0}", mt1._k);
            mt1._k = 500;
            mt1.PrintNumber();
 
 
            //상속
            myTest_02 mt4 = new myTest_02();
            mt4.PrintNumber();
            mt4.printString();
 
            myTest_01 mt5 = mt4;
            //is, as
            if (mt5 is myTest_02)    //A is B, A가 원레 생성된 B인지, 즉 타입이 맞는지 확인한뒤 true, false로 리턴한다
            {
                Console.WriteLine("mt5는 Mytest_02입니다.");
            }
            if (mt5 is  myTest_01)   
            {
                Console.WriteLine("mt5는 Mytest_01입니다.");
            }
 
            //as가 더 자주 쓰인다//
            myTest_02 mt7 = mt5 as myTest_02; //만약 이게 맞으면, mt7은 null이 아니게 된다
                                              //= 변경 가능하면 값이 있고, 불가능하면 null
            if(mt7 != null)
            {
                Console.WriteLine("mt7는 myTest_02입니다.");
                mt7.printString();
            }
 
            Console.ReadLine();
        }
    }

 

 

추가. 상속

 class myTest_01
    {
        public Work2 work;
        public int i = 10;      //인수 하나하나 마다 모두 public이나 private등을 붙여주어야 한다
        private int j = 20;     //인수에 바로 값을 대입할 수 있다
        int k = 30;             //아무것도 안붙이면 'private'로 인식한다
 
        //프로퍼티 : 겟셋을 쉽게 만들수 있게 해준다
        public int _k
        {
            get { return this.k; }
            set
            {
                if(value < 0)
                {
                    this.k = 0;
                }
                else if (value > 101)
                {
                    this.k = 100;
                }
                else
                {
                    this.k = value;
                }
            }
        }//겟셋 값을 한다
 
 
        //생성자와 소멸자도 만들 수 있다. 다만 이 경우에 public을 붙여주지 않으면 private로 생성된다..!
        public myTest_01()
        {
            Console.WriteLine("myTest_01 생성");
        }
        ~myTest_01()
        {
            //단, 소멸자는 '언제 소멸될 지 모른다'
            Console.WriteLine("myTest_01 소멸");
        }
        
        public void PrintNumber()
        {
            Console.WriteLine("i : {0},j : {1},k : {2}", i,j,k);
        }
        public myTest_01 DeppCopy()
        {
            myTest_01 result = new myTest_01();
           result.i = this.i;
           result.j = this.j;
           result.k = this.k;
 
           return result;
 
        }
 
        public void WorkSet(Work2 newWork)
        {
            work = newWork;
        }
 
        public void SetJ(int num)
        {
            j = num;
        }
 
    }

 

  //상속
    class myTest_02 : myTest_01 //무조건 public 상속
    {
        public void printString()
        {
            Console.WriteLine("MyTest_02 입니다.");
        }
    }