*์ด ๊ธ์ <์ด๊ฒ์ด C#์ด๋ค> ์ฑ ์ ๋ฐํ์ผ๋ก ๊ณต๋ถํ ๊ธ์ ๋๋ค.
1. ๊ฐ์ ์ํ ํธ์ถ (Call by value)
ํจ์์ ๋ฉ์๋๋ฅผ ํธ์ถํ ๋, ํ์ํ ๊ฐ๋ค์ ์ ๋ฌํด์ฃผ๊ธฐ ์ํด ๋งค๊ฐ๋ณ์์ ๊ฐ์ ๋ฃ์ด ์ ๋ฌํด ์ค๋ค.
- ๊ฐ ํ์(Value type)์ ๋งค๊ฐ ๋ณ์๋ก ์ ๋ฌ ์์ ํด๋น ์ธ์์ ๊ฐ์ ๋ณต์ฌํด์ ์ ๋ฌ
- ํจ์์ ๋ฉ์๋์์ ๊ฐ์ ๋ฆฌํดํ ๋๋ ๋ง์ฐฌ๊ฐ์ง
- ์ด๊ฒ์ ๊ฐ์ ์ํ ํธ์ถ(Call by value)์ด๋ผ๊ณ ํจ
๋ ๋งค๊ฐ ๋ณ์๋ฅผ ๋ฐ์์ ์๋ก ๊ฐ์ ๋ฐ๊พธ๋ Swap() ํจ์์์ ์ด๋ฐ ์์๊ฐ ์์ฃผ ๋์จ๋ค.
static void Swap(int x, int y)
{
int temp = x;
x = y;
y = temp;
}
๊ทธ๋ฆฌ๊ณ ๋ค์๊ณผ ๊ฐ์ด ์ฌ์ฉ์ ํด ๋ณธ๋ค.
static void Main(string[] args)
{
int x = 3;
int y = 5;
Swap(x, y);
Console.WriteLine($"x = {x}"); // x = 3
Console.WriteLine($"y = {y}"); // y = 5
}
๋ณ์ x์ y์ ๊ฐ์ ์๋ก ๋ฐ๋์ง ์์๋ค. ์๋ณธ์ ์ ๋ฌํ ๊ฒ ์๋, ๋ณต์ฌ๋ณธ์ ์ ๋ฌํ๊ธฐ ๋๋ฌธ์ด๋ค.
์ฆ, ์๋ณธ์ ์ ๋ฌํ๋ ๋ฐฉ๋ฒ์ด ํ์ํ๋ค.
2. ์ฐธ์กฐ์ ์ํ ํธ์ถ (Call by reference)
๋งค๊ฐ ๋ณ์๊ฐ ๋ณ์ ๋๋ ์์๋ก๋ถํฐ ๊ฐ์ ๋ณต์ฌํ๋ ๊ฐ์ ์ํ ํธ์ถ๊ณผ ๋ฌ๋ฆฌ, ์ฐธ์กฐ์ ์ํ ํธ์ถ์ ๋งค๊ฐ๋ณ์๊ฐ ๋ฉ์๋์ ๋๊ฒจ์ง ์๋ณธ ๋ณ์๋ฅผ ์ง์ ์ฐธ์กฐํ๋ค. ๊ทธ๋ ๋ค๋ฉด, ์ด๋ป๊ฒ ์ฌ์ฉํ๋ ๊ฒ์ผ๊น?
ref ํค์๋
Swap() ํจ์๋ฅผ ๋ค์ ์์ฑํด๋ณด์.
public static void Swap(ref int x, ref int y)
{
int temp = x;
x = y;
y = temp;
}
๋งค๊ฐ ๋ณ์์ ref ๋ผ๋ ํค์๋๊ฐ ๋ถ์๋ค. ๋งค๊ฐ ๋ณ์๊ฐ ๋๊ฒจ๋ฐ์ ์๋ณธ ๋ณ์์ ์ง์ ์ ์ผ๋ก ์ฐธ์กฐํ๊ฒ ๋ค๋ ์๋ฏธ๋ค.
๊ทธ๋ฆฌ๊ณ ๋ค์ Swap() ํจ์๋ฅผ ์ฌ์ฉํด๋ณธ๋ค.
static void Main(string[] args)
{
int x = 3;
int y = 5;
Swap(ref x, ref y);
Console.WriteLine($"x = {x}"); // x = 5
Console.WriteLine($"y = {y}"); // y = 3
}
์๋ณธ ๋ณ์์ ์ ๊ทผํ์ฌ Swap() ํจ์๊ฐ ์ ๋๋ก ๋์ํ๋ ๊ฒ์ ๋ณผ ์ ์๋ค.
์ฐธ์กฐ ๋ฆฌํด
๊ฐ ํ์์ด๋ผ๋ฉด ๋ฉ์๋์ ๋ฆฌํด ๊ฒฐ๊ณผ ๋ํ ๋ณต์ฌ๋์ด ๋ฐํ๋๋ ํ์์ด๋ผ๊ณ ํ๋ค. ํ์ง๋ง, ๋ฉ์๋์ ๊ฒฐ๊ณผ๋ฅผ ์ฐธ์กฐ๋ก ๋ค๋ฃจ๊ณ ์ถ์ ๋๊ฐ ์์ ์ ์๋ค. ref ํ์ ์๋ฅผ ์ด์ฉํด์ ๋ฉ์๋๋ฅผ ์ ์ธํ๊ณ , return ๋ฌธ์ด ๋ฐํํ๋ ๋ณ์ ์์๋ ref ํค์๋๋ฅผ ๋ช ์ํด์ผ ํ๋ค.
class Monster
{
int hp = 100;
public ref int Function() // ๋ฉ์๋ ์์ ref ํค์๋
{
...
return ref hp; // return ๋ฌธ ์์ ref ํค์๋ ๋ช
์
}
}
๋ง์ฝ ๊ฐ์ ๋ณต์ฌํ์ฌ ๋ฆฌํดํ๋ ํ์์ผ๋ก ์ฌ์ฉํ ๊ฒ์ด๋ผ๋ฉด, ํ์์ฒ๋ผ ์ฌ์ฉํ๋ฉด ๋๋ค.
Monster monster = new Monster();
int hp = monster.Function();
ํ์ง๋ง, ๋ฉ์๋๊ฐ ๋ฐํํ๋ ๊ฒฐ๊ณผ๋ฅผ ํธ์ถ์๊ฐ ์ฐธ์กฐ๋ก ๋๊ฒจ๋ฐ๊ณ ์ถ๋ค๋ฉด ๋ค์๊ณผ ๊ฐ์ด ์์ฑํด์ผ ํ๋ค.
Monster monster = new Monster();
ref int hp = ref monster.Function(); // ref ํค์๋ ๋ถ์ด๊ธฐ
// hp๋ ์ฐธ์กฐ ์ง์ญ ๋ณ์
๋ฉ์๋์ ํน์ฑ์, ๊ฐ์ ํ๋๋ง ๋ฆฌํดํ ์ ์๋ ํน์ฑ์ด ์๋ค.
(๋ฌผ๋ก ํํ(Tuple), ๋ฆฌ์คํธ(List)๊ฐ์ ๊ฑธ๋ก ์ฌ๋ฌ ๊ฐ ๋ฆฌํดํ ์๋ ์๋ค. ํ์ง๋ง ๊ทธ๊ฒ ๋ํ ์ด๋๊น์ง๋ ํด๋น ๊ฐ์ฒด ํ๋๋ง ๋ฆฌํดํ๋ ๊ฒ์ ๊ฐ๋ค.)
์ฐธ์กฐ๋ฅผ ์ด์ฉํ๊ฒ ๋๋ฉด, ์๋ณธ ๊ฐ์ ์ฌ๋ฌ ๊ฐ ๋ฐ์์์ ์์ ์ด ๊ฐ๋ฅํ๊ธฐ ๋๋ฌธ์ ๋ง์น ์ฌ๋ฌ ๊ฐ์ ๊ฐ์ ๋ฆฌํดํ๋ ๊ฒ ๊ฐ์ ํจ๊ณผ๋ฅผ ๋ณผ ์ ์๋ค. ์ด๋ฐ ์ ์ ์ด์ฉํ๋ฉด ์ฝ๋ ์์ฑ ์ ๋ ์ ์ฉํ๊ฒ ์์ฉํ ๊ฒ์ด๋ค.
out ํค์๋
ref ํค์๋๋ ๋ฉ์๋ ๋ด๋ถ์์ ref ๋งค๊ฐ๋ณ์์ ๊ฐ์ ํ ๋นํ์ง ์์๋ ์ปดํ์ผ ์ค๋ฅ๋ฅผ ๋ฐ์์ํค์ง ์๋๋ค.
์์๋ฅผ ๋ค๊ธฐ ์ํด, ๋๋์ ๋ฉ์๋๋ฅผ ๋ง๋ค์ด์ ๋ชซ(quotient)๊ณผ ๋๋จธ์ง(remainder)๋ฅผ ์ฐธ์กฐ๋ก ๋ฐํํ๋ ๊ฑธ ๋ณด์.
static void Divide(int a, int b, ref int quotient, ref int remainder)
{
// ref๋ก ์ ์ธ๋ ๋งค๊ฐ๋ณ์์ ๊ฐ์ ํ ๋นํ์ง ์์๋ ์ปดํ์ผ ์๋ฌ ๋ฐ์ํ์ง ์์
//quotient = a / b;
//remainder = a % b;
}
static void Main(string[] args)
{
int a = 20;
int b = 3;
int c = 1;
int d = 2;
Divide(a, b, ref c, ref d);
Console.WriteLine("Quotient : {0}, Remainder : {1}", c, d);
}
์ด๋ฐ ๋ถ๋ถ์ ๋ง์ฝ ํ๋ก๊ทธ๋๋จธ๊ฐ ์ค์ํ์ฌ ๊ฐ์ ํ ๋นํ์ง ์๋๋ค๋ฉด, ์ค๋ฅ๋ ๋ฐ์ํ์ง ์๋ ๋ฐํ์ ์๋ฌ์ด๊ธฐ ๋๋ฌธ์ ๋๋ฒ๊น ํ๊ธฐ๊ฐ ์ด๋ ค์์ง๋ค. out ํค์๋๋ ์์ ๊ฐ์ ๋ฌธ์ ๋ฅผ ๋ฐฉ์งํ ์ ์๊ฒ ๋ฉ์๋ ๋ด๋ถ์์ ๋งค๊ฐ๋ณ์์ ๊ฐ์ ํ ๋นํ์ง ์๋๋ค๋ฉด ์ปดํ์ผ ์ค๋ฅ๋ฅผ ๋ฐ์์ํจ๋ค.
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;
int c;
int d;
Divide(a, b, out c, out d);
Console.WriteLine("Quotient : {0}, Remainder : {1}", c, d);
}
์ฆ, ๋ง์น ์ธํฐํ์ด์ค๋ ์ถ์ํด๋์ค์ ์ถ์ ํจ์๊ฐ ์ค๋ฒ๋ผ์ด๋ฉ์ ๊ฐ์ ๋ก ํ๋ ๊ฒ์ฒ๋ผ ํ๋ก๊ทธ๋๋จธ์๊ฒ ์๋ ค์ฃผ๋ ๊ฒ์ด๋ค.
๋ ํ๋์ ์ฌ์ค์ ref ํค์๋๋ก๋ ์ด๊ธฐํํ์ง ์์ ์ง์ญ ๋ณ์๋ฅผ ๋งค๊ฐ ๋ณ์๋ก ๋๊ฒจ์ฃผ๋ฉด ์ค๋ฅ๊ฐ ๋์ง๋ง, out ํค์๋๋ ์ด๊ธฐํํ์ง ์์ ์ง์ญ ๋ณ์๋ฅผ ๋งค๊ฐ ๋ณ์๋ก ๋๊ฒจ์ค๋ ์ค๋ฅ๊ฐ ๋์ง ์๋๋ค. ์ด์ฐจํผ ํด๋น ๋ฉ์๋ ๋ด๋ถ์์ ๊ฐ์ ๋ก ์ด๊ธฐํ๋ฅผ ํ๊ธฐ ๋๋ฌธ์ด๋ค.
out ํค์๋๋ ์ฌ์ค ๋ค์๊ณผ ๊ฐ์ด ๋ฉ์๋๋ฅผ ํธ์ถํ ๋, ๋งค๊ฐ๋ณ์ ๋ชฉ๋ก ์์์ ์ฆ์์ผ๋ก ์ ์ธํด๋ ๋๋ค.
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);
Console.WriteLine("Quotient : {0}, Remainder : {1}", c, d);
}
'๐ฏ๏ธLanguage > C#' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[C#] ์์ ๋ณต์ฌ(Shallow Copy)์ ๊น์ ๋ณต์ฌ(Deep Copy) + ICloneable ์ธํฐํ์ด์ค (0) | 2022.03.18 |
---|---|
[C#] ๊ฐ๋ณ ์ธ์, ๋ช ๋ช ๋ ๋งค๊ฐ๋ณ์, ๋ํดํธ ๋งค๊ฐ๋ณ์ + ๋ก์ปฌ ํจ์ (0) | 2022.03.18 |
[C#] switch ๋ฌธ๊ณผ when ์ , ๊ทธ๋ฆฌ๊ณ switch ์ (0) | 2022.03.13 |
[C#] TryParse() VS Parse() (0) | 2022.03.13 |
[C#] Null๊ณผ ๊ด๋ จ๋ ์ฐ์ฐ์๋ค(?, [ ]?, ??) (0) | 2022.03.13 |