[C] 04_연산자

---

* 본 포스팅은 혼자 공부하는 C언어 (서현우 지음)를 읽고 정리한 내용입니다.

* 본 포스팅에 포함된 코드는 본인이 작성한 것이므로 책과 다를 수 있습니다.

---

 

1. 산술 연산자

• 더하기(+)
• 빼기(-)
• 곱하기(*)
• 나누기(/)
• 나머지(%)

#include <stdio.h>

int main(void)
{
    int a, b;
    int sum, sub, mul, inv;
    a = 10;
    b = 20;
    
    sum = a+b;
    sub = a-b;
    mul = a*b;
    inv = -a;

    printf("a의 값 : %d, b의 값 : %d\n", a, b);
    printf("덧셈 : %d\n", sum);
    printf("뺄셈 : %d\n", sub);
    printf("곱셈 : %d\n", mul);
    printf("a의 음수 연산 : %d\n", inv);

    return 0;
}
====================================================
결과 : 
a의 값 : 10, b의 값 : 20
덧셈 : 30
뺄셈 : -10
곱셈 : 200
a의 음수 연산 : -10

• / 연산자 : 정수로 연산할 때는 몫을 구하고 실수로 연산할 때는 소수점까지 구한다.
• 연산 결과가 실수일 경우에는 double형 변수에, 정수일 경우에는 int형 변수에 저장

#include <stdio.h>

int main(void)
{
    double apple;			// 실수
    int banana;				// 정수
    int orange;				// 정수

    apple = 5.0/2.0;
    banana = 5/2;
    orange = 5%2;

    printf("apple : %.1lf\n", apple);
    printf("banana : %d\n", banana);
    printf("orange : %d\n", orange);

    return 0;
}
============================================
결과 : 
apple : 2.5
banana : 2
orange : 1

2. 증감 연산자

#include <stdio.h>

int main(void)
{
    int a = 10, b = 10;
    ++a;
    --b;

    printf("a : %d\n", a);
    printf("b : %d\n", b);

    return 0;
}
==================================
결과 : 
a : 11
b : 9

3. 전위 표기와 후위 표기

• 증감연산자가 피연산자 앞에 놓이면 전위 표기( 값이 증감하고 나서 연산에 사용 )
• 뒤에 놓이면 후위 표기 ( 연산에 사용하고 나서 값이 증감 )

#include <stdio.h>

int main(void)
{
    int a = 5, b = 5;
    int pre, post;
	
    pre = 3*(++a);
    post = 3*(b++);

    printf("초깃값 a = %d, b = %d\n", a, b);
    printf("전위형: (++a) * 3 = %d, 후위형 : (b++) * 3 = %d\n", pre, post);

    return 0;
}
=====================================================
결과 : 
초깃값 a = 6, b = 6
전위형: (++a) * 3 = 18, 후위형 : (b++) * 3 = 15

4. 관계 연산자

#include <stdio.h>

int main(void)
{
    int a = 10, b = 20, c = 10;
    int res;                           // 결괏값을 저장할 변수
	                                   // 각각 a와 b, c 값을 대입해보자.
    res = a > b;
    printf("a > b : %d\n", res);
    res = a >= b;
    printf("a >= b : %d\n", res);
    res = a < b;
    printf("a < b : %d\n", res);
    res = a <= b;
    printf("a <= b : %d\n", res);
    res = a <= c;
    printf("a <= c : %d\n", res);
    res = a == b;
    printf("a == b : %d\n", res);
    res = a != c;
    printf("a != c : %d\n", res);

    return 0;
}
===============================================
결과 : 
a > b : 0
a >= b : 0
a < b : 1
a <= b : 1
a <= c : 1
a == b : 0
a != c : 0

 

5. 논리 연산자

• 논리 연산자는 참과 거짓을 판단하는데 사용
• && :  논리곱(AND) 연산자로 2개의 피연산자가 모두 참일 때만 참
• ||  :  논리합(OR) 연산자로 둘 중에 하나라도 참이면 참
• ! : 논리부정(NOT) 연산자이며 피연산자를 하나 사용하여 그 참과 거짓을 바꿀 때 사용

