16. 값, 참조에 의한 매개변수 전달, ref와 out의 차이

728x90

값에 의한 전달이 매개변수가 변수나 상수로부터 값을 복사하는 것과 달리,

참조에 의한 전달은 매개변수가 메소드에 넘겨진 원본 변수를 직접 참조한다.

<값에 의한 전달>

using System;
using System.Collections;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using static System.Console;

namespace Hello
{
    class MainApp
    {
        public static void Swap(int a, int b)
        {
            int temp = b;
            b = a;
            a = temp;
            WriteLine($"Swap메소드 내에서 a는 {a}, b는 {b}");
        }
        static void Main(string[] args)
        {
            int x = 7;
            int y = 5;
            WriteLine($"Main메소드 내에서 x는 {x}, y는 {y}");
            Swap(x,y);
            WriteLine($"Swap메소드 호출 뒤, Main메소드 내에서 x는 {x}, y는 {y}");

        }
    }
}

<출력 결과>

Main메소드 내에서 x는 7, y는 5
Swap메소드 내에서 a는 5, b는 7
Swap메소드 호출 뒤, Main메소드 내에서 x는 7, y는 5

위 Swap 함수에서 매개변수 a는 x가 가진 것과 똑같은 데이터를 갖고 있지만,

a와 x는 완전히 별개의 메모리 공간을 사용한다. b와 y의 관계도 마찬가지이다. (마치 아래 표와 같이)

b=5

a=7

y=5

x=7

출력 결과를 보면

호출이 끝난 후 x와 y의 값은 여전하다.

메소드가 매개 변수를 받아들일 때는 데이터의 '복사'가 이루어진다.

Swap() 메소드의 첫 번째 매개 변수 a는 x가 담고 있는 7을 복사해서 받고,

두번째 매개변수 b는 y가 담고 있는 5를 복사해서 받는다.

Swap() 메소드 안에서 아무리 두 매개 변수를 요리조리 요리해도

Main() 메소드 안에서 선언된 x와 y에는 영향이 없는 것이다.

이처럼 메소드를 호출할 때 데이터를 복사해서 매개변수에 넘기는 것을 "값에 의한 전달"이라고 부른다.

<참조에 의한 매개변수 전달>

Swap() 메소드가 이름값을 하도록,

즉 두 매개변수의 값을 제대로 교환할 수 있도록 하기 위해서는

매개 변수를 "참조에 의한 전달"로 넘기면 된다.

값에 의한 전달이 매개변수가 변수나 상수로부터 값을 복사하는 것과 달리,

참조에 의한 전달은 매개변수가 메소드에 넘겨진 원본 변수를 직접 참조한다.

따라서 메소드 안에서 매개 변수를 수정하면

이 매개변수가 참조하고 있는 원본 변수에 수정이 이루어진다.

C#에서 참조에 의한 매개 변수 전달은 아주 쉽다.

ref 키워드를 매개변수 앞에 붙이면 된다.

using System;
using System.Collections;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using static System.Console;

namespace Hello
{
    class MainApp
    {
        public static void Swap(ref int a, ref int b)
        {
            int temp = b;
            b = a;
            a = temp;
            WriteLine($"Swap메소드 내에서 a는 {a}, b는 {b}");
        }
        static void Main(string[] args)
        {
            int x = 7;
            int y = 5;
            WriteLine($"Main메소드 내에서 x는 {x}, y는 {y}");
            Swap(ref x,ref y);
            WriteLine($"Swap메소드 호출 뒤, Main메소드 내에서 x는 {x}, y는 {y}");

        }
    }
}

이제 a는 x를 참조하고,

b는 y를 참조하게 되었다.

<출력 결과>

Main메소드 내에서 x는 7, y는 5
Swap메소드 내에서 a는 5, b는 7
Swap메소드 호출 뒤, Main메소드 내에서 x는 5, y는 7

<메소드의 결과를 참조로 반환하기 ref> : 메소드의 결과를 참조로 반환하는 참조 반환값

참조 반환값을 이용하면 메소드의 호출자로 하여금 반환받은 결과를 참조로 다룰 수 있도록 한다.

<예제 1>

using System;
using System.Collections;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using static System.Console;

