C++ 연산자 구현하기

소개

이 랩에서는 기본적인 수학 연산, 증가/감소, 관계 및 논리 연산자, 비트 연산, 복합 할당, 연산자 우선순위, 그리고 삼항 조건 연산자를 포함한 다양한 C++ 연산자를 구현하는 방법을 배우게 됩니다. 이러한 기본적인 연산자들은 C++ 프로그래밍에서 산술 연산을 수행하고, 비교를 수행하며, 데이터를 조작하는 데 필수적입니다. 일련의 실습을 통해, 이러한 연산자들을 효과적으로 활용하여 더 복잡하고 효율적인 C++ 애플리케이션을 구축하는 방법에 대한 확실한 이해를 얻게 될 것입니다.

기본 수학 연산 수행 (+, -, *, /, %)

이 단계에서는 C++ 에서 기본적인 수학 연산을 수행하는 방법을 배우게 됩니다. 수학 연산은 프로그래밍의 기본이며, 표준 산술 연산자를 사용하여 숫자 값을 조작할 수 있게 해줍니다.

WebIDE 를 열고 ~/project 디렉토리에 math_operations.cpp라는 새 파일을 생성합니다.

touch ~/project/math_operations.cpp

math_operations.cpp 파일에 다음 코드를 추가합니다.

#include <iostream>

int main() {
    // Declare variables for mathematical operations
    int a = 10;
    int b = 3;

    // Addition (+)
    int sum = a + b;
    std::cout << "Addition: " << a << " + " << b << " = " << sum << std::endl;

    // Subtraction (-)
    int difference = a - b;
    std::cout << "Subtraction: " << a << " - " << b << " = " << difference << std::endl;

    // Multiplication (*)
    int product = a * b;
    std::cout << "Multiplication: " << a << " * " << b << " = " << product << std::endl;

    // Division (/)
    int quotient = a / b;
    std::cout << "Division: " << a << " / " << b << " = " << quotient << std::endl;

    // Modulus (%) - Remainder of division
    int remainder = a % b;
    std::cout << "Modulus: " << a << " % " << b << " = " << remainder << std::endl;

    return 0;
}

프로그램을 컴파일하고 실행합니다.

g++ math_operations.cpp -o math_operations
./math_operations

예시 출력:

Addition: 10 + 3 = 13
Subtraction: 10 - 3 = 7
Multiplication: 10 * 3 = 30
Division: 10 / 3 = 3
Modulus: 10 % 3 = 1

수학 연산자를 자세히 살펴보겠습니다.

1. + (덧셈): 두 숫자를 더합니다. 예를 들어, 5 + 3은 8이 됩니다.
2. - (뺄셈): 첫 번째 숫자에서 두 번째 숫자를 뺍니다. 예를 들어, 10 - 4는 6이 됩니다.
3. * (곱셈): 두 숫자를 곱합니다. 예를 들어, 6 * 7은 42가 됩니다.
4. / (나눗셈): 첫 번째 숫자를 두 번째 숫자로 나눕니다. 두 숫자 모두 정수일 경우, 정수 나눗셈이 수행되어 소수 부분이 잘립니다. 예를 들어, 10 / 3은 3이 됩니다.
5. % (나머지): 나눗셈의 나머지를 반환합니다. 예를 들어, 10 % 3은 10 을 3 으로 나눈 나머지가 1 이므로 1이 됩니다.

몇 가지 중요한 사항:

• 정수 나눗셈은 소수 부분을 잘라냅니다. 예를 들어, 5 / 2는 2가 되며, 2.5가 아닙니다.
• 나머지 연산자는 정수 타입에서만 작동합니다. 부동 소수점 숫자 (예: float 또는 double) 에는 사용할 수 없습니다.
• 0 으로 나누는 것은 런타임 오류를 발생시키므로 항상 주의해야 합니다. 0 으로 나누려고 하면 프로그램이 충돌합니다.

전위 및 후위 증감 연산자 사용 (++i, i++)

이 단계에서는 C++ 의 증가 및 감소 연산자에 대해 배우게 됩니다. 이러한 연산자를 사용하면 변수의 값을 1 씩 증가 또는 감소시킬 수 있으며, 전위 증가와 후위 증가 사이에는 미묘한 차이가 있습니다.

WebIDE 를 열고 ~/project 디렉토리에 increment_decrement.cpp라는 새 파일을 생성합니다.

touch ~/project/increment_decrement.cpp