#include <stdio.h>

int main(void)
{
    int a = 30;
    int res;
    res = a > 10 && a < 20;
    printf("(a > 10) && (a < 20) : %d\n", res);
    res =  a < 10 || a > 20;
    printf("(a < 10) || (a > 20) : %d\n", res);
    res = !(a >= 30);
    printf("!(a >= 30) : %d\n", res);

    return 0;
}
============================================
결과 : 
(a > 10) && (a < 20) : 0
(a < 10) || (a > 20) : 1
!(a >= 30) : 0

6. 연산의 결괏값을 처리하는 방법

#include <stdio.h>

int main(void)
{
    int a = 10, b = 20, res;

    a + b;          //  연산의 결과를 사용하지 않는 문장이므로 삭제하는 편이 좋음
    printf("%d + %d = %d\n", a, b, a + b);  // 연산 결과를 바로 출력에 사용
    res = a+b;
    printf("%d + %d = %d\n", a, b, res);    // 저장된 값을 계속 사용

    return 0;
}
=================================
결과 : 
10 + 20 = 30
10 + 20 = 30

7. 형 변환 연산자

• 값을 일시적으로 실수로 사용하고 싶으면 a앞에 괄호로 (double)처럼 원하는 자료형을 넣으면 된다.

(자료형)피연산자
(double)10 -> 10.0
(int)10.7  -> 10

• 형 변환은 나누기 연산을 할 때 유용하게 사용할 수 있다.
• 나누기 결과는 항상 정수로 나오지 않기 때문에 소수점 이하까지 값을 구하려면 형 변환을 사용해야 함.

#include <stdio.h>

int main(void)
{
    int a = 20, b = 3;
    double res;

    res = (double) a/b;
    printf("a = %d, b = %d\n", a, b);
    printf("a / b의 결과 : %.1lf\n", res);


    a = (int) res;
    printf("(int) %.1lf의 결과 : %d\n", res, a);

    return 0;
}
=========================================
결과 : 
a = 20, b = 3
a / b의 결과 : 6.7
(int) 6.7의 결과 : 6

8. sizeof 연산자

• sizeof(피연산자) : 피연산자의 크기를 바이트 단위로 계산해서 알려 줌.
• 데이터의 크기를 확인하거나 메모리를 동적으로 할당하는 작업 등에 유용하게 사용.

#include <stdio.h>

int main(void)
{
    int a = 10;
    double b = 3.4;

    printf("int형 변수의 크기 : %d\n", sizeof(a));
    printf("double형 변수의 크기 : %d\n", sizeof (b));
    printf("정수형 상수의 크기 : %d\n",sizeof (10) );
    printf("수식의 결괏값의 크기 : %d\n",sizeof (1.5 + 3.4));
    printf("char 자료형의 크기 : %d\n",sizeof (char));

    return 0;
}
========================================
결과 : 
int형 변수의 크기 : 4
double형 변수의 크기 : 8
정수형 상수의 크기 : 4
수식의 결괏값의 크기 : 8
char 자료형의 크기 : 1

9. 복합대입 연산자

• 산술 복합대입 연산자 : +=, -=, *=, /=, %=
• 특징 1) 왼쪽 피연산자는 반드시 변수가 와야 한다.
• 특징 2) 오른쪽 항의 계산이 모두 끝난 다음에 복합대입 연산자는 가장 마지막에 계산한다.

#include <stdio.h>

int main(void)
{
    int a = 10, b = 20;
    int res = 2;
    
    a += 20;
    res *= (b + 10);

    printf("a = %d, b = %d\n", a, b);
    printf("res = %d\n", res);

    return 0;
}
===============================
결과 : 
a = 30, b = 20
res = 60

10. 콤마 연산자

• 콤마 연산자(,) : 한 번에 여러 개의 수식을 차례로 나열해야 할 때 사용
• 왼쪽부터 오른쪽으로 차례로 연산을 수행하며 가장 오른쪽의 피연산자가 최종 결괏값이 된다.
• 대입 연산자와 함께 사용할 떄는 반드시 괄호가 필요하다.