namespace Hello
{
    class Product
    {
        private int price = 100;
        public ref int GetPrice()
        {
            return ref price;
        }
        public void PrintPrice()
        {
            WriteLine($"Price:{price}");
        }
    }
    class MainApp
    {
        static void Main(string[] args)
        {
            Product carrot = new Product();
            ref int ref_local_price = ref carrot.GetPrice(); //ref_local_price를 수정하면 carrot.price의 내용도 바뀐다.
            int normal_local_price = carrot.GetPrice();

            carrot.PrintPrice();
            WriteLine($"Ref Local Price : {ref_local_price}");
            WriteLine($"Normal Local Price : {normal_local_price}");

            ref_local_price = 200;

            carrot.PrintPrice();
            WriteLine($"Ref Local Price : {ref_local_price}");
            WriteLine($"Normal Local Price :{normal_local_price}");
        }
    }
}

<출력>

Price:100
Ref Local Price : 100
Normal Local Price : 100
Price:200
Ref Local Price : 200
Normal Local Price :100

<연습1>

using System;
using System.Collections;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using static System.Console;

namespace Hello
{
    class Product
    {
        private int price = 100;
        public int Price
        {
            get { return price; }
            set { price = value; }
        }
        public int Sale()
        {
            price = (price / 2); 
            return price;
        }
        public void PrintPrice()
        {
            WriteLine(price);
        }
    }
    class MainApp
    {
        static void Main(string[] args)
        {
            Product carrot = new Product();
            int carrot_price = carrot.Price;
            WriteLine(carrot_price);//100
            carrot.Sale();
            carrot.PrintPrice(); //50
            carrot_price = carrot.Price;
            WriteLine(carrot_price);//50
        }
    }
}

<연습2>

using System;
using System.Collections;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using static System.Console;

namespace Hello
{
    class Product
    {
        private int price = 100;
        public ref int getPrice()
        {
            return ref price;
        }
        public int Sale()
        {
            price = (price / 2); 
            return price;
        }
        public void PrintPrice()
        {
            WriteLine(price);
        }
    }
    class MainApp
    {
        static void Main(string[] args)
        {
            Product carrot = new Product();
            int carrot_price1 = carrot.getPrice();
            WriteLine(carrot_price1);//100

            carrot.Sale();
            carrot.PrintPrice(); //50

            carrot_price1 = carrot.getPrice();
            WriteLine(carrot_price1);//50
            ref int carrot_price2 = ref carrot.getPrice();
            WriteLine(carrot_price2);//50

            carrot_price1 *= 2;
            carrot.PrintPrice(); //50
            carrot_price2 *= 2;
            carrot.PrintPrice(); //100
        }
    }
}

<출력 전용 매개변수 out >

대개의 경우 메소드의 결과는 하나만 충분하다. 다만, 두개 이상의 결과를 요구하는 특별한 메소드들이 있다.

나눗셈을 구현할 때는 제수와 피제수를 매개변수로 넘겨받고

결과는 몫과 나머지 두 개로 반환할 필요가 있다.

다음과 같이 ref 키워드를 이용해서 메소드를 구현하면 몫과 나머지를 한번에 반환할 수 있다.

using System;
using System.Collections;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using static System.Console;

namespace UsingOut
{
    class MainApp
    {
        static void Divide(int a, int b, ref int quotient, ref int remainder)
        {
            quotient = a / b;
            remainder = a % b;
        }
        static void Main(string[] args)
        {
            int a = 20;
            int b = 3;
            int c = 0;
            int d = 0;
            Divide(a,b, ref c, ref d);
            WriteLine($"a:{a},b:{b},a/b:{c},a%b:{d}");
        }
    }
}

출력 결과

a:20,b:3,a/b:6,a%b:2

using System;
using System.Collections;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using static System.Console;

namespace UsingOut
{
    class MainApp
    {
        static void Divide(int a, int b, out int quotient, out int remainder)
        {
            quotient = a / b;
            remainder = a % b;
        }
        static void Main(string[] args)
        {
            int a = 20;
            int b = 3;
            Divide(a,b,out int c, out int d);
            WriteLine($"a:{a},b:{b},a/b:{c},a%b:{d}");
        }
    }
}

출력결과

a:20,b:3,a/b:6,a%b:2

----

연습

----

using System;
using System.Collections;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using static System.Console;