increment_decrement.cpp 파일에 다음 코드를 추가합니다.

#include <iostream>

int main() {
    // Pre-increment (++i)
    int a = 5;
    std::cout << "Original value of a: " << a << std::endl;

    // Pre-increment: increment happens before the value is used
    std::cout << "Pre-increment (++a): " << ++a << std::endl;
    std::cout << "Value after pre-increment: " << a << std::endl;

    // Post-increment (i++)
    int b = 5;
    std::cout << "\nOriginal value of b: " << b << std::endl;

    // Post-increment: increment happens after the value is used
    std::cout << "Post-increment (b++): " << b++ << std::endl;
    std::cout << "Value after post-increment: " << b << std::endl;

    // Decrement operators work similarly
    int c = 5;
    std::cout << "\nPre-decrement (--c): " << --c << std::endl;

    int d = 5;
    std::cout << "Post-decrement (d--): " << d-- << std::endl;
    std::cout << "Value after post-decrement: " << d << std::endl;

    return 0;
}

프로그램을 컴파일하고 실행합니다.

g++ increment_decrement.cpp -o increment_decrement
./increment_decrement

예시 출력:

Original value of a: 5
Pre-increment (++a): 6
Value after pre-increment: 6

Original value of b: 5
Post-increment (b++): 5
Value after post-increment: 6

Pre-decrement (--c): 4
Post-decrement (d--): 5
Value after post-decrement: 4

주요 차이점:

• 전위 증가 ++i: 표현식에서 사용하기 전에 값을 증가시킵니다. 코드 예제에서 ++a는 먼저 a를 6으로 증가시킨 다음, 6의 값을 cout 문에서 사용합니다.
• 후위 증가 i++: 표현식에서 먼저 현재 값을 사용한 다음 값을 증가시킵니다. 코드 예제에서 b++는 먼저 b의 현재 값인 5를 cout 문에서 사용한 다음, b를 6으로 증가시킵니다.

감소 연산자 --i 및 i--에도 동일한 원리가 적용됩니다. 여기서 --i는 먼저 감소시킨 다음 값을 사용하고, i--는 먼저 값을 사용한 다음 감소시킵니다.

중요 사항:

• 전위 증가는 표현식에서 사용하기 전에 값을 변경하므로 증가된 값을 즉시 사용할 수 있습니다.
• 후위 증가는 먼저 원래 값을 사용한 다음 증가시킵니다. 즉, 현재 문에서는 원래 값을 얻고 다음 문에서는 증가된 값을 얻습니다.
• 이러한 연산자는 루프 (예: for 루프) 및 변수의 값을 수정하면서 해당 값을 사용하려는 복잡한 표현식에서 일반적으로 사용됩니다.
• 이러한 연산자를 사용할 때, 특히 복잡한 표현식에서 의도한 동작을 얻기 위해 전위 또는 후위 버전을 사용해야 하는지 여부를 염두에 두는 것이 중요합니다.

관계 연산자 (<, >, ==, !=) 를 사용하여 값 비교하기

이 단계에서는 C++ 의 관계 연산자에 대해 배우게 됩니다. 이러한 연산자는 값을 비교하고 서로 다른 숫자 또는 변수 간의 관계를 결정하는 데 도움이 됩니다.

WebIDE 를 열고 ~/project 디렉토리에 relational_operators.cpp라는 새 파일을 생성합니다.

touch ~/project/relational_operators.cpp

relational_operators.cpp 파일에 다음 코드를 추가합니다.

#include <iostream>

int main() {
    int a = 10;
    int b = 5;
    int c = 10;

    // Less than (<)
    std::cout << "Less than (<):" << std::endl;
    std::cout << a << " < " << b << " is " << (a < b) << std::endl;
    std::cout << b << " < " << a << " is " << (b < a) << std::endl;

    // Greater than (>)
    std::cout << "\nGreater than (>):" << std::endl;
    std::cout << a << " > " << b << " is " << (a > b) << std::endl;
    std::cout << b << " > " << a << " is " << (b > a) << std::endl;

    // Equal to (==)
    std::cout << "\nEqual to (==):" << std::endl;
    std::cout << a << " == " << b << " is " << (a == b) << std::endl;
    std::cout << a << " == " << c << " is " << (a == c) << std::endl;

    // Not equal to (!=)
    std::cout << "\nNot equal to (!=):" << std::endl;
    std::cout << a << " != " << b << " is " << (a != b) << std::endl;
    std::cout << a << " != " << c << " is " << (a != c) << std::endl;

    return 0;
}

