1. 연산자란?
연산자란 특정 작업을 하기 위한 기호나 키워드를 의미합니다.
연산의 대상이 되는 것을 오퍼랜드라고 합니다.
오퍼랜드와 연산자로 구성된 것을 식이라고 합니다.
작업의 종류에 따라 산술 연산자, 할당 연산자, 논리 연산자, 비트 연산자, 시프트 연산자, 같음 연산자, 비교 연산자, 멤버 액세스 연산자, 데이터 형식 테스트 및 캐스트 연산자, ?: 연산자, => 연산자, 기본 연산자, 대리자 연산자, new 연산자, sizeof 연산자이 있습니다.
| 연산자 타입 | 연산자 | 예제 |
| 산술 연산자 | 증감 연산자 ++, -- 단항 더하기 빼기 연산자 +, - 곱하기 연산자 * 나누기 연산자 / 나머지 연산자 % 더하기 연산자 + 빼기 연산자 - |
a++; ++a; a--; --a; +a, -a b * c; d / f; g % h; i + j; k - l; |
| 할당 연산자 | 대입 연산자 = 복합 할당 +=, -=, *=, /=, %= |
a = b; c += d; e *= f; g %= h; |
| 논리 연산자 | 부정 연산자 ! AND 연산자 && OR 연산자 || |
!b1 b2 && b3; b4 || b5; |
| 비트 연산자 | 보수 연산자 ~ AND 연산자 & XOR 연산자 ^ OR 연산자 | |
~b1 b2 & b3; b4 ^ b5; b4 | b5; |
| 시프트 연산자 | 왼쪽 시프트 연산자 << 오른쪽 시프트 연산자 >> |
a << 4 b >> 1 |
| 같음 연산자 | 같음 연산자 == 같지 않음 연산자 != |
a == b c != d |
| 비교 연산자 | 보다 작음 연산자 < 보다 큼 연산자 > 작거나 같음 연산자 <= 크거나 같음 연산자 >= |
a < b c > d e <= f g >= h |
| 멤버 액세스 연산자 | 멤버 액세스 연산자 . 인덱서 연산자 [] 호출 연산자() |
using System.Collections.Generic; int[] a= new int[10]; a[0] = 1; Add(); |
| 데이터 형식 변환 및 검사 연산자 | is 연산자 as 연산자 캐스트 연산자 () typeof 연산자 |
E is T; E as T; (int)x; typeof(int); |
| 삼항 연산자 | 조건부 연산자 ?: | a ? b : c; |
| 람다 연산자 | 람다 연산자 => | square = x => x * x; |
| 기본 연산자 | default 연산자 | default(int); |
| 대리자 연산자 | delegate 연산자 | delegate (int a, int b) { return a + b; }; |
| new 연산자 | new 연산자 | string a = new string(); |
| sizeof 연산자 | sizeof 연산자 | sizeof(int); |
2. 연산자
2.1 산술 연산자
2.1.1 단항 연산자 (++, --)
단항 연산자는 1씩 증가하거나 1씩 감소합니다.
++는 1씩 증가하고, --는 1씩 감소합니다.
단항 연산자가 피연산자의 앞에 위치하면 전위 단항 연산자이고, 뒤에 위치하면 후위 단항 연산자입니다.
- 전위 단항 연산자 : ++x, --x의 결과 값이 연산 전의 x입니다. 그다음의 값은 연산 후입니다.
- 후위 단항 연산자 : x++, x--의 결과 값이 연산 후의 x입니다. 그다음의 값은 연산 후입니다.
| 예제 : 전위 단항 연산자 | 예제 : 후위 단항 연산자 |
| using UnityEngine; public class PrefixUnaryOperatorExample : MonoBehaviour { void Start() { int i = 1; Debug.Log(i.ToString()); // 출력 : 1 Debug.Log((++i).ToString()); // 출력 : 2 Debug.Log(i.ToString()); // 출력 : 2 float f = 2.3f; Debug.Log(f.ToString()); // 출력 : 2.3 Debug.Log((--f).ToString()); // 출력 : 1.3 Debug.Log(f.ToString()); // 출력 : 1.3 } } |
using UnityEngine; public class PostfixUnaryOperatorExample : MonoBehaviour { void Start() { int i = 1; Debug.Log(i.ToString()); // 출력 : 1 Debug.Log((i++).ToString()); // 출력 : 1 Debug.Log(i.ToString()); // 출력 : 2 float f = 2.3f; Debug.Log(f.ToString()); // 출력 : 2.3 Debug.Log((f--).ToString()); // 출력 : 2.3 Debug.Log(f.ToString()); // 출력 : 1.3 } } |
2.1.2 단항 더하기 빼기 연산자 (+, -)
- 단항 + 연산자 : 피연산자의 값을 그대로 반환합니다.
- 단항 - 연산자 : 피연산자의 값에 -1을 곱한 값을 반환합니다
using UnityEngine;
public class UnaryPlusMinusOperationExample : MonoBehaviour
{
void Start()
{
int i = 1234;
Debug.Log((+i).ToString()); // 출력 : 1234
Debug.Log((-i).ToString()); // 출력 : -1234
}
}
2.1.3 곱하기 연산자 *
곱하기입니다.
- 정수 * 정수 = 정수
- 정수 * 실수 또는 실수 * 정수 = 실수
- 실수 * 실수 = 실수
using UnityEngine;
public class MultiplicationOperatorExample : MonoBehaviour
{
void Start()
{
int a = 2, b = 3;
Debug.Log((a * b).ToString()); // 출력 : 6
int c = 4;
float d = 5.6f;
Debug.Log((c * d).ToString()); // 출력 : 22.4
float e = 7.8f, f = 9.0f;
Debug.Log((e * f).ToString()); // 출력 : 70.2
}
}
2.1.4 나누기 연산자 /
나누기입니다.
- 정수 / 정수 = 정수
- 정수 / 실수 또는 실수 / 정수 = 실수
- ((실수)정수 / (실수)정수) = 실수
- 실수 * 실수 = 실수
using UnityEngine;
public class DivisionOperatorExample : MonoBehaviour
{
void Start()
{
int a = 7, b = 3;
Debug.Log((a / b).ToString()); // 출력 : 2
Debug.Log(((float)a / (float)b).ToString()); // 출력 : 2.333333
int c = 7;
float d = 3.0f;
Debug.Log((c / d).ToString()); // 출력 : 2.333333
float e = 7f, f = 3f;
Debug.Log((e / f).ToString()); // 출력 : 2.333333
}
}
나누기 연산자는 곱하기 연산자보다 연산속도가 느립니다.
그래서 나누기를 대처해서 곱하기를 할 수 있을 경우 곱하기를 사용하는 것이 성능면에서 좋습니다.
| 나누기 | 곱하기 |
| x / 10 | x * 0.1f |
| x / 8 | x * 0.125f |
| x / 5 | x * 0.2f |
| x / 4 | x * 0.25f |
| x / 2 | x * 0.5f |
2.1.5 나머지 연산자 %
나머지입니다. 나누고 나머지를 계산합니다.
- 정수 나머지 : a % b = a - (a / b) * b
- 실수 나머지 : a % b = c
- c가 아닌 경우 c의 부호는 a와 동일
- c의 절대값은 |a| - n * |b| : n은 |a| / |b| 보다 작거나 같은 최대 정수. |a|, |b|는 a와 b의 절대값
using UnityEngine;
public class RemainderOperatorExample : MonoBehaviour
{
void Start()
{
int a = 7, b = 3;
Debug.Log((a % b).ToString()); // 출력 : 1
int c = 7, d = -3;
Debug.Log((c % d).ToString()); // 출력 : 1
int e = -7, f = 3;
Debug.Log((e % f).ToString()); // 출력 : -1
int g = -7, h = -3;
Debug.Log((g % h).ToString()); // 출력 : -1
float i = -5.1f, j = 3.1f;
Debug.Log((i % j).ToString()); // 출력 : -2
float k = 5.1f, l = -3.1f;
Debug.Log((k % l).ToString()); // 출력 : 2
}
}
2.1.6 더하기 연산자 +
더하기입니다.
using UnityEngine;
public class AdditionOperatorExample : MonoBehaviour
{
void Start()
{
int a = 7, b = 3;
Debug.Log((a + b).ToString()); // 출력 : 10
int c = 7;
float d = -3.1f;
Debug.Log((c + d).ToString()); // 출력 : 3.9
float e = -7f, f = 3.1f;
Debug.Log((e + f).ToString()); // 출력 : -3.9
}
}
2.1.7 빼기 연산자 +
빼기입니다.
using UnityEngine;
public class SubtractionOperatorExample : MonoBehaviour
{
void Start()
{
int a = 7, b = 3;
Debug.Log((a - b).ToString()); // 출력 : 4
int c = 7;
float d = -3.1f;
Debug.Log((c - d).ToString()); // 출력 : 10.1
float e = -7f, f = 3.1f;
Debug.Log((e - f).ToString()); // 출력 : -10.1
}
}
2.2 할당 연산자
2.2.1 대입 연산자
대입 연산자 =은 오른쪽 피연사자의 값을 왼쪽 피연산자가 제공하는 변수, 속성 또는 인덱서 요소에 할당합니다.
| 사용 방법 : 대입 연산자 |
| a = b; |
using UnityEngine;
public class AssignmentOperatorExample : MonoBehaviour
{
void Start()
{
int a = 7, b = 3; // 할당
int c = a + b; // 할당
Debug.Log(c.ToString()); // 출력 : 10
float[] ds = new float[] { 1.2f, 3.4f }; // 할당
Debug.Log(ds[0].ToString()); // 출력 : 1.2
}
}
2.2.2 복합 할당 연산자
복합 항당은 이진 연산자(+, -, *, /, %)를 사용하여, 산술 연산을 합니다.
x op = y는 x = x op y로 풀어서 계산됩니다.
| 복합 할당 연산자 |
| x op = y → x = x op y x += y → x = x + y x -= y → x = x - y x *= y → x = x* y x /= y → x = x / y x %= y → x = x % y |
using UnityEngine;
public class CompoundAssignmentExample : MonoBehaviour
{
void Start()
{
int a = 1;
a += 3;
Debug.Log(a.ToString()); // 출력 : 4
a -= 2;
Debug.Log(a.ToString()); // 출력 : 2
a *= 4;
Debug.Log(a.ToString()); // 출력 : 8
a /= 5;
Debug.Log(a.ToString()); // 출력 : 1
a %= 6;
Debug.Log(a.ToString()); // 출력 : 1
}
}
2.3 논리 연산자
2.3.1 논리 부정 연산자 !
논리 부정 연산자 !는 피연산자가 false이면 true로 바뀌고, true이면 false로 바뀝니다.
using UnityEngine;
public class LogicalNegationOperatorExample : MonoBehaviour
{
void Start()
{
bool b = false;
Debug.Log((!b).ToString()); // 출력 : True
}
}
2.3.2 논리 AND 연산자 &&
논리 AND 연산자는 피 연산자가 모두 true이면 true입니다. 나머지는 false입니다.
| 논리 AND 연산자 && |
| true && true → true false && true → false true && false → false false && false → false |
using UnityEngine;
public class ConditionalLogicalAndOperatorExample : MonoBehaviour
{
void Start()
{
bool bt1 = true, bt2 = true, bf1 = false, bf2 = false;
Debug.Log((bt1 && bt2).ToString()); // 출력 : True
Debug.Log((bt1 && bf1).ToString()); // 출력 : False
Debug.Log((bf1 && bf2).ToString()); // 출력 : False
}
}
2.3.3 논리 OR 연산자 ||
논리 OR 연산자는 피 연산자 중 하나라도 true이면 true입니다. 둘 다 false이면, false입니다.
| 논리 OR 연산자 || |
| true || true → true false || true → false true || false → false false || false → false |
using UnityEngine;
public class ConditionalLogicalOrOperatorExample : MonoBehaviour
{
void Start()
{
bool bt1 = true, bt2 = true, bf1 = false, bf2 = false;
Debug.Log((bt1 || bt2).ToString()); // 출력 : True
Debug.Log((bt1 || bf1).ToString()); // 출력 : False
Debug.Log((bf1 || bf2).ToString()); // 출력 : False
}
}
2.4 비트 연산자
2.4.0 진수 변환
비트 연산자를 사용하기 위해서는 진수를 알아야 합니다.
2진수, 10진수, 16진수는 일반적으로 C#에서 사용되는 진수입니다.
- 2진수 : 0, 1
- 10진수 : 0, 1, 2, 3, 4, 5, 6, 7, 8, 9
- 16진수 : 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F
2진수와 10진수, 16진수는 상호 변환이 가능합니다.
이 진수 변환은 10진수 숫자를 기본으로 합니다.
만약 2진수 ↔ 16진수로 변환하기 위해서는 10진수로 변환한 뒤 변환해야 합니다.
2진수 또는 16진수 → 10진수 : Convert.Int32(, base) 메서드를 사용.
10진수 → 2진수 또는 16진수 : Convert.ToString(intVal, base) 메서드사용.
Convert클래스를 사용하기 위해서는 using문을 사용하여 System을 선언해 주어야 합니다.
using UnityEngine;
using System;
public class BaseConverterExample : MonoBehaviour
{
void Start()
{
string base2 = "0100100010000100";
int base10 = Convert.ToInt32(base2, 2);
string base16 = Convert.ToString(base10, 16);
Debug.LogFormat("2진수 : {0}", base2); // 출력 : 2진수 : 0100100010000100
Debug.LogFormat("10진수 : {0}", base10); // 출력 : 10진수 : 18564
Debug.LogFormat("16진수 : {0}", base16); // 출력 : 16진수 : 4884
}
}
비트 연산자를 사용하기 위해서는 2진수를 사용해야 합니다.
10진수를 2진수(비트)로 변환 후 비트 연산자를 사용합니다.
2.4.1 보수 연산자 ~
비트가 1이면 0으로, 0이면 1로 반전시킵니다.
using UnityEngine;
using System;
public class BitwiseComplementOperatorExample : MonoBehaviour
{
void Start()
{
uint a = 0b_0010_1101_0100_1111_0000_1111_0000_1100; // 접두어 0b는 비트(2진수)라는 의미입니다.
uint b = ~a;
Debug.Log(Convert.ToString(b, toBase: 2)); // 출력 : 11010010101100001111000011110011
}
}
2.4.2 AND 연산자 &
두 비트가 모두 1일 때만 1을 반환하고, 다른 경우에는 0을 반환합니다.
using UnityEngine;
using System;
public class AndOperatorExample : MonoBehaviour
{
void Start()
{
uint a = 0b_1100_1010;
uint b = 0b_1101_1101;
uint c = a & b;
Debug.Log(Convert.ToString(c, toBase: 2)); // 출력 : 11001000
}
}
2.4.3 XOR 연산자 ^
두 비트가 같으면 0을 다르면 1을 반환합니다.
using UnityEngine;
using System;
public class ExclusiveOrOperatorExample : MonoBehaviour
{
void Start()
{
uint a = 0b_1100_1010;
uint b = 0b_1101_1101;
uint c = a ^ b;
Debug.Log(Convert.ToString(c, toBase: 2)); // 출력 : 10111
}
}
2.4.4 OR 연산자 |
두 비트 중 하나라도 1이면 1을 반환하고, 두 비트 모두 0이면 0을 반환합니다.
using UnityEngine;
using System;
public class OrOperatorExample : MonoBehaviour
{
void Start()
{
uint a = 0b_1100_1010;
uint b = 0b_1101_1101;
uint c = a | b;
Debug.Log(Convert.ToString(c, toBase: 2)); // 출력 : 11011111
}
}
2.5 시프트 연산자 >>, <<
시프트는 오른쪽이나 왼쪽으로 비트를 이동합니다.
그리고 범위를 벗어나는 비트는 버려지고, 새로 들어오는 비트는 0으로 채웁니다.
using UnityEngine;
using System;
public class ShiftOperatorExample : MonoBehaviour
{
void Start()
{
uint x1 = 0b_1100_1001_0000_0000_0000_0000_0001_0001;
Debug.Log($"원래 값: {Convert.ToString(x1, toBase: 2)}");
// 출력 : 원래 값: 11001001000000000000000000010001
uint y1 = x1 >> 2;
Debug.Log($"오른쪽 시프트: {Convert.ToString(y1, toBase: 2)}");
// 출력 : 오른쪽 시프트: 110010010000000000000000000100
uint y2 = x1 << 2; ;
Debug.Log($"왼쪽 시프트: {Convert.ToString(y2, toBase: 2),4}");
// 출력 : 왼쪽 시프트: 100100000000000000000001000100
}
}
2.6 같음 연산자 ==
같음 연산자 ==는 피연산자가 같으면 true를 반환하고, 그렇지 않으면 false를 반환합니다.
같지 않음 연산자 !=는 피연산자가 같지 않으면 true를 반환하고, 그렇지 않으면 false를 반환합니다.
| 같음 연산자 == |
| a == b a != b a != b → ! (a == b ) : 둘은 a와 b가 같지 않다면 이라는 의미입니다. |
같은 연산자와 같이 쓰이는 메서드가 object.Equals 메서드입니다.
같은 연산자를 사용하게 되면 임시적인 메모리를 사용하기 때문에 가버지 컬렉션이 발생합니다.
그래서 같은 연산자 대신에 object.Equals 메서드를 권장합니다.
| Equals 메서드 |
| a.Equals(b) !a.Equals(b) |
using UnityEngine;
public class EqualityOperatorExample : MonoBehaviour
{
void Start()
{
char c1 = 'a';
char c2 = 'A';
Debug.Log(c1 == c2); // 출력 : False
int a = 1 + 1 + 2 + 3;
int b = 6;
Debug.Log(a != b); // 출력 : True
Debug.Log(a.Equals(b)); // 출력 : False
Debug.Log(!a.Equals(b)); // 출력 : True
}
}
2.7 비교 연산자 <, > <=, >=
비교 연산자는 크기를 비교합니다.
- < : 보다 작음
- > : 보다 큼
- <= : 작거나 같음
- >= : 크거나 같음
using UnityEngine;
public class ComparisonOperatorsExample : MonoBehaviour
{
void Start()
{
int a = 1, b = 2, c = 2;
Debug.Log(a < b); // 출력 : True
Debug.Log(a > b); // 출력 : False
Debug.Log(b <= c); // 출력 : True
Debug.Log(b >= c); // 출력 : True
}
}
2.8 멤버 액세스 연산자
2.8.1 멤버 액세스 연산자 .
멤버 액세스 연산자는 . 을 사용하여 네임스페이스 또는 멤버의 메서드에 액세스 합니다.
2.8.1.1 using 지시문 중첩된 네임스페이스 액세스
| 네임스페이스 |
| using System.Collections.Generic; |
2.8.1.2 멤버 메서드 액세스
| 예제 : 멤버 메서드 |
| Debug.Log("Member"); |
2.8.2 인덱서 연산자 []
인덱서 연산자 []는 배열에서 사용합니다.
using UnityEngine;
public class IndexerOperatorExample : MonoBehaviour
{
void Start()
{
int[] i = new int[2];
i[0] = 1;
i[2] = 1;
}
}
2.8.3 호출 연산자()
호출 연산자()를 사용하여 메서드를 호출합니다.
using UnityEngine;
public class InvocationOperatorExample : MonoBehaviour
{
void Start()
{
DebugLog("호출 연산자"); // 호출연산자()
}
void DebugLog(string message)
{
Debug.Log(message);
}
}
2.9 데이터 형식 변환 및 검사 연산자
데이터 형식 변환 연산자는 as 연산자, 캐스트 연산자이고, 데이터 형식 검사 연산자는 is 연산자, typeof 연산자입니다.
2.9.1 is 연산자
is 연산자는 식 결과의 런타임 데이터 형식이 지정된 데이터 형식과 호환되는지 확인합니다
| is 연산자 |
| E is T : E는 값을 반환하는 식이고, T는 데이터 형식입니다. |
using UnityEngine;
public class IsOperatorExample : MonoBehaviour
{
void Start()
{
int i = 1;
object iBoxed = i;
Debug.Log((iBoxed is int).ToString()); // 출력 : True
Debug.Log((iBoxed is float).ToString()); // 출력 : False
}
}
2.9.2 as 연산자
as 연산자는 참조형 데이터 형식 간의 자료변환이 가능합니다.
형 변환이 가능하면 형 변환을 수행하고, 그렇지 않으면 null 값을 대입하는 연산자입니다.
| as 연산자 |
| E as T : E는 값을 반환하는 식이고, T는 데이터 형식입니다. |
using UnityEngine;
public class AsOperatorExample : MonoBehaviour
{
void Start()
{
object o = 1;
int? i = o as int?;
if (i == null)
Debug.Log("Null");
else
Debug.Log(i.ToString()); // 출력 : 1
}
}
2.9.3 캐스트 연산자 ()
(T)E 형태의 캐스트 식은 E 식의 결과를 T 데이터 형식으로 명시적으로 변환합니다.
| 캐스트 연산자 () |
| (T)E : E는 값을 반환하는 식이고, T는 데이터 형식입니다. |
using UnityEngine;
public class CastOperatorExample : MonoBehaviour
{
void Start()
{
float f = 1.2f;
int i = (int)f;
Debug.Log(i.ToString()); // 출력 : 1
}
}
2.9.4 typeof 연산자
typeof 연산자는 데이터 형식을 System.Type 인스턴스를 가져옵니다.
그리고, 변수의 System.Type을 가져올 수 있는데 이때 사용되는 메서드가 GetType 메서드입니다.
using UnityEngine;
public class TypeofOperatorExample : MonoBehaviour
{
void Start()
{
Debug.Log(typeof(int)); // 출력 : System.Int32
int i = 1;
Debug.Log(i.GetType()); // 출력 : System.Int32
}
}
2.10 조건부 연산자 ? :
조건부 연산자는 ? : 을 사용하여, 3항 연산자로 실행됩니다.
a ?b :c 형태로 되어 있으며, a는 조건을 계산하고, 조건이 참이면 b를 거짓이면 c를 실행합니다.
| 조건부 연산자 ? : |
| ①condition ? ②consequent : ③alternative |
- condition 식에서 true, false 계산 true이면
- consequent 식 실행 false이면
- alternative 식 실행
using UnityEngine;
public class ConditionalOperatorExample : MonoBehaviour
{
void Start()
{
int i = 1;
string s1 = (i >= 1) ? "True" : "False";
Debug.Log(s1); // 출력 : True
string s2 = (i < 1) ? "True" : "False";
Debug.Log(s2); // 출력 : False
}
}
2.11 람다 연산자 =>
람다식은 메서드를 하나의 식으로 표현한 것입니다.
람다 연사자는 매개변수 목록과 식을 구분하는 연산자로 사용됩니다.
| 선언 방식 |
| (매개변수-목록) => 식 |
아래 3개의 예제는 모두 같은 람다식입니다.
| delegate (int a, int b) { return a + b; } |
(int a, int b) => a + b; | (a, b) => a + b; |
using UnityEngine;
public class LambdaOperatorExample : MonoBehaviour
{
delegate int Method(int a, int b);
void Start()
{
Method Add = (a, b) => a + b;
Debug.Log(Add(1, 2)); // 출력 : 3
Method Minus = (a, b) =>
{
return a - b;
};
Debug.Log(Minus(4, 3)); // 출력 : 1
}
}
2.12 기본 연산자 default
default 연산자는 데이터 형식의 기본값을 생성합니다.
default 연산자에 대한 인수는 데이터 형식의 이름이어야 합니다.
| 기본 연산자 default |
| default(데이터-형식) |
using UnityEngine;
public class DefaultOperatorExample : MonoBehaviour
{
void Start()
{
Debug.Log(default(int)); // 출력 : 0
Debug.Log(default(bool)); // 출력 : False
}
}
2.13 대리자 연산자 delegate
delegate 연산자는 대리자 형식으로 변환될 수 있는 무명 메서드를 만듭니다
using UnityEngine;
public class LambdaOperatorExample : MonoBehaviour
{
delegate int Method(int a, int b);
void Start()
{
Method Add = (a, b) => a + b;
Debug.Log(Add(1, 2)); // 출력 : 3
Method Minus = (a, b) =>
{
return a - b;
};
Debug.Log(Minus(4, 3)); // 출력 : 1
}
}
2.14 new 연산자
new 연산자는 참조 형식의 인스턴스를 만듭니다.
using UnityEngine;
public class NewOperatorExample : MonoBehaviour
{
void Start()
{
var a = new int[3] { 10, 20, 30 };
GameObject go = new GameObject();
}
}
2.16 sizeof 연산자
sizeof 연산자는 지정된 형식의 변수에서 사용하는 바이트 수를 반환합니다.
using UnityEngine;
public class SizeOfOperatorExample : MonoBehaviour
{
void Start()
{
Debug.Log(sizeof(sbyte)); // 출력 : 1
Debug.Log(sizeof(byte)); // 출력 : 1
Debug.Log(sizeof(short)); // 출력 : 2
Debug.Log(sizeof(ushort)); // 출력 : 2
Debug.Log(sizeof(int)); // 출력 : 4
Debug.Log(sizeof(uint)); // 출력 : 4
Debug.Log(sizeof(long)); // 출력 : 8
Debug.Log(sizeof(ulong)); // 출력 : 8
Debug.Log(sizeof(char)); // 출력 : 2
Debug.Log(sizeof(float)); // 출력 : 4
Debug.Log(sizeof(double)); // 출력 : 8
Debug.Log(sizeof(decimal)); // 출력 : 16
Debug.Log(sizeof(bool)); // 출력 : 1
}
}
3. 연산자 우선순위
연사자들은 우선순위가 있습니다.
a + b * c 의 경우 b * c 가 먼저 계산되고, 그 결과값과 a가 더해집니다.
아래 표는 위에서부터 아래로 우선순위가 먼저입니다.
| 범주 또는 이름 | 연산자 |
| 주 | x.y, x?.y, x?[y], f(x), a[i], x++, x--, new, typeof, default, nameof, delegate, sizeof, x->y |
| 단항 | +x, -x, !x, ~x, ++x, --x, ^x, (T)x, await, &x, *x |
| 곱하기 | x * y, x / y, x % y |
| 더하기 | x + y, x – y |
| Shift | x << y, x >> y |
| 관계형 및 데이터 형식 테스트 | x < y, x > y, x <= y, x >= y, is, as |
| 같음 | x == y, x != y |
| 비트 AND | x & y |
| 비트 XOR | x ^ y |
| 비트 OR | x | y |
| 논리 AND | x && y |
| 논리 OR | x || y |
| 3항 연산자 | c ? t : f |
| 할당 및 람다 선언 | x = y, x += y, x -= y, x *= y, x /= y, x %= y, x &= y, x |= y, x ^= y, x <<= y, x >>= y, x ??= y, => |
그런데 우선순위가 다 외우는 것은 무리입니다.
그러나 우선순위가 헷갈리면 그냥 괄호()로 묶으면 됩니다.
괄호()가 가장 먼저 계산됩니다.
| 예제 : 괄호와 우선순위 |
| a + b * c → a + (b * c) |
'프로그램 > 유니티 C# 강좌' 카테고리의 다른 글
| [유니티 C# 강좌] 9. 반복문(Repetitive Statement) (1) | 2019.11.24 |
|---|---|
| [유니티 C# 강좌] 8. 문(Statement), 조건문(Conditional Statement) (0) | 2019.11.14 |
| [유니티 C# 강좌] 6. 형 변환(Type Conversions) (0) | 2019.11.12 |
| [유니티 C# 강좌] 5. 열거형(Enumeration) (0) | 2019.10.28 |
| [유니티 C# 강좌] 4. 문자열(String) (1) | 2019.10.27 |