namespace UsingOut
{
    class MainApp
    {
        static void Divide(int ori, int div, ref int mox, ref int namuge)
        {
            mox = ori / div;
            namuge = ori % div;
        }
        static void Main(string[] args)
        {
            int a = 20;
            int b = 6;
            int c = 0;
            int d = 0;
            Divide(a,b,ref c,ref d);
            WriteLine($"a는 {a}, b는 {b}, c는 {c}, d는 {d}");
        }
    }
}

출력 결과

a는 20, b는 6, c는 3, d는 2

위와 같이 ref만으로도 여러 개의 결과를 메소드에서 얻어올 수 있지만,

C#은 더 안전한 방법으로 똑같은 일을 가능케 해준다.

바로 out 키워드를 이용한 "출력 전용 매개변수"가 바로 그것이다.

out 키워드의 사용법은 간단하다.

메소드의 선언부와 호출부에 ref 키워드 대신에 out 키워드를 사용하는 것이 전부이다.

바로 아래와 같이 작성하면 된다!

using System;
using System.Collections;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using static System.Console;

namespace UsingOut
{
    class MainApp
    {
        static void Divide(int ori, int div, out int mox, out int namuge)
        {
            mox = ori / div;
            namuge = ori % div;
        }
        static void Main(string[] args)
        {
            int a = 20;
            int b = 6;
            int c = 0;
            int d = 0;
            Divide(a,b, out c, out d);
            WriteLine($"a는 {a}, b는 {b}, c는 {c}, d는 {d}");//a는 20, b는 6, c는 3, d는 2
        }
    }
}

언뜻 보면 키워드만 달라졌다 뿐이지 달라진 것이 없어보인다.

하지만 out에는 ref에는 없는 안전장치가 있다.

예를들어 ref 키워드를 이용해서 매개변수를 넘기는 경우

메소드가 해당 매개변수에 결과를 저장하지 않아도 컴파일러는 아무런 경고를 하지 않는다.

이와는 달리, out 키워드를 이용해서 매개변수를 넘길 때는

매소드가 해당 매개변수에 결과를 저장하지 않으면 컴파일러가 에러 메시지를 출력한다.

<빌드 오류: 아래의 코드는 실행이 안됨!>

using System;
using System.Collections;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using static System.Console;

namespace UsingOut
{
    class MainApp
    {
        static void Divide(int ori, int div, out int mox, out int namuge)
        {
            mox = ori / div;
            //namuge = ori % div;
        }
        static void Main(string[] args)
        {
            int a = 20;
            int b = 6;
            Divide(a,b, out int c, out int d);
            WriteLine($"a는 {a}, b는 {b}, c는 {c}, d는 {d}");//a는 20, b는 6, c는 3, d는 2
        }
    }
}

<빌드 오류가 안 날 뿐더러 d값이 0으로 나온다>

using System;
using System.Collections;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using static System.Console;

namespace UsingOut
{
    class MainApp
    {
        static void Divide(int ori, int div, out int mox, ref int namuge)
        {
            mox = ori / div;
            //namuge = ori % div;
        }
        static void Main(string[] args)
        {
            int a = 20;
            int b = 6;
            int d=0;
            Divide(a,b, out int c, ref d);
            WriteLine($"a는 {a}, b는 {b}, c는 {c}, d는 {d}");//a는 20, b는 6, c는 3, d는 0
        }
    }
}

그러므로 아래와 같이 작성하는 것이 무난하다.

출력 전용 매개변수는 사실 메소드를 호출하기 전에 미리 선언할 필요가 없다.

호출할 때 매개변수 목록 안에서 즉석으로 선언하면 되기 때문이다.

using System;
using System.Collections;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using static System.Console;

namespace UsingOut
{
    class MainApp
    {
        static void Divide(int ori, int div, out int mox, out int namuge)
        {
            mox = ori / div;
            namuge = ori % div;
        }
        static void Main(string[] args)
        {
            int a = 20;
            int b = 6;
            Divide(a,b, out int c, out int d);
            WriteLine($"a는 {a}, b는 {b}, c는 {c}, d는 {d}");//a는 20, b는 6, c는 3, d는 2
        }
    }
}

혹은 이렇게

using System;
using System.Collections;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using static System.Console;