프로그램을 컴파일하고 실행합니다.

g++ relational_operators.cpp -o relational_operators
./relational_operators

예시 출력:

Less than (<):
10 < 5 is 0
5 < 10 is 1

Greater than (>):
10 > 5 is 1
5 > 10 is 0

Equal to (==):
10 == 5 is 0
10 == 10 is 1

Not equal to (!=):
10 != 5 is 1
10 != 10 is 0

관계 연산자에 대한 주요 사항:

• < (작음): 왼쪽 값이 오른쪽 값보다 작은지 확인합니다. 예를 들어, 5 < 10은 참 (1 반환) 이고, 10 < 5는 거짓 (0 반환) 입니다.
• > (큼): 왼쪽 값이 오른쪽 값보다 큰지 확인합니다. 예를 들어, 10 > 5는 참 (1 반환) 이고, 5 > 10은 거짓 (0 반환) 입니다.
• == (같음): 두 값이 정확히 같은지 확인합니다. 예를 들어, 5 == 5는 참 (1 반환) 이고, 5 == 6은 거짓 (0 반환) 입니다.
• != (같지 않음): 두 값이 같지 않은지 확인합니다. 예를 들어, 5 != 6은 참 (1 반환) 이고, 5 != 5는 거짓 (0 반환) 입니다.
• 이러한 연산자는 1 (참) 또는 0 (거짓) 을 반환합니다. C++ 에서 1은 참을 나타내고 0은 거짓을 나타냅니다. 이러한 값은 조건문에서 사용할 수 있습니다.

중요 사항:

• 관계 연산자는 조건문을 생성하는 데 필수적이며, 비교를 기반으로 프로그램이 결정을 내릴 수 있도록 합니다.
• 항상 부울 값을 반환하며, 이는 C++ 에서 정수로 표현됩니다 (참은 1, 거짓은 0).
• 이러한 연산자는 if 문, while 루프 및 for 루프에서 실행 흐름을 제어하는 데 일반적으로 사용됩니다.

논리 AND (&&) 및 OR (||) 연산자로 조건 결합하기

이 단계에서는 C++ 에서 논리 AND (&&) 및 OR (||) 연산자를 사용하여 여러 조건을 결합하는 방법을 배우게 됩니다. 이러한 연산자는 여러 조건을 평가하여 더 복잡한 조건문을 생성하는 데 도움이 됩니다.

WebIDE 를 열고 ~/project 디렉토리에 logical_operators.cpp라는 새 파일을 생성합니다.

touch ~/project/logical_operators.cpp

logical_operators.cpp 파일에 다음 코드를 추가합니다.

#include <iostream>

int main() {
    int x = 10;
    int y = 5;
    int z = 15;

    // Logical AND (&&) operator
    std::cout << "Logical AND (&&) operator:" << std::endl;

    // Both conditions must be true
    if (x > y && x < z) {
        std::cout << "x is greater than y AND less than z" << std::endl;
    }

    if (x > 20 && y < 10) {
        std::cout << "This will not be printed" << std::endl;
    }

    // Logical OR (||) operator
    std::cout << "\nLogical OR (||) operator:" << std::endl;

    // At least one condition must be true
    if (x > 20 || y < 10) {
        std::cout << "At least one condition is true" << std::endl;
    }

    if (x > 20 || z < 20) {
        std::cout << "Another true condition" << std::endl;
    }

    // Combining AND and OR
    std::cout << "\nCombining AND and OR:" << std::endl;

    if ((x > y && y < z) || x == 10) {
        std::cout << "Complex condition is true" << std::endl;
    }

    return 0;
}

프로그램을 컴파일하고 실행합니다.

g++ logical_operators.cpp -o logical_operators
./logical_operators

예시 출력:

Logical AND (&&) operator:
x is greater than y AND less than z

Logical OR (||) operator:
At least one condition is true
Another true condition

Combining AND and OR:
Complex condition is true

논리 연산자에 대한 주요 사항:

• && (AND): &&로 연결된 두 조건이 모두 참이어야 전체 표현식이 참이 됩니다. 조건 중 하나라도 거짓이면 전체 표현식은 거짓으로 평가됩니다. 코드에서 x > y && x < z는 x > y (10 > 5) 와 x < z (10 < 15) 가 모두 참이기 때문에 참입니다.
• || (OR): ||로 연결된 조건 중 적어도 하나는 참이어야 전체 표현식이 참이 됩니다. 모든 조건이 거짓이면 전체 표현식은 거짓으로 평가됩니다. 코드에서 x > 20 || y < 10은 y < 10 (5 < 10) 이 참이기 때문에 참입니다.
• 괄호를 사용하여 여러 조건을 결합하여 평가 순서를 제어할 수 있습니다. 이렇게 하면 복잡한 표현식을 더 쉽게 읽고 이해할 수 있습니다.
• 이러한 연산자는 조건문 내에서 복잡한 의사 결정 로직을 생성하는 데 매우 유용합니다.

중요 사항:

• 논리 연산자는 if 문, while 루프 및 기타 제어 흐름 구조에서 프로그램을 더 다재다능하게 만드는 데 자주 사용됩니다.
• 여러 기준을 동시에 확인할 수 있도록 하여 더 정교한 조건 검사를 생성하는 데 도움이 됩니다.
• 단락 평가 (Short-circuit evaluation):
  • &&의 경우, 첫 번째 조건이 거짓이면 두 번째 조건은 평가되지 않습니다. 두 번째 조건이 무엇이든 전체 표현식은 거짓이 되기 때문입니다. 이 최적화는 성능을 향상시킬 수 있습니다.
  • ||의 경우, 첫 번째 조건이 참이면 두 번째 조건은 평가되지 않습니다. 전체 표현식이 참이 되기 때문입니다.

이진수 조작을 위한 비트 연산 적용

이 단계에서는 C++ 의 비트 연산자에 대해 배우게 됩니다. 이러한 연산자는 정수의 이진 표현에서 직접 작동하여 개별 비트를 조작할 수 있습니다.

WebIDE 를 열고 ~/project 디렉토리에 bitwise_operations.cpp라는 새 파일을 생성합니다.

touch ~/project/bitwise_operations.cpp

bitwise_operations.cpp 파일에 다음 코드를 추가합니다.

#include <iostream>
#include <bitset>

int main() {
    // Binary representation of numbers
    unsigned int a = 5;   // 0101 in binary
    unsigned int b = 3;   // 0011 in binary

    // Bitwise AND (&)
    std::cout << "Bitwise AND (&):" << std::endl;
    std::cout << "a = " << std::bitset<4>(a) << " (5 in decimal)" << std::endl;
    std::cout << "b = " << std::bitset<4>(b) << " (3 in decimal)" << std::endl;
    unsigned int and_result = a & b;
    std::cout << "a & b = " << std::bitset<4>(and_result)
              << " (" << and_result << " in decimal)" << std::endl;

    // Bitwise OR (|)
    std::cout << "\nBitwise OR (|):" << std::endl;
    unsigned int or_result = a | b;
    std::cout << "a | b = " << std::bitset<4>(or_result)
              << " (" << or_result << " in decimal)" << std::endl;

    // Bitwise XOR (^)
    std::cout << "\nBitwise XOR (^):" << std::endl;
    unsigned int xor_result = a ^ b;
    std::cout << "a ^ b = " << std::bitset<4>(xor_result)
              << " (" << xor_result << " in decimal)" << std::endl;

    // Bitwise NOT (~)
    std::cout << "\nBitwise NOT (~):" << std::endl;
    unsigned int not_result = ~a;
    std::cout << "~a = " << std::bitset<32>(not_result)
              << " (" << not_result << " in decimal)" << std::endl;

    // Left shift (<<)
    std::cout << "\nLeft Shift (<<):" << std::endl;
    unsigned int left_shift = a << 2;
    std::cout << "a << 2 = " << std::bitset<8>(left_shift)
              << " (" << left_shift << " in decimal)" << std::endl;

    // Right shift (>>)
    std::cout << "\nRight Shift (>>):" << std::endl;
    unsigned int right_shift = a >> 1;
    std::cout << "a >> 1 = " << std::bitset<4>(right_shift)
              << " (" << right_shift << " in decimal)" << std::endl;

    return 0;
}

프로그램을 컴파일하고 실행합니다.

g++ bitwise_operations.cpp -o bitwise_operations
./bitwise_operations

예시 출력:

Bitwise AND (&):
a = 0101 (5 in decimal)
b = 0011 (3 in decimal)
a & b = 0001 (1 in decimal)

Bitwise OR (|):
a | b = 0111 (7 in decimal)

Bitwise XOR (^):
a ^ b = 0110 (6 in decimal)