// a에는 1이 더해진 c가 저장
a = (++b, ++c);

// 콤마는 대입연산자보다 우선순위가 낮아서 대입연산자가 먼저 실행
// 그래서 a에는 1이 더해진 b가 저장
a = ++b, ++c;

 

• 별개의 두 문장을 한 줄에 작성할 때는 콤마 연산자 대신 세미콜론을 사용하는 것이 좋다.

#include <stdio.h>

int main(void)
{
    int a = 10, b = 20;
    int res;

    res = (++a, ++b);    // res에 저장되는 값은 증가된 b의 값이다.
                           
    printf("a: %d, b : %d\n", a, b);
    printf("res: %d\n", res);

    return 0;
}
=================================
결과 : 
a: 11, b : 21
res: 21

11. 조건 연산자

• 조건 연산자는 유일한 삼항 연산자로 ? 와  : 기호를 함께 사용한다.
• 첫 번째 피연산자가 참이면 두 번째 피연산자가 결괏값이 되고,
• 첫 번째 피연산자가 거짓이면 세 번째 피연산자가 결괏값이 된다.

#include <stdio.h>

int main(void)
{
    int a = 10, b = 20, res;

    // 조건 연산자를 사용해서 a가 b보다 클 경우 a, 작을 경우 b를 res에 저장
    (a > b) ? (res = a) : (res = b);
    printf("큰 값 : %d\n", res);

    return 0;
}
=======================================
결과 : 
큰 값 : 20

12. 비트 연산자

• 비트 연산자 : 데이터를 비트 단위로 연산한다.
• 비트 논리 연산자 : & , | , ^
• 비트 이동 연산자 : >> , <<
• 데이터를 비트로 정확히 표현할 수 있는 정수에만 사용할 수 있다.
• & :  두 피연산자를 각 비트별로 논리곱 연산(&)을 수행
• ^ : 두 피연산자를 각 비트별로 배타적 논리합 연산(^)을 수행. 배타적 논리합의 진리값은 두 피연산자의 진리값이 서로 다를 때만 참이 됨.
•  |  : 두 피연산자를 각 비트별로 논리합 연산(|)을 수행
• ~ : 피연산자가 하나이며 피연산자의 비트를 반전시킴.
• << : 비트들을 왼쪽으로 이동시키고 
• >> : 오른쪽으로 이동시킴.
• << 을 사용할 때 왼쪽 끝의 비트들은 사라지고 오른쪽의 남은 비트들은 0으로 채워진다.
• >> 을 사용할 때 오른쪽 끝의 비트들은 사라지고 왼쪽의 남은 비트는 0으로 채워진다.

#include <stdio.h>

int main(void)
{
    int a = 10;			// 비트열 00000000 00000000 00000000 00001010
    int b = 12;			// 비트열 00000000 00000000 00000000 00001100


    printf("a & b : %d\n", a & b);

    printf("a ^ b : %d\n", a ^ b);

    printf("a | b : %d\n", a | b);

    printf("~a : %d\n", ~a);

    printf("a << 1 : %d\n", a<< 1);

    printf("a >> 2 : %d\n", a >> 2);

    return 0;
}
=================================================
결과 : 
a & b : 8
a ^ b : 6
a | b : 14
~a : -11
a << 1 : 20
a >> 2 : 2

 

 

13. 연산자 우선순위와 연산 방향

• 하나의 수식에서 2개 이상의 연산자가 함께 쓰일 때는 연산자의 우선순위에 따라 연산된다.

#include <stdio.h>

int main(void)
{
    int a = 10, b = 5;
    int res;

    res = a / b * 2;
    printf("res = %d\n", res);

    res = ++a * 3;
    printf("res = %d\n", res);

    res = a > b && a != 5;
    printf("res = %d\n", res);

    res = a % 3 == 0;
    printf("res = %d\n", res);

    return 0;
}
=====================================
결과 : 
res = 4
res = 33
res = 1
res = 0

---

출처 : 혼자 공부하는 C언어 (서현우 지음), 엘리스 아카데미 - 혼자 공부하는 C언어