namespace UsingOut
{
    class MainApp
    {
        static void Divide(int ori, int div, out int mox, out int namuge) 
        {
            mox = ori / div;
            namuge = ori % div;
        }
        static void Main(string[] args)
        {
            int a = 20;
            int b = 6;
            int c = 0;
            int d = 0;
            Divide(a, b, out c, out d);
            WriteLine($"a는 {a}, b는 {b}, c는 {c}, d는 {d}");//a는 20, b는 6, c는 3, d는 2
        }
    }
}

한편...

메소드를 호출하는 쪽에서는 초기화하지 않은 지역 변수를 메소드의 out 매개 변수로 넘길 수 있다.

컴파일러가 호출당하는 메소드에서 그 지역 변수를 할당할 것을 보장하기 때문이다.

이처럼 컴파일러를 통해 결과를 할당하지 않는 버그가 만들어질 가능성을 제거할 수 있다면

그 방법을 사용하는 것이 좋다.

런타임에 발생하는 버그는 컴파일 타임에 발생하는 버그보다 훨씬 잡기가 어렵기 때문이다.

(컴파일 에러는 어느 곳에 문제가 있는지 컴파일러가 정확하게 알려주지만,

런타임 버그는 프로그래머의 논리력으로 추적해야 한다.)

<메소드 오버로딩>

오버로딩 Overloading 이란 "과적하다"라는 뜻을 가지고 있다.

과적이란 트럭 따위에 원래의 탑재량을 넘겨 싣는 것을 말한다.

메소드 오버로딩은 하나의 메소드 이름에 여러 개의 구현을 올리는 것을 뜻한다.

using System;
using System.Collections;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using static System.Console;

namespace UsingOut
{
    class MainApp
    {
        static int Plus(int a, int b) 
        {
            return a + b;
        }
        static int Plus(int a, int b, int c)
        {
            return a + b + c;
        }
        static double Plus(double a, double b)
        {
            return a + b;
        }
        static double Plus(double a, double b, double c)
        {
            return a + b + c;
        }
        static void Main(string[] args)
        {
            int a = Plus(1, 2);
            WriteLine(a);
            WriteLine(Plus(1, 2, 3));
            WriteLine(Plus(1.1, 2.1));
            WriteLine(Plus(1.1, 2.1,3.1));
        }
    }
}

위 코드와 같이 오버로딩을 해놓으면 컴파일러가 메소드 호출 코드에 사용되는

매개변수의 수와 형식을 분석해서(오로지 매개변수만 분석한다. 반환 형식은 묻지도 따지지도 않는다.)

어떤 버전이 호출될지를 찾아준다.

실행할 메소드의 버전을 찾는 작업이 컴파일 타임에 이루어지므로 성능 저하는 걱정하지 않아도 된다.

메소드 오버로딩은 이름에 대한 고민을 줄여주는 동시에

코드를 일관성있게 유지해준다.

(일관성있는 코드는 메소드 작성자에게도 도움을 주지만, 메소드 사용자에게도 높은 생산성을 제공한다.)

예를 들어 System.Console 클래스의 WriteLine() 메소드는 모두 18개의 버전을 오버로딩하고 있지만

프로그래머는 버전을 의식하지 않고 자유롭게 이를 사용해왔다.

만약 오버로딩이 없었다면 WriteLine() 메소드는 가 구현에 따라 18개의 이름으로 나뉘었을 것이다.

<가변 개수의 인수 Params 키워드와 배열>

프로그래밍을 하다보면 그저 인수의 개수가 다르다는 이유만으로 똑같은 메소드를 여러가지 버전으로 오버로딩하고 싶을 때가 있다. 이런 경우를 위해 C#은 가변 개수의 인수라는 기능을 제공한다.

가변 개수의 인수란, 그 개수가 유연하게 변할 수 있는 인수를 말한다.

이것을 이용하면 다음과 같이 입력되는 모든 인수의 합을 구하는 Sum() 메소드를 오버로딩하지 않고도 구현할 수 있다.

int total = 0;

total = Sum(1,2);
total = Sum(1,2,3);
total = Sum(1,2,3,4,5,6,7,8,9,10);
//...

가변 개수의 인수는 params 키워드와 배열을 이용해서 선언한다.

다음은 가변 개수의 인수를 이용해서 모든 인수의 합을 구해 반환하는 Sum() 메소드의 구현이다.