Bitwise NOT (~):
~a = 11111111111111111111111111111010 (4294967290 in decimal)

Left Shift (<<):
a << 2 = 00010100 (20 in decimal)

Right Shift (>>):
a >> 1 = 0010 (2 in decimal)

비트 연산자에 대한 주요 사항:

• & (AND): 두 숫자의 해당 비트를 비교합니다. 두 비트가 모두 1 이면 결과 비트는 1 이고, 그렇지 않으면 0 입니다. 코드 예제에서 5 & 3 (이진수 0101 & 0011) 의 결과는 0001이며, 이는 10 진수 1입니다.
• | (OR): 두 숫자의 해당 비트를 비교합니다. 비트 중 적어도 하나가 1 이면 결과 비트는 1 이고, 그렇지 않으면 0 입니다. 예제에서 5 | 3 (이진수 0101 | 0011) 의 결과는 0111이며, 이는 10 진수 7입니다.
• ^ (XOR): 두 숫자의 해당 비트를 비교합니다. 비트가 다르면 결과 비트는 1 이고, 그렇지 않으면 0 입니다. 예제에서 5 ^ 3 (이진수 0101 ^ 0011) 의 결과는 0110이며, 이는 10 진수 6입니다.
• ~ (NOT): 숫자의 모든 비트를 반전시킵니다. 비트가 1 이면 0 이 되고, 0 이면 1 이 됩니다. 출력 ~a는 11111111111111111111111111111010인데, 이는 숫자가 32 비트 부호 없는 정수로 처리될 때의 결과의 이진 표현입니다.
• << (Left Shift): 숫자의 비트를 지정된 위치 수만큼 왼쪽으로 이동시킵니다. 각 시프트마다 숫자에 2 를 곱하는 효과가 있습니다. 예제에서 5 << 2 (이진수 0101 << 2) 는 비트를 이동시켜 010100이 되며, 이는 10 진수 20입니다.
• >> (Right Shift): 숫자의 비트를 지정된 위치 수만큼 오른쪽으로 이동시킵니다. 각 시프트마다 숫자를 2 로 나누는 효과가 있습니다. 예제에서 5 >> 1 (이진수 0101 >> 1) 는 비트를 이동시켜 0010이 되며, 이는 10 진수 2입니다.

중요 사항:

• 비트 연산은 정수의 이진 표현에서 직접 작동하여 낮은 수준의 조작과 최적화를 가능하게 합니다.
• 임베디드 시스템, 그래픽 프로그래밍 및 값 내에서 개별 비트를 설정, 지우거나 테스트해야 하는 시나리오에서 일반적으로 사용됩니다.
• 부호 있는 정수와 부호 없는 정수를 사용할 때는 주의해야 합니다. 오른쪽 시프트 동작이 다를 수 있습니다 (산술 시프트 대 논리 시프트).
• std::bitset을 사용하면 이러한 연산이 비트 수준에서 어떻게 작동하는지 시각화하는 데 도움이 됩니다.

복합 할당 연산자 (+=, -=, *=) 사용하기

이 단계에서는 C++ 의 복합 할당 연산자에 대해 배우게 됩니다. 이러한 연산자는 산술 연산과 할당을 결합하여 코드를 더 간결하고 읽기 쉽게 만듭니다.

WebIDE 를 열고 ~/project 디렉토리에 compound_operators.cpp라는 새 파일을 생성합니다.

touch ~/project/compound_operators.cpp

compound_operators.cpp 파일에 다음 코드를 추가합니다.

#include <iostream>

int main() {
    // Initialize variables
    int x = 10;
    int y = 5;

    // Addition assignment (+=)
    std::cout << "Addition Assignment (+=):" << std::endl;
    std::cout << "Initial x: " << x << std::endl;
    x += 3;  // Equivalent to x = x + 3
    std::cout << "x += 3: " << x << std::endl;

    // Subtraction assignment (-=)
    std::cout << "\nSubtraction Assignment (-=):" << std::endl;
    std::cout << "Initial y: " << y << std::endl;
    y -= 2;  // Equivalent to y = y - 2
    std::cout << "y -= 2: " << y << std::endl;

    // Multiplication assignment (*=)
    std::cout << "\nMultiplication Assignment (*=):" << std::endl;
    int z = 4;
    std::cout << "Initial z: " << z << std::endl;
    z *= 3;  // Equivalent to z = z * 3
    std::cout << "z *= 3: " << z << std::endl;

    // Division assignment (/=)
    std::cout << "\nDivision Assignment (/=):" << std::endl;
    int a = 15;
    std::cout << "Initial a: " << a << std::endl;
    a /= 3;  // Equivalent to a = a / 3
    std::cout << "a /= 3: " << a << std::endl;

    // Modulus assignment (%=)
    std::cout << "\nModulus Assignment (%=):" << std::endl;
    int b = 17;
    std::cout << "Initial b: " << b << std::endl;
    b %= 5;  // Equivalent to b = b % 5
    std::cout << "b %= 5: " << b << std::endl;

    return 0;
}

