# 연산자와 표현식

아래는 연산자와 그 설명을 마크다운 표로 정리한 것이다.

| **연산자**           | **설명**                                         | **예시**                         | **수식 (LaTex)**                               |
| ----------------- | ---------------------------------------------- | ------------------------------ | -------------------------------------------- |
| **덧셈 (`+`)**      | 두 피연산자의 값을 더함                                  | `a + b`                        | $c = a + b$                                  |
| **뺄셈 (`-`)**      | 첫 번째 피연산자에서 두 번째 피연산자의 값을 뺌                    | `a - b`                        | $c = a - b$                                  |
| **곱셈 (`*`)**      | 두 피연산자를 곱함                                     | `a * b`                        | $c = a \times b$                             |
| **나눗셈 (`/`)**     | 첫 번째 피연산자를 두 번째 피연산자로 나눔                       | `a / b`                        | $c = \frac{a}{b}$                            |
| **몫 나누기 (`~/`)**  | 나눗셈의 결과에서 소수점을 버리고 정수 부분만 반환                   | `a ~/ b`                       | $c = \left\lfloor \frac{a}{b} \right\rfloor$ |
| **나머지 (`%`)**     | 첫 번째 피연산자를 두 번째 피연산자로 나눈 나머지를 반환               | `a % b`                        | $c = a \mod b$                               |
| **동등 (`==`)**     | 두 값이 같으면 `true`, 그렇지 않으면 `false`               | `a == b`                       | $a == b \Rightarrow \text{true 또는 false}$    |
| **같지 않음 (`!=`)**  | 두 값이 같지 않으면 `true`, 그렇지 않으면 `false`            | `a != b`                       | $a \neq b \Rightarrow \text{true 또는 false}$  |
| **크다 (`>`)**      | 첫 번째 피연산자가 두 번째 피연산자보다 크면 `true`               | `a > b`                        | $a > b \Rightarrow \text{true 또는 false}$     |
| **작다 (`<`)**      | 첫 번째 피연산자가 두 번째 피연산자보다 작으면 `true`              | `a < b`                        | $a < b \Rightarrow \text{true 또는 false}$     |
| **크거나 같음 (`>=`)** | 첫 번째 피연산자가 두 번째 피연산자보다 크거나 같으면 `true`          | `a >= b`                       | $a \geq b \Rightarrow \text{true 또는 false}$  |
| **작거나 같음 (`<=`)** | 첫 번째 피연산자가 두 번째 피연산자보다 작거나 같으면 `true`          | `a <= b`                       | $a \leq b \Rightarrow \text{true 또는 false}$  |
| **논리 AND (`&&`)** | 두 조건이 모두 `true`일 때만 `true` 반환                  | `a && b`                       | $a \land b \Rightarrow \text{true 또는 false}$ |
| \*\*논리 OR (\`     | \`)\*\*                                        | 두 조건 중 하나라도 `true`이면 `true` 반환 | \`a                                          |
| **논리 NOT (`!`)**  | 조건을 부정하여 `true`를 `false`로, `false`를 `true`로 변환 | `!a`                           | $\neg a \Rightarrow \text{true 또는 false}$    |
| **비트 AND (`&`)**  | 두 피연산자의 비트가 모두 1일 때만 1을 반환                     | `a & b`                        | $a & b$                                      |
| \*\*비트 OR (\`     | \`)\*\*                                        | 두 피연산자의 비트 중 하나라도 1이면 1을 반환    | \`a                                          |
| **비트 XOR (`^`)**  | 두 피연산자의 비트가 다르면 1을 반환                          | `a ^ b`                        | $a \oplus b$                                 |
| **비트 NOT (`~`)**  | 피연산자의 모든 비트를 반전함                               | `~a`                           | $\sim a$                                     |
| **기본 할당 (`=`)**   | 오른쪽의 값을 왼쪽 변수에 할당                              | `a = b`                        | $a = b$                                      |
| **덧셈 할당 (`+=`)**  | 왼쪽 변수에 오른쪽 값을 더한 후 결과를 다시 왼쪽 변수에 할당            | `a += b`                       | $a = a + b$                                  |
| **뺄셈 할당 (`-=`)**  | 왼쪽 변수에서 오른쪽 값을 뺀 후 결과를 다시 왼쪽 변수에 할당            | `a -= b`                       | $a = a - b$                                  |
| **곱셈 할당 (`*=`)**  | 왼쪽 변수에 오른쪽 값을 곱한 후 결과를 다시 왼쪽 변수에 할당            | `a *= b`                       | $a = a \times b$                             |
| **나눗셈 할당 (`/=`)** | 왼쪽 변수를 오른쪽 값으로 나눈 후 결과를 다시 왼쪽 변수에 할당           | `a /= b`                       | $a = \frac{a}{b}$                            |
| **몫 할당 (`~/=`)**  | 왼쪽 변수를 오른쪽 값으로 나눈 후 그 몫을 다시 왼쪽 변수에 할당          | `a ~/= b`                      | $a = \left\lfloor \frac{a}{b} \right\rfloor$ |
| **전위 증가 (`++a`)** | 변수의 값을 1 증가시킨 후 그 값을 반환                        | `++a`                          | $a = a + 1$                                  |
| **후위 증가 (`a++`)** | 변수의 현재 값을 반환한 후 그 값을 1 증가                      | `a++`                          | $a = a + 1$                                  |
| **전위 감소 (`--a`)** | 변수의 값을 1 감소시킨 후 그 값을 반환                        | `--a`                          | $a = a - 1$                                  |
| **후위 감소 (`a--`)** | 변수의 현재 값을 반환한 후 그 값을 1 감소                      | `a--`                          | $a = a - 1$                                  |

#### 산술 연산자

Dart에서 산술 연산자는 기본적인 수학 연산을 수행하는 데 사용된다. 이 연산자들은 대부분 다른 프로그래밍 언어들과 유사하게 동작하며, 일반적인 수식과 함께 사용할 수 있다.

* **덧셈(`+`)**: 두 피연산자의 값을 더한다.

  예: `a + b`

$$
c = a + b
$$

* **뺄셈(`-`)**: 첫 번째 피연산자에서 두 번째 피연산자의 값을 뺍니다.

  예: `a - b`

$$
c = a - b
$$

* **곱셈(`*`)**: 두 피연산자를 곱한다.

  예: `a * b`

$$
c = a \times b
$$

* **나눗셈(`/`)**: 첫 번째 피연산자를 두 번째 피연산자로 나눈다. 이 연산자는 결과를 실수로 반환한다.

  예: `a / b`

$$
c = \frac{a}{b}
$$

* **몫 나누기 (`~/`)**: 나눗셈의 결과에서 소수점을 버리고 정수 부분만 반환한다.

  예: `a ~/ b`

$$
c = \left\lfloor \frac{a}{b} \right\rfloor
$$

* **나머지(`%`)**: 첫 번째 피연산자를 두 번째 피연산자로 나눈 나머지를 반환한다.

  예: `a % b`

$$
c = a \mod b
$$

#### 관계 연산자

관계 연산자는 두 값 사이의 관계를 비교하는 데 사용된다. 이 연산자는 `true` 또는 `false` 값을 반환하며, 주로 조건문에서 사용된다.

* **동등(`==`)**: 두 값이 같으면 `true`, 그렇지 않으면 `false`를 반환한다.

  예: `a == b`

$$
a == b \quad \Rightarrow \quad \text{true 또는 false}
$$

* **같지 않음(`!=`)**: 두 값이 같지 않으면 `true`, 그렇지 않으면 `false`를 반환한다.

  예: `a != b`

$$
a \neq b \quad \Rightarrow \quad \text{true 또는 false}
$$

* **크다(`>`)**: 첫 번째 피연산자가 두 번째 피연산자보다 크면 `true`, 그렇지 않으면 `false`를 반환한다.

  예: `a > b`

$$
a > b \quad \Rightarrow \quad \text{true 또는 false}
$$

* **작다(`<`)**: 첫 번째 피연산자가 두 번째 피연산자보다 작으면 `true`, 그렇지 않으면 `false`를 반환한다.

  예: `a < b`

$$
a < b \quad \Rightarrow \quad \text{true 또는 false}
$$

* **크거나 같음(`>=`)**: 첫 번째 피연산자가 두 번째 피연산자보다 크거나 같으면 `true`, 그렇지 않으면 `false`를 반환한다.

  예: `a >= b`

$$
a \geq b \quad \Rightarrow \quad \text{true 또는 false}
$$

* **작거나 같음(`<=`)**: 첫 번째 피연산자가 두 번째 피연산자보다 작거나 같으면 `true`, 그렇지 않으면 `false`를 반환한다.

  예: `a <= b`

$$
a \leq b \quad \Rightarrow \quad \text{true 또는 false}
$$

#### 논리 연산자

논리 연산자는 조건문에서 두 개 이상의 조건을 결합하거나 부정할 때 사용된다. Dart에서 사용되는 주요 논리 연산자는 다음과 같다.

* **논리 AND(`&&`)**: 두 조건이 모두 `true`일 때만 `true`를 반환한다.

  예: `a && b`

$$
a \land b \quad \Rightarrow \quad \text{true 또는 false}
$$

이 연산은 주로 두 조건을 모두 만족해야 할 때 사용된다. 예를 들어, `a > 0 && b > 0`은 `a`와 `b`가 모두 0보다 클 때만 `true`이다.

* **논리 OR(`||`)**: 두 조건 중 하나라도 `true`이면 `true`를 반환한다.

  예: `a || b`

$$
a \lor b \quad \Rightarrow \quad \text{true 또는 false}
$$

이는 두 조건 중 하나만 만족해도 될 때 사용된다. 예를 들어, `a > 0 || b > 0`은 `a` 또는 `b` 중 하나만 0보다 커도 `true`를 반환한다.

* **논리 NOT(`!`)**: 조건을 부정하여, `true`를 `false`로, `false`를 `true`로 변환한다.

  예: `!a`

$$
eg a \quad \Rightarrow \quad \text{true 또는 false}
$$

이 연산은 주로 조건을 반대로 평가할 때 사용된다. 예를 들어, `!(a > 0)`은 `a`가 0보다 크지 않을 때 `true`를 반환한다.

#### 비트 연산자

비트 연산자는 피연산자들을 이진수로 변환한 후 각 비트를 기준으로 연산을 수행한다. Dart에서는 다음과 같은 비트 연산자를 제공한다.

* **비트 AND(`&`)**: 두 피연산자의 비트가 모두 1일 때만 1을 반환한다.

  예: `a & b`

$$
a & b
$$

이 연산은 두 수의 비트를 AND 연산하여 결과를 반환한다. 예를 들어, 6(`0110`) & 3(`0011`)은 `0010`이 되어 결과는 2이다.

* **비트 OR(`|`)**: 두 피연산자의 비트 중 하나라도 1이면 1을 반환한다.

  예: `a | b`

$$
a | b
$$

예를 들어, 6(`0110`) | 3(`0011`)은 `0111`이 되어 결과는 7이다.

* **비트 XOR(`^`)**: 두 피연산자의 비트가 다르면 1을 반환한다.

  예: `a ^ b`

$$
a \oplus b
$$

예를 들어, 6(`0110`) ^ 3(`0011`)은 `0101`이 되어 결과는 5이다.

* **비트 NOT(`~`)**: 피연산자의 모든 비트를 반전시킨다.

  예: `~a`

$$
\sim a
$$

예를 들어, 6(`0110`)을 반전하면 `1001`이 되어 결과는 -7이다. (Dart는 2의 보수를 사용하여 음수를 처리한다.)

#### 할당 연산자

할당 연산자는 변수에 값을 할당하는 데 사용된다. 가장 기본적인 할당 연산자는 `=`이며, 이를 사용해 변수에 값을 대입할 수 있다. Dart에서는 여러 복합 할당 연산자를 제공하여 할당과 동시에 다른 연산을 수행할 수 있다.

* **기본 할당(`=`)**: 오른쪽의 값을 왼쪽의 변수에 할당한다.

  예: `a = b`

  이 연산은 변수 `a`에 `b`의 값을 대입한다. 예를 들어, `a = 5`는 변수 `a`에 5를 할당한다.
* **덧셈 할당(`+=`)**: 왼쪽 변수에 오른쪽 값을 더한 후, 그 결과를 다시 왼쪽 변수에 할당한다.

  예: `a += b`

$$
a = a + b
$$

이는 `a = a + b`와 같은 의미이다. 예를 들어, `a += 3`은 변수 `a`에 3을 더한 값을 다시 `a`에 저장한다.

* **뺄셈 할당(`-=`)**: 왼쪽 변수에서 오른쪽 값을 뺀 후, 그 결과를 다시 왼쪽 변수에 할당한다.

  예: `a -= b`

$$
a = a - b
$$

이는 `a = a - b`와 같은 의미이다. 예를 들어, `a -= 2`는 변수 `a`에서 2를 뺀 값을 다시 `a`에 저장한다.

* **곱셈 할당(`*=`)**: 왼쪽 변수에 오른쪽 값을 곱한 후, 그 결과를 다시 왼쪽 변수에 할당한다.

  예: `a *= b`

$$
a = a \times b
$$

이는 `a = a \times b`와 같은 의미이다. 예를 들어, `a *= 2`는 변수 `a`에 2를 곱한 값을 다시 `a`에 저장한다.

* **나눗셈 할당(`/=`)**: 왼쪽 변수를 오른쪽 값으로 나눈 후, 그 결과를 다시 왼쪽 변수에 할당한다.

  예: `a /= b`

$$
a = \frac{a}{b}
$$

이는 `a = a / b`와 같은 의미이다. 예를 들어, `a /= 4`는 변수 `a`를 4로 나눈 값을 다시 `a`에 저장한다.

* **몫 할당(`~/=`)**: 왼쪽 변수를 오른쪽 값으로 나눈 후, 그 몫을 왼쪽 변수에 할당한다.

  예: `a ~/= b`

$$
a = \left\lfloor \frac{a}{b} \right\rfloor
$$

이는 `a = a ~/ b`와 같은 의미이다. 예를 들어, `a ~/= 3`은 변수 `a`를 3으로 나눈 몫을 다시 `a`에 저장한다.

#### 증감 연산자

증감 연산자는 변수의 값을 1씩 증가하거나 감소시키는 데 사용된다. Dart에서는 전위 및 후위 증감 연산자를 제공한다.

* **전위 증가(`++a`)**: 변수의 값을 먼저 1 증가시키고 나서, 증가된 값을 반환한다.

  예: `++a`

$$
a = a + 1
$$

이 연산자는 변수 `a`의 값을 1 증가시킨 후, 증가된 값을 사용한다.

* **후위 증가(`a++`)**: 변수의 현재 값을 반환하고 나서, 그 후에 1을 증가시킨다.

  예: `a++`

$$
a = a + 1
$$

이 연산자는 먼저 변수 `a`의 현재 값을 사용하고, 그 후에 `a`를 1 증가시킨다.

* **전위 감소(`--a`)**: 변수의 값을 먼저 1 감소시키고 나서, 감소된 값을 반환한다.

  예: `--a`

$$
a = a - 1
$$

이 연산자는 변수 `a`의 값을 1 감소시킨 후, 감소된 값을 사용한다.

* **후위 감소(`a--`)**: 변수의 현재 값을 반환하고 나서, 그 후에 1을 감소시킨다.

  예: `a--`

$$
a = a - 1
$$

이 연산자는 먼저 변수 `a`의 현재 값을 사용하고, 그 후에 `a`를 1 감소시킨다.