이렇게 구현한 메소드는 앞에서 본 코드에서처럼 인수의 개수를 달리해서 호출할 수 있다.

using System;
using System.Collections;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using static System.Console;

namespace UsingOut
{
    class MainApp
    {
        static int Sum(params int[] args)
        {
            int sum = 0;
            for(int i=0; i<args.Length; i++)
            {
                if (i > 0) Write(", ");
                Write($"{args[i]}");
                sum += args[i];
            }
            WriteLine();
            return sum;
        }
        static void Main(string[] args)
        {
            int sum = Sum(3, 4, 5, 6, 7, 8, 9, 10);
            WriteLine($"Sum : {sum}");
        }
    }
}

출력값

3, 4, 5, 6, 7, 8, 9, 10
Sum : 52

메소드 오버로딩과 가변 개수의 인수는 활용성에서 차이가 있다.

메소드 오버로딩은 매개변수의 개수 뿐 아니라 형식이 다른 경우에 사용할 수 있다.

또한 매개변수의 개수가 유한하게 정해져 있다면 가변 개수의 인수보다는

메소드 오버로딩을 사용하는 것이 적절하다.

가변 개수의 인수는 형식은 같으나 인수의 개수만 유연하게 달라질 수 잇는 경우에 적합하다.

매개 변수의 개수가 유연하게 변할 때 -> 가변 개수의 인수

매개 변수의 개수가 유한하고, 형식을 달리 해야할 겨우 -> 메소드 오버로딩

<명명된 인수> : 가독성을 올리는 기법으로,

말 그대로 메소드를 호출할 때 인수의 이름에 근거해서 데이터를 할당할 수 있는 기능이다.

명명된 인수를 사용하기 위해 메소드 선언에 손댈 일은 전혀 없다.

메소드를 호출할 때만 인수의 이름 뒤에 콜론(:)을 붙인 뒤 그 뒤에 할당할 데이터를 넣어주면 된다.

명명된 인수는 더 많은 타이핑을 해야하므로 생산성 면에서는 떨어지나,

일단 명명된 인수를 이용해서 코드를 작성하면 가독성이 올라간다.(선택의 문제)

그러므로, 인수가 너무 많아 어느 매개변수에 어느 인수를 할당하고 있는지 분간이 어려운 경우에는 명명된 인수가 도움이 될 것이다.

using System;
using System.Collections;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using static System.Console;

namespace UsingOut
{
    class MainApp
    {
        static void PrintProfile(string name, string phone)
        {
            WriteLine($"Name: {name}, Phone: {phone}");
        }
        static void Main(string[] args)
        {
            PrintProfile(name:"박찬호",phone:"010-123-1234");
            PrintProfile(phone:"010-9876-5432", name: "박세리");
            PrintProfile("김연아", "010-987-654");
            PrintProfile("장미란", phone:"010-234-567");
        }
    }
}

<로컬 함수>

로컬 함수는 메소드 안에서 선언되고, 선언된 메소드 안에서만 사용되는 특별한 함수이다.

클래스의 멤버가 아니기 때문에 메소드가 아니라 함수라고 부른다.

선언 방법은 메소드와 다르지 않지만

로컬 함수는 자신이 존재하는 지역에 선언되어 있는 변수를 사용할 수 있다.

로컬 함수는 메소드 밖에서는 다시 쓸 일 없는 반복적인 작업을 하나의 이름 아래 묶어놓는 데 제격이다.

람다식과 더불어 프로그래머에게 코드를 간추릴 수 있는 또 하나의 옵션인 것이다.

class SoneClass
{
	public void SomeMethod() //메소드 선언
    {
    	int count = 0;
        SomeLocalFunction(1,2); //로컬 함수 호출
        SomeLocalFunction(3,4);
        
        void SomeLocalFunction(int a, int b) //로컬 함수 선언
        {
        	//Do Some Work
        	Write($"count : {++count}"); 
            //로컬 함수는 자신이 속한 메소드의 지역 변수를 사용할 수 있다.
		}
    }
}

<예제 프로그램>

using System;
using System.Collections;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using static System.Console;