프로그램을 컴파일하고 실행합니다.

g++ compound_operators.cpp -o compound_operators
./compound_operators

예시 출력:

Addition Assignment (+=):
Initial x: 10
x += 3: 13

Subtraction Assignment (-=):
Initial y: 5
y -= 2: 3

Multiplication Assignment (*=):
Initial z: 4
z *= 3: 12

Division Assignment (/=):
Initial a: 15
a /= 3: 5

Modulus Assignment (%=):
Initial b: 17
b %= 5: 2

복합 할당 연산자에 대한 주요 사항:

• += (더하고 할당): 오른쪽 피연산자를 왼쪽 피연산자에 더하고 결과를 왼쪽 피연산자에 할당합니다. x += 3은 x = x + 3과 같습니다.
• -= (빼고 할당): 오른쪽 피연산자를 왼쪽 피연산자에서 빼고 결과를 왼쪽 피연산자에 할당합니다. y -= 2는 y = y - 2와 같습니다.
• *= (곱하고 할당): 왼쪽 피연산자에 오른쪽 피연산자를 곱하고 결과를 왼쪽 피연산자에 할당합니다. z *= 3은 z = z * 3과 같습니다.
• /= (나누고 할당): 왼쪽 피연산자를 오른쪽 피연산자로 나누고 결과를 왼쪽 피연산자에 할당합니다. a /= 3은 a = a / 3과 같습니다.
• %= (나머지 연산하고 할당): 왼쪽 피연산자를 오른쪽 피연산자로 나눈 나머지를 계산하고 결과를 왼쪽 피연산자에 할당합니다. b %= 5는 b = b % 5와 같습니다.

중요 사항:

• 복합 할당 연산자는 한 단계에서 연산과 할당을 결합하여 코드를 더 간결하고 읽기 쉽게 만듭니다.
• 모든 기본 산술 연산 (+, -, *, /, %) 과 함께 작동합니다.
• 타이핑을 줄이고 코드를 짧게 만들 수 있으며 잠재적으로 성능을 향상시킬 수 있습니다.

다중 연산자 사용 시 연산 순서 이해하기

이 단계에서는 C++ 의 연산 순서에 대해 배우게 됩니다. 이는 종종 PEMDAS (괄호, 지수, 곱셈과 나눗셈, 덧셈과 뺄셈) 약어로 기억됩니다. 이 순서를 이해하는 것은 올바른 수학적 표현식을 작성하는 데 매우 중요합니다.

WebIDE 를 열고 ~/project 디렉토리에 order_of_operations.cpp라는 새 파일을 생성합니다.

touch ~/project/order_of_operations.cpp

order_of_operations.cpp 파일에 다음 코드를 추가합니다.

#include <iostream>

int main() {
    // Basic order of operations demonstration
    int a = 10;
    int b = 5;
    int c = 3;

    // Multiplication before addition
    std::cout << "Multiplication before Addition:" << std::endl;
    int result1 = a + b * c;
    std::cout << "a + b * c = " << result1 << std::endl;

    // Parentheses change the order of operations
    std::cout << "\nParentheses change order:" << std::endl;
    int result2 = (a + b) * c;
    std::cout << "(a + b) * c = " << result2 << std::endl;

    // Complex expression with multiple operators
    std::cout << "\nComplex Expression:" << std::endl;
    int x = 4;
    int y = 2;
    int z = 3;

    int complex_result = x + y * z - (x / y);
    std::cout << "x + y * z - (x / y) = " << complex_result << std::endl;

    // Demonstrating precedence with increment and multiplication
    std::cout << "\nIncrement and Multiplication:" << std::endl;
    int m = 3;
    int n = 2;
    int precedence_result = m++ * n;
    std::cout << "m++ * n = " << precedence_result << std::endl;
    std::cout << "m after operation = " << m << std::endl;

    return 0;
}

프로그램을 컴파일하고 실행합니다.

g++ order_of_operations.cpp -o order_of_operations
./order_of_operations

예시 출력:

Multiplication before Addition:
a + b * c = 25

Parentheses change order:
(a + b) * c = 45

Complex Expression:
x + y * z - (x / y) = 8

Increment and Multiplication:
m++ * n = 6
m after operation = 4

연산 순서에 대한 주요 사항:

• 연산 순서, 즉 연산자 우선 순위는 표현식이 어떻게 평가되는지를 결정합니다. C++ 는 이를 위해 수학 규칙을 따릅니다.
• PEMDAS/BODMAS: 이는 순서를 기억하기 위한 일반적인 약어입니다.
  • Parentheses / Brackets: 괄호 또는 대괄호 안의 표현식이 먼저 평가됩니다.
  • Exponents / Orders: 지수 또는 차수 (예: 제곱근) 가 다음에 평가됩니다. C++ 에는 내장 지수 연산자가 없지만, 이 단계는 pow()와 같은 연산을 나타냅니다.
  • MD Multiplication and Division: 곱셈과 나눗셈은 동일한 우선 순위를 가지며 왼쪽에서 오른쪽으로 평가됩니다.
  • AS Addition and Subtraction: 덧셈과 뺄셈은 동일한 우선 순위를 가지며 왼쪽에서 오른쪽으로 평가됩니다.
• 코드에서 int result1 = a + b * c;는 10 + (5 * 3)으로 평가되어 10 + 15 = 25가 됩니다. 곱셈이 덧셈보다 우선 순위가 높기 때문입니다.
• 괄호는 기본 연산 순서를 무시할 수 있으며, 표현식 int result2 = (a + b) * c;는 (10 + 5) * 3으로 평가되어 15 * 3 = 45가 됩니다. 괄호 안의 표현식이 먼저 계산되기 때문입니다.
• 증가/감소 연산자는 때때로 혼란스러울 수 있는 특정 우선 순위 규칙을 갖습니다. 코드에서 사용된 후위 증가 연산자 m++의 경우, 곱셈 m * n에서 먼저 m의 원래 값이 사용되고 그 후에 변수 m이 증가합니다.
• 복잡한 표현식 x + y * z - (x / y)에서 곱셈과 나눗셈이 덧셈과 뺄셈보다 먼저 수행됩니다. 괄호는 정수 나눗셈 x / y가 먼저 수행되도록 합니다.
• 특히 복잡한 표현식이 있는 경우 항상 괄호를 사용하여 의도를 명확하게 하십시오. 이렇게 하면 코드를 더 쉽게 읽을 수 있을 뿐만 아니라 표현식이 의도한 대로 정확하게 평가되도록 할 수 있습니다.

중요 사항:

• PEMDAS/BODMAS는 표현식이 어떻게 평가될지 예측하는 데 도움이 되지만, C++ 에는 내장 지수 연산자가 없다는 점을 명심하십시오.
• 의심스러운 경우 괄호를 사용하여 순서를 명시적으로 정의하십시오. 이렇게 하면 코드를 더 명확하게 만들고 잘못된 우선 순위로 인해 발생할 수 있는 오류를 방지할 수 있습니다.
• 일부 연산자는 동일한 우선 순위를 가지며 왼쪽에서 오른쪽으로 평가됩니다. 예를 들어, a - b + c가 있는 경우 뺄셈이 덧셈보다 먼저 수행됩니다.
• 괄호를 사용하지 않고 단일 표현식에 여러 연산자를 결합할 때는 특히 주의하십시오. 연산자 우선 순위를 제대로 이해하지 못하면 미묘한 버그가 발생할 수 있습니다.

삼항 조건 연산자 연습하기

이 단계에서는 삼항 조건 연산자에 대해 배우게 됩니다. 이는 간단한 if-else 문을 한 줄로 작성하는 간결한 방법입니다. 이 연산자는 코드에서 결정을 내리는 간결한 방법을 제공합니다.

WebIDE 를 열고 ~/project 디렉토리에 ternary_operator.cpp라는 새 파일을 생성합니다.

touch ~/project/ternary_operator.cpp

ternary_operator.cpp 파일에 다음 코드를 추가합니다.

#include <iostream>