namespace UsingOut
{
    class MainApp
    {
        static string ToLowerString(string input)
        {
            var arr = input.ToCharArray();//https://www.delftstack.com/ko/howto/csharp/csharp-convert-string-to-char/
            //var은 char[]로 변환된다
            //string str = "String";
            //char[] charArray = str.ToCharArray();
            for (int i=0; i<arr.Length; i++)
            {
                arr[i] = ToLowerChar(i);
            }
            char ToLowerChar(int i)
            {
                if (arr[i] < 65 || arr[i] > 90)//A~Z의 아스키값 : 65~99
                    return arr[i];
                else //a~z의 아스키값 : 97~122
                    return (char)(arr[i] + 32);
            }
            return new string(arr);
        }
        static void Main(string[] args)
        {
            WriteLine(ToLowerString("Hello!"));
            WriteLine(ToLowerString("Good Morning!"));
            WriteLine(ToLowerString("This is C#!"));
            string str = "String";
            char[] charArray = str.ToCharArray();
            WriteLine(charArray);
            WriteLine(charArray[0]);
        }
    }
}

<출력결과>

hello!
good morning!
this is c#!
String
S

using System;
using System.Collections;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using static System.Console;

namespace UsingOut
{
    class MainApp
    {
        static string ToLowerString(string input)
        {
            var arr = input.ToCharArray();
            for (int i = 0; i < arr.Length; i++)
            {
                arr[i] = ToLowerChar(i);
            }
            char ToLowerChar(int i) //로컬 함수 선언
            {
                if (arr[i] < 65 || arr[i] > 90) //A~Z의 아스키값 : 65~90, a~z의 아스키값 : 97~122
                    return arr[i]; //즉 대문자가 아니라면 그대로 
                else //대문자라면
                    return (char)(arr[i] + 32); //32를 더해서 대문자로 바꾸어준다.
            }
            return new string(arr);
        }
        static void Main(string[] args)
        {
            WriteLine(ToLowerString("Hello!"));
            WriteLine(ToLowerString("Good Morning!"));
            WriteLine(ToLowerString("This is C#."));
        }
    }
}

출력결과

hello!
good morning!
this is c#.

<이것이 C#이다 챕터 6 연습문제 1번>

using System;
using System.Collections;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using static System.Console;

namespace UsingOut
{
    class MainApp
    {
        static double Square(double arg)
        {
            double result = arg * arg;
            return result;
        }
        static void Main(string[] args)
        {
            Write("수를 입력하세요 : ");
            string input = ReadLine();
            double arg = Convert.ToDouble(input);
            WriteLine("결과 : {0}", Square(arg));
        }
    }
}

<이것이 C#이다 챕터 6 연습문제 2번>

using System;
using System.Collections;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using static System.Console;

namespace UsingOut
{
    class MainApp
    {
        static void Main(string[] args)
        {
            double mean = 0;
            Mean(1, 2, 3, 4, 5, out mean);
            WriteLine($"평균:{mean}");
        }
        public static void Mean(double a, double b, double c, double d, double e, out double mean)
        {
            mean = (a + b + c + d + e) / 5;
        }
    }
}

<이것이 C#이다 챕터6 연습문제 3번>

using System;
using System.Collections;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using static System.Console;

namespace UsingOut
{
    class MainApp
    {
        static void Main(string[] args)
        {
            int a = 3;
            int b = 4;
            int resultA = 0;

            Plus(a, b, out resultA);

            WriteLine("{0} + {1}={2}",a,b,resultA);

            double x = 2.4;
            double y = 3.1;
            double resultB = 0;

            Plus(x, y, out resultB); //오버로드가 필요한 메소드
            WriteLine("{0}+{1}={2}",x,y,resultB);
        }

        public static void Plus(int a, int b, out int c)
        {
            c = a + b;
        }
        public static void Plus(double a, double b, out double c)
        {
            c = a + b;
        }
    }
}

728x90

'C# > 이것이 C#이다' 카테고리의 다른 글

18. 객체의 삶과 죽음(생성자,종료자) + 생성자 오버로딩 (0)	2022.02.10
17. C#의 클래스 (0)	2022.02.10
15. 메소드로 코드 간추리기 + 재귀호출 함수짜기(피보나치 예제) (0)	2022.02.09
14. 입출력, 분기문 (0)	2022.02.08
13. null 병합 연산자 (0)	2022.02.08

'C# > 이것이 C#이다' 카테고리의 다른 글

티스토리툴바