int main() {
    // Basic ternary operator syntax
    // condition ? value_if_true : value_if_false

    // Simple comparison
    int x = 10;
    int y = 5;

    // Determine the larger number
    int max_value = (x > y) ? x : y;
    std::cout << "Larger value: " << max_value << std::endl;

    // Check if a number is even or odd
    int number = 7;
    std::string result = (number % 2 == 0) ? "Even" : "Odd";
    std::cout << number << " is " << result << std::endl;

    // Nested ternary operator
    int a = 15;
    std::string category = (a < 10) ? "Small"
                         : (a < 20) ? "Medium"
                         : "Large";
    std::cout << "Category: " << category << std::endl;

    // Ternary operator with function calls
    int abs_value = (x < 0) ? -x : x;
    std::cout << "Absolute value of x: " << abs_value << std::endl;

    // Ternary operator in output
    std::cout << "Is x greater than y? "
              << ((x > y) ? "Yes" : "No") << std::endl;

    return 0;
}

프로그램을 컴파일하고 실행합니다.

g++ ternary_operator.cpp -o ternary_operator
./ternary_operator

예시 출력:

Larger value: 10
7 is Odd
Category: Medium
Absolute value of x: 10
Is x greater than y? Yes

삼항 연산자에 대한 주요 사항:

• Syntax (구문): condition ? value_if_true : value_if_false. 이는 if-else 문을 한 줄로 작성하는 간결한 방법입니다.
• condition이 평가됩니다. 참이면 표현식은 value_if_true를 반환하고, 그렇지 않으면 value_if_false를 반환합니다.
• 코드에서 int max_value = (x > y) ? x : y;는 x와 y 중 더 큰 숫자를 결정합니다. x가 y보다 크면 x를 max_value에 할당하고, 그렇지 않으면 y를 할당합니다. x가 10 이고 y가 5 이므로 max_value는 10이 됩니다.
• 표현식 std::string result = (number % 2 == 0) ? "Even" : "Odd";는 나머지 연산자 %를 사용하여 숫자가 짝수인지 홀수인지 확인합니다. 결과는 확인 결과에 따라 "Even" 또는 "Odd"이며, 문자열 변수 result에 할당됩니다.
• 삼항 연산자는 중첩될 수 있지만, 그렇게 하면 코드를 읽기 어려워질 수 있습니다. 예제에서 중첩된 삼항 연산자는 정수 a의 값에 따라 문자열 "Small", "Medium", 또는 "Large"를 변수 category에 할당합니다.
• int abs_value = (x < 0) ? -x : x;를 사용한 예제는 삼항 연산자를 사용하여 x의 절대값을 얻는 방법을 보여줍니다. x가 음수이면 x를 부정하여 절대값으로 변환합니다. 그렇지 않으면 x를 그대로 반환합니다.
• 마지막 예제는 삼항 연산자의 결과를 직접 출력하는 방법을 보여줍니다: std::cout << "Is x greater than y? " << ((x > y) ? "Yes" : "No") << std::endl;

중요 사항:

• 코드 가독성을 유지하기 위해 신중하게 사용하십시오. 삼항 연산자, 특히 중첩된 연산자를 과도하게 사용하면 코드를 따라가기 어려워질 수 있습니다.
• 너무 복잡해지면 읽기 어려워질 수 있습니다. 복잡한 결정은 종종 전체 if-else 블록으로 표현해야 합니다.
• 두 값 중 하나를 반환하거나 할당해야 하는 간단하고 직접적인 조건에 주로 사용됩니다.

요약

이 Lab 에서는 C++ 에서 덧셈, 뺄셈, 곱셈, 나눗셈 및 나머지 연산을 포함한 기본적인 수학 연산을 수행하는 방법을 배웠습니다. 또한 전위 및 후위 증가/감소 연산자의 사용법을 살펴보고, 그들 간의 미묘한 차이점을 이해했습니다. 또한, 값을 효과적으로 비교하고 결합하기 위해 관계 연산자 및 논리 연산자에 대해 배웠습니다. 더 나아가, 이진 조작을 위한 비트 연산과 할당과 함께 산술 연산을 단순화하고 축약하기 위한 복합 할당 연산자를 연습했습니다. 마지막으로, 여러 연산자를 사용한 연산 순서를 이해하고 간결한 조건문을 위해 삼항 조건 연산자를 사용했습니다. 이러한 기본적인 개념은 강력하고 효율적인 C++ 프로그램을 구축하는 데 필수적입니다. 이러한 기본 연산자를 숙달함으로써, 더 복잡한 코딩 문제에 대처할 수 있는 충분한 역량을 갖추게 될 것입니다.