๋ณธ๋ฌธ ๋ฐ”๋กœ๊ฐ€๊ธฐ
๐Ÿ“ Development Study/๐Ÿ’ป Win32API

์—ฐ์‚ฐ์ž

by eazuooz 2022. 8. 17.

๋ณ€์ˆ˜์™€ ์ƒ์ˆ˜๋ฅผ ์—ฐ์‚ฐ์ž๋ฅผ ์‚ฌ์šฉํ•˜์—ฌ ์—ฐ์‚ฐ ์ž‘์—…์„ ํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค๋‹ค์Œ์€ ์ „์ฒด ์—ฐ์‚ฐ์ž ๋ชฉ๋ก์ž…๋‹ˆ๋‹ค์ด ์‹œ์ ์—์„œ ๋ชจ๋“  ํ•ญ๋ชฉ์„ ์•Œ ํ•„์š”๋Š” ์—†์ง€๋งŒ ์ฐธ์กฐ์šฉ์œผ๋กœ๋„ ์‚ฌ์šฉํ•  ์ˆ˜ ์žˆ๋„๋ก ๋ชจ๋‘ ์—ฌ๊ธฐ์— ๋‚˜์—ด๋˜์–ด ์žˆ์Šต๋‹ˆ๋‹ค.

 

๋Œ€์ž… ์—ฐ์‚ฐ์ž(=)

๋Œ€์ž… ์—ฐ์‚ฐ์ž๋Š” ๋ณ€์ˆ˜์— ๊ฐ’์„ ํ• ๋‹นํ•ฉ๋‹ˆ๋‹ค.

x = 5;

์ด ๋ฌธ์€ ์ •์ˆ˜ ๊ฐ’ 5์„ ๋ณ€์ˆ˜์— ํ• ๋‹นํ•ฉ๋‹ˆ๋‹ค x. ํ• ๋‹น ์ž‘์—…์€ ํ•ญ์ƒ ์˜ค๋ฅธ์ชฝ์—์„œ ์™ผ์ชฝ์œผ๋กœ ๋ฐœ์ƒํ•˜๋ฉฐ ๊ทธ ๋ฐ˜๋Œ€๋Š” ์ ˆ๋Œ€ ์•„๋‹™๋‹ˆ๋‹ค.

x = y;

๋ฌธ์€ ๋ณ€์ˆ˜ ์— ํฌํ•จ๋œ  y๊ฐ’ x ๋ณ€์ˆ˜์— ํ• ๋‹นํ•ฉ๋‹ˆ๋‹ค .์ด ๋ช…๋ น๋ฌธ์ด ์‹คํ–‰๋˜๋Š” ์ˆœ๊ฐ„ ๊ธฐ์กด์— ์žˆ๋˜  x๊ฐ’ ์€ ์†์‹ค๋˜๊ณ  y์˜ ๊ฐ’์œผ๋กœ ๋Œ€์ฒด๋ฉ๋‹ˆ๋‹ค.

// assignment operator
#include <iostream>
using namespace std;

int main ()
{
  int a, b;         // a:?,  b:?
  a = 10;           // a:10, b:?
  b = 4;            // a:10, b:4
  a = b;            // a:4,  b:4
  b = 7;            // a:4,  b:7

  cout << "a:";
  cout << a;
  cout << " b:";
  cout << b;
}

a์ด ํ”„๋กœ๊ทธ๋žจ์€ ๋ฐ b(๊ฐ๊ฐ 4 ๋ฐ 7) ์˜ ์ตœ์ข… ๊ฐ’์„ ํ™”๋ฉด์— ์ถœ๋ ฅํ•ฉ๋‹ˆ๋‹ค.

์ด์ „์— ์„ ์–ธํ–ˆ์Œ์—๋„ ๋ถˆ๊ตฌํ•˜๊ณ  a์˜ ์ตœ์ข… ์ˆ˜์ •์— ์˜ํ•ด ์–ด๋–ป๊ฒŒ ์˜ํ–ฅ์„ ๋ฐ›์ง€ ์•Š์•˜๋Š”์ง€ ์ฃผ๋ชฉ ํ•˜์„ธ์š”.

 

y = 2 + (x = 5);

์ด ์‹์—์„œ y์— 2๋ฅผ ๋”ํ•œ ๊ฒฐ๊ณผ์™€ ๋‹ค๋ฅธ ํ• ๋‹น ์‹(์ž์ฒด ๊ฐ’์ด 5์ž„)์˜ ๊ฐ’์ด ํ• ๋‹น๋ฉ๋‹ˆ๋‹ค. ๋Œ€๋žต ๋‹ค์Œ๊ณผ ๊ฐ™์Šต๋‹ˆ๋‹ค.

x = 5;
y = 2 + x;

 

์„ธ ๋ณ€์ˆ˜ ๋ชจ๋‘์— 5๋ฅผ ํ• ๋‹นํ•ฉ๋‹ˆ๋‹ค. 

x = y = z = 5;

 

์‚ฐ์ˆ  ์—ฐ์‚ฐ์ž( +, -, *, /, % )

C++์—์„œ ์ง€์›ํ•˜๋Š” 5๊ฐ€์ง€ ์‚ฐ์ˆ  ์—ฐ์‚ฐ์€ ๋‹ค์Œ๊ณผ ๊ฐ™์Šต๋‹ˆ๋‹ค.

 

operator description
+ addition
- subtraction
* multiplication
/ division
% modulo

 

๋”ํ•˜๊ธฐ, ๋นผ๊ธฐ, ๊ณฑํ•˜๊ธฐ ๋ฐ ๋‚˜๋ˆ„๊ธฐ ์—ฐ์‚ฐ์€ ๋ฌธ์ž ๊ทธ๋Œ€๋กœ ํ•ด๋‹น ์ˆ˜ํ•™ ์—ฐ์‚ฐ์ž์— ํ•ด๋‹นํ•ฉ๋‹ˆ๋‹ค. ๋งˆ์ง€๋ง‰ ํ•˜๋‚˜์ธ ๋ชจ๋“ˆ๋กœ ์—ฐ์‚ฐ์ž ๋Š” ๋ฐฑ๋ถ„์œจ ๊ธฐํ˜ธ( %)๋กœ ํ‘œ์‹œ๋˜๋ฉฐ ๋‘ ๊ฐ’์„ ๋‚˜๋ˆˆ ๋‚˜๋จธ์ง€๋ฅผ ์ œ๊ณตํ•ฉ๋‹ˆ๋‹ค. ์˜ˆ๋ฅผ ๋“ค์–ด:

x = 11 % 3;

x11์„ 3์œผ๋กœ ๋‚˜๋ˆ„๋ฉด 3์ด ๋˜๊ณ  ๋‚˜๋จธ์ง€๋Š” 2๊ฐ€ ๋˜๊ธฐ ๋•Œ๋ฌธ์— ๊ฐ’ 2๋ฅผ ํฌํ•จํ•˜๋Š” ๋ณ€์ˆ˜ ๊ฐ€ ๋ฉ๋‹ˆ๋‹ค.

 

๋ณตํ•ฉ ํ• ๋‹น(+=, -=, *=, /=, %=, >>=, <<=, &=, ^=, |=)

๋ณตํ•ฉ ํ• ๋‹น ์—ฐ์‚ฐ์ž๋Š” ์—ฐ์‚ฐ์„ ์ˆ˜ํ–‰ํ•˜์—ฌ ๋ณ€์ˆ˜์˜ ํ˜„์žฌ ๊ฐ’์„ ์ˆ˜์ •ํ•ฉ๋‹ˆ๋‹ค. ์ฒซ ๋ฒˆ์งธ ํ”ผ์—ฐ์‚ฐ์ž์— ์—ฐ์‚ฐ ๊ฒฐ๊ณผ๋ฅผ ํ• ๋‹นํ•˜๋Š” ๊ฒƒ๊ณผ ๊ฐ™์Šต๋‹ˆ๋‹ค.

 

expression equivalent to...
y += x; y = y + x;
x -= 5; x = x - 5;
x /= y; x = x / y;
price *= units + 1; price = price * (units+1);

๋‹ค๋ฅธ ๋ชจ๋“  ๋ณตํ•ฉ ํ• ๋‹น ์—ฐ์‚ฐ์ž์— ๋Œ€ํ•ด์„œ๋„ ๋™์ผํ•ฉ๋‹ˆ๋‹ค. ์˜ˆ๋ฅผ ๋“ค์–ด:

// compound assignment operators
#include <iostream>
using namespace std;

int main ()
{
  int a, b=3;
  a = b;
  a+=2;             // equivalent to a=a+2
  cout << a;
}

์ฆ๊ฐ€ ๋ฐ ๊ฐ์†Œ(++, --)

++์ฆ๊ฐ€ ์—ฐ์‚ฐ์ž( )์™€ ๊ฐ์†Œ ์—ฐ์‚ฐ์ž( --)๋Š” ๋ณ€์ˆ˜์— ์ €์žฅ๋œ ๊ฐ’์„ 1๋งŒํผ ์ฆ๊ฐ€ ๋˜๋Š” ๊ฐ์†Œ์‹œํ‚ค๋Š” ์‹์œผ๋กœ ํ›จ์”ฌ ๋” ๋‹จ์ถ•๋  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค ํ›จ์”ฌ ๋” ๋‹จ์ถ•๋  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค๊ทธ๊ฒƒ๋“ค์€ ๊ฐ๊ฐ +=1๋ฐ  -=1์— ํ•ด๋‹นํ•ฉ๋‹ˆ๋‹ค

++x;
x+=1;
x=x+1;

3๊ฐœ์˜ ๊ฐ’์ด ๋ชจ๋‘ 1์”ฉ ์ฆ๊ฐ€ํ•ฉ๋‹ˆ๋‹ค.

์ดˆ๊ธฐ C ์ปดํŒŒ์ผ๋Ÿฌ์—์„œ ์•ž์˜ ์„ธ ์‹์€ ์‚ฌ์šฉ๋œ ์ฝ”๋“œ์— ๋”ฐ๋ผ ๋‹ค๋ฅธ ์‹คํ–‰ ์ฝ”๋“œ๋ฅผ ์ƒ์„ฑํ–ˆ์„ ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค์˜ค๋Š˜๋‚  ์ด๋Ÿฌํ•œ ์œ ํ˜•์˜ ์ฝ”๋“œ ์ตœ์ ํ™”๋Š” ์ผ๋ฐ˜์ ์œผ๋กœ ์ปดํŒŒ์ผ๋Ÿฌ์— ์˜ํ•ด ์ž๋™์œผ๋กœ ์ˆ˜ํ–‰๋˜๋ฏ€๋กœ ์„ธ ๊ฐ€์ง€ ํ‘œํ˜„์‹์ด ์ •ํ™•ํžˆ ๋™์ผํ•œ ์‹คํ–‰ ์ฝ”๋“œ๋กœ ๋ณ€ํ™˜๋˜์–ด ์‹คํ–‰๋ฉ๋‹ˆ๋‹ค.



๊ฐ™์€์ค„(code line)์—์„œ ์ „์œ„ ์—ฐ์‚ฐ์ž(++x)์˜ ๊ฒฝ์šฐ ์ฆ๊ฐ€ ์—ฐ์‚ฐ์ด ๋จผ์ € ์ง„ํ–‰ํ•œ ํ›„ ๋Œ€์ž… ์—ฐ์‚ฐ์ด ์ฒ˜๋ฆฌ๋ฉ๋‹ˆ๋‹ค.

ํ›„์œ„ ์—ฐ์‚ฐ์ž(x++) ์˜ ๊ฒฝ์šฐ ๋Œ€์ž… ์—ฐ์‚ฐ์ด ๋จผ์ € ์ง„ํ–‰๋œ ํ›„ ํ•ด๋‹น ๋ณ€์ˆ˜์˜ ๊ฐ’์ด ์ฆ๊ฐ๋ฉ๋‹ˆ๋‹ค.

์‹ค์‹œ์˜ˆ 1 ์‹ค์‹œ์˜ˆ 2
x = 3;
y = ++x;
// x contains 4, y contains 4
x = 3;
y = x++;
// x contains 4, y contains 3

 

๊ด€๊ณ„ ๋ฐ ๋น„๊ต ์—ฐ์‚ฐ์ž( ==, !=, >, <, >=, <= )

๊ด€๊ณ„ ์—ฐ์‚ฐ์ž์™€ ํ•ญ๋“ฑ ์—ฐ์‚ฐ์ž๋ฅผ ์‚ฌ์šฉํ•˜์—ฌ ๋‘ ํ‘œํ˜„์‹์„ ๋น„๊ตํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค. ์˜ˆ๋ฅผ ๋“ค์–ด, ๋‘ ๊ฐ’์ด ๊ฐ™์€์ง€ ๋˜๋Š” ํ•˜๋‚˜๊ฐ€ ๋‹ค๋ฅธ ๊ฐ’๋ณด๋‹ค ํฐ์ง€ ํ™•์ธํ•ฉ๋‹ˆ๋‹ค.

์ด๋Ÿฌํ•œ ์—ฐ์‚ฐ์˜ ๊ฒฐ๊ณผ๋Š” ์ฐธ ๋˜๋Š” ๊ฑฐ์ง“ ๊ฐ’์ž…๋‹ˆ๋‹ค.

C++์˜ ๊ด€๊ณ„ ์—ฐ์‚ฐ์ž๋Š” ๋‹ค์Œ๊ณผ ๊ฐ™์Šต๋‹ˆ๋‹ค.

operator description
== Equal to
!= Not equal to
< Less than
> Greater than
<= Less than or equal to
>= Greater than or equal to

๋‹ค์Œ์€ ๋ช‡ ๊ฐ€์ง€ ์˜ˆ์ž…๋‹ˆ๋‹ค.

(7 == 5)     // evaluates to false
(5 > 4)      // evaluates to true
(3 != 2)     // evaluates to true
(6 >= 6)     // evaluates to true
(5 < 5)      // evaluates to false
(a == 5)     // evaluates to false, since a is not equal to 5
(a*b >= c)   // evaluates to true, since (2*3 >= 6) is true
(b+4 > a*c)  // evaluates to false, since (3+4 > 2*6) is false
((b=2) == a) // evaluates to true

๋น„๊ต ์—ฐ์‚ฐ์ž๋ฅผ ์‚ฌ์šฉํ• ๋•Œ ๋Œ€์ž…์—ฐ์‚ฐ์ž(=)์ด ์‚ฌ์šฉ๋˜์ง€ ์•Š๋„๋ก ์กฐ์˜ํ•˜์—ฌ์•ผ ํ•ฉ๋‹ˆ๋‹ค.

 

๋…ผ๋ฆฌ ์—ฐ์‚ฐ์ž( !, &&, || )

์—ฐ์‚ฐ์ž !๋Š” ๋ถ€์šธ ์—ฐ์‚ฐ NOT์— ๋Œ€ํ•œ C++ ์—ฐ์‚ฐ์ž์ž…๋‹ˆ๋‹ค. ์˜ค๋ฅธ์ชฝ์— ํ•˜๋‚˜์˜ ํ”ผ์—ฐ์‚ฐ์ž๊ฐ€ ์žˆ๊ณ  ๊ทธ๊ฒƒ์„ ๋ฐ˜์ „์‹œ์ผœ falseํ”ผ์—ฐ์‚ฐ์ž๊ฐ€ ์ด๋ฉด ํ”ผ์—ฐ์‚ฐ์ž๊ฐ€ true์ด๊ณ  true์ด๋ฉด false๋ฅผ ์ƒ์„ฑํ•ฉ๋‹ˆ๋‹ค . ๊ธฐ๋ณธ์ ์œผ๋กœ ํ”ผ์—ฐ์‚ฐ์ž๋ฅผ ํ‰๊ฐ€ํ•˜๋Š” ๋ฐ˜๋Œ€ Boolean ๊ฐ’์„ ๋ฐ˜ํ™˜ํ•ฉ๋‹ˆ๋‹ค. ์˜ˆ๋ฅผ ๋“ค์–ด:

!(5 == 5)   // evaluates to false because the expression at its right (5 == 5) is true
!(6 <= 4)   // evaluates to true because (6 <= 4) would be false
!true       // evaluates to false
!false      // evaluates to true

๋…ผ๋ฆฌ ์—ฐ์‚ฐ์ž &&๋ฐ ||๋Š” ๋‹จ์ผ ๊ด€๊ณ„ํ˜• ๊ฒฐ๊ณผ๋ฅผ ์–ป๊ธฐ ์œ„ํ•ด ๋‘ ์‹์„ ํ‰๊ฐ€ํ•  ๋•Œ ์‚ฌ์šฉ๋ฉ๋‹ˆ๋‹ค. ์—ฐ์‚ฐ์ž &&๋Š” ๋ถ€์šธ ๋…ผ๋ฆฌ ์—ฐ์‚ฐ AND์— ํ•ด๋‹นํ•˜๋ฉฐ, true๋‘ ํ”ผ์—ฐ์‚ฐ์ž๊ฐ€ ๋ชจ๋‘ ์ด๋ฉด ๊ฒฐ๊ณผ ๋ฅผ ์‚ฐ์ถœ trueํ•˜๊ณ  false๊ทธ๋ ‡์ง€ ์•Š์œผ๋ฉด ์‚ฐ์ถœํ•ฉ๋‹ˆ๋‹ค. 

&& ์—ฐ์‚ฐ์ž
a b a && b
true true true
true false false
false true false
false false false


์—ฐ์‚ฐ์ž ||๋Š” ๋ถ€์šธ ๋…ผ๋ฆฌ ์—ฐ์‚ฐ OR์— trueํ•ด๋‹นํ•˜๋ฉฐ, ํ”ผ์—ฐ์‚ฐ์ž ์ค‘ ํ•˜๋‚˜๊ฐ€ true์ด๋ฉด ๋‘ ํ”ผ์—ฐ์‚ฐ์ž๊ฐ€ ๋ชจ๋‘ ๊ฑฐ์ง“์ธ ๊ฒฝ์šฐ์—๋งŒ ๊ฑฐ์ง“์ด ๋ฉ๋‹ˆ๋‹ค. 

|| ์—ฐ์‚ฐ์ž
a b a  || b
true true true
true false true
false true true
false false false
( (5 == 5) && (3 > 6) )  // evaluates to false ( true && false )
( (5 == 5) || (3 > 6) )  // evaluates to true ( true || false )

๋…ผ๋ฆฌ ์—ฐ์‚ฐ์ž๋ฅผ ์‚ฌ์šฉํ•  ๋•Œ C++๋Š” ๊ฒฐํ•ฉ๋œ ๊ด€๊ณ„ํ˜• ๊ฒฐ๊ณผ๋ฅผ ๋„์ถœํ•˜๊ธฐ ์œ„ํ•ด ์™ผ์ชฝ์—์„œ ์˜ค๋ฅธ์ชฝ์œผ๋กœ ํ•„์š”ํ•œ ๊ฒƒ๋งŒ ํ‰๊ฐ€ํ•˜๊ณ  ๋‚˜๋จธ์ง€๋Š” ๋ฌด์‹œํ•ฉ๋‹ˆ๋‹ค. ๋”ฐ๋ผ์„œ ๋งˆ์ง€๋ง‰ ์˜ˆ( (5==5)||(3>6))์—์„œ C++ 5==5๋Š” ๊ฐ€ true์ธ ์ง€ ์—ฌ๋ถ€๋ฅผ ๋จผ์ € ํ‰๊ฐ€ํ•˜๊ณ  ์ธ ๊ฒฝ์šฐ ์ธ ์—ฌ๋ถ€ 3>6๋ฅผ ํ™•์ธ trueํ•˜์ง€ ์•Š์Šต๋‹ˆ๋‹ค. ์ด๋ฅผ ๋‹จ๋ฝ ํ‰๊ฐ€ ๋ผ๊ณ  ํ•˜๋ฉฐ ๋‹ค์Œ ์—ฐ์‚ฐ์ž์— ๋Œ€ํ•ด ๋‹ค์Œ๊ณผ ๊ฐ™์ด ์ž‘๋™ํ•ฉ๋‹ˆ๋‹ค.

 

operator short-circuit
&& ์™ผ์ชฝ ํ‘œํ˜„์‹์ด false์ด๋ฉด ๊ฒฐํ•ฉ๋œ ๊ฒฐ๊ณผ๋Š” false(์˜ค๋ฅธ์ชฝ ํ‘œํ˜„์‹์€ ํ‰๊ฐ€๋˜์ง€ ์•Š์Œ)์ž…๋‹ˆ๋‹ค.
|| ์™ผ์ชฝ ํ‘œํ˜„์‹์ด true์ด๋ฉด ๊ฒฐํ•ฉ๋œ ๊ฒฐ๊ณผ๋Š” true(์˜ค๋ฅธ์ชฝ ํ‘œํ˜„์‹์€ ํ‰๊ฐ€๋˜์ง€ ์•Š์Œ)์ž…๋‹ˆ๋‹ค.

์ด๊ฒƒ์€ ์˜ค๋ฅธ์ชฝ ํ‘œํ˜„์‹์— ๊ฐ’ ๋ณ€๊ฒฝ๊ณผ ๊ฐ™์€ ๋ถ€์ž‘์šฉ์ด ์žˆ์„ ๋•Œ ๊ฐ€์žฅ ์ค‘์š”ํ•ฉ๋‹ˆ๋‹ค.

if ( (i<10) && (++i<n) ) { /*...*/ }   // note that the condition increments i

 

์กฐ๊ฑด๋ถ€ ์‚ผํ•ญ ์—ฐ์‚ฐ์ž( ? )

์กฐ๊ฑด ์—ฐ์‚ฐ์ž๋Š” ํ‘œํ˜„์‹์„ ํ‰๊ฐ€ํ•˜์—ฌ ํ•ด๋‹น ํ‘œํ˜„์‹์ด true ๋กœ ํ‰๊ฐ€๋˜๋Š” ๊ฒฝ์šฐ ํ•˜๋‚˜์˜ ๊ฐ’(์™ผ์ชฝ)์„ ๋ฐ˜ํ™˜ํ•˜๊ณ  ํ‘œํ˜„์‹์ด false๋กœ ํ‰๊ฐ€๋˜๋Š” ๊ฒฝ์šฐ ๋‹ค๋ฅธ ๊ฐ’(์˜ค๋ฅธ์ชฝ)์„ ๋ฐ˜ํ™˜ ํ•ฉ๋‹ˆ๋‹ค๊ตฌ๋ฌธ์€ ๋‹ค์Œ๊ณผ ๊ฐ™์Šต๋‹ˆ๋‹ค



condition ? result1 : result2

7==5 ? 4 : 3     // evaluates to 3, since 7 is not equal to 5.
7==5+2 ? 4 : 3   // evaluates to 4, since 7 is equal to 5+2.
5>3 ? a : b      // evaluates to the value of a, since 5 is greater than 3.
a>b ? a : b      // evaluates to whichever is greater, a or b. 

// conditional operator
#include <iostream>
using namespace std;

int main ()
{
  int a,b,c;

  a=2;
  b=7;
  c = (a>b) ? a : b;

  cout << c << '\n';
}

 

์‰ผํ‘œ ์—ฐ์‚ฐ์ž( , )

์‰ผํ‘œ ์—ฐ์‚ฐ์ž( ,)๋Š” ํ•˜๋‚˜์˜ ํ‘œํ˜„์‹๋งŒ ์˜ˆ์ƒ๋˜๋Š” ๋‘ ๊ฐœ ์ด์ƒ์˜ ํ‘œํ˜„์‹์„ ๊ตฌ๋ถ„ํ•˜๋Š” ๋ฐ ์‚ฌ์šฉ๋ฉ๋‹ˆ๋‹ค. ํ‘œํ˜„์‹ ์„ธํŠธ๊ฐ€ ๊ฐ’์— ๋Œ€ํ•ด ํ‰๊ฐ€๋˜์–ด์•ผ ํ•˜๋Š” ๊ฒฝ์šฐ ๋งจ ์˜ค๋ฅธ์ชฝ ํ‘œํ˜„์‹๋งŒ ๊ณ ๋ ค๋ฉ๋‹ˆ๋‹ค.

์˜ˆ๋ฅผ ๋“ค์–ด:

a = (b=3, b+2);

๋จผ์ € ๊ฐ’ 3์„ b์— ํ• ๋‹นํ•œ ๋‹ค์Œ b+2๋ณ€์ˆ˜์— ํ• ๋‹นํ•ฉ๋‹ˆ๋‹ค 

 

๋น„ํŠธ ์—ฐ์‚ฐ์ž( &, |, ^, ~, <<, >> )

๋น„ํŠธ ์—ฐ์‚ฐ์ž๋Š” ์ €์žฅํ•˜๋Š” ๊ฐ’์„ ๋‚˜ํƒ€๋‚ด๋Š” ๋น„ํŠธ ํŒจํ„ด์„ ๊ณ ๋ คํ•˜์—ฌ ๋ณ€์ˆ˜๋ฅผ ์ˆ˜์ •ํ•ฉ๋‹ˆ๋‹ค.

operatorasm equivalent  description
& AND ๋น„ํŠธ AND
| OR ๋น„ํŠธ ํฌํ•จ OR
^ XOR ๋น„ํŠธ ๋ฐฐํƒ€์  OR
~ NOT ๋‹จํ•ญ ๋ณด์ˆ˜(๋น„ํŠธ ๋ฐ˜์ „)
<< SHL ๋น„ํŠธ๋ฅผ ์™ผ์ชฝ์œผ๋กœ ์ด๋™
>> SHR ๋น„ํŠธ๋ฅผ ์˜ค๋ฅธ์ชฝ์œผ๋กœ ์ด๋™

 

๋ช…์‹œ์  ์œ ํ˜• ์บ์ŠคํŒ… ์—ฐ์‚ฐ์ž

์บ์ŠคํŒ… ์—ฐ์‚ฐ์ž๋ฅผ ์‚ฌ์šฉํ•˜๋ฉด ์ฃผ์–ด์ง„ ์œ ํ˜•์˜ ๊ฐ’์„ ๋‹ค๋ฅธ ์œ ํ˜•์œผ๋กœ ๋ณ€ํ™˜ํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค. C++์—์„œ ์ด๋ฅผ ์ˆ˜ํ–‰ํ•˜๋Š” ๋ช‡ ๊ฐ€์ง€ ๋ฐฉ๋ฒ•์ด ์žˆ์Šต๋‹ˆ๋‹ค. C ์–ธ์–ด์—์„œ ๊ฐ€์žฅ ๊ฐ„๋‹จํ•œ ๊ฒƒ์€ ๋ณ€ํ™˜ํ•  ํ‘œํ˜„์‹ ์•ž์— ๊ด„ํ˜ธ(())๋กœ ๋ฌถ์ธ ์ƒˆ ์œ ํ˜•์œผ๋กœ ํ‘œ์‹œํ•˜๋Š” ๊ฒƒ์ž…๋‹ˆ๋‹ค.

int i;
float f = 3.14;
i = (int) f;

์ด์ „ ์ฝ”๋“œ๋Š” ๋ถ€๋™ ์†Œ์ˆ˜์  ์ˆซ์ž 3.14๋ฅผ ์ •์ˆ˜ ๊ฐ’( 3)์œผ๋กœ ๋ณ€ํ™˜ํ•ฉ๋‹ˆ๋‹ค๋‚˜๋จธ์ง€ ์‹ค์ˆ˜๋ถ€๋Š” ์†์‹ค๋ฉ๋‹ˆ๋‹ค

 

 

sizeof() ์—ฐ์‚ฐ์ž

์ด ์—ฐ์‚ฐ์ž๋Š” ์œ ํ˜• ๋˜๋Š” ๋ณ€์ˆ˜๊ฐ€ ๋  ์ˆ˜ ์žˆ๋Š” ํ•˜๋‚˜์˜ ๋งค๊ฐœ๋ณ€์ˆ˜๋ฅผ ํ—ˆ์šฉํ•˜๊ณ  ํ•ด๋‹น ์œ ํ˜• ๋˜๋Š” ๊ฐ์ฒด์˜ ํฌ๊ธฐ๋ฅผ ๋ฐ”์ดํŠธ ๋‹จ์œ„๋กœ ๋ฐ˜ํ™˜ํ•ฉ๋‹ˆ๋‹ค.

x = sizeof (char);

์—ฌ๊ธฐ์„œ ๋Š” 1๋ฐ”์ดํŠธ ํฌ๊ธฐ์˜ ์œ ํ˜• ์ด๊ธฐ ๋•Œ๋ฌธ์— x๊ฐ’์ด ํ• ๋‹น๋ฉ๋‹ˆ๋‹ค . 

 

์—ฐ์‚ฐ์ž์˜ ์šฐ์„  ์ˆœ์œ„

๋‹จ์ผ ํ‘œํ˜„์‹์— ์—ฌ๋Ÿฌ ์—ฐ์‚ฐ์ž๊ฐ€ ์žˆ์„ ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค. ์˜ˆ๋ฅผ ๋“ค์–ด:

x = 5 + 7 % 2;
 


C++์—์„œ ์œ„์˜ ํ‘œํ˜„์‹์€ ํ•ญ์ƒ ๋ณ€์ˆ˜์— 6์„ ํ• ๋‹นํ•ฉ๋‹ˆ๋‹ค x. ์™œ๋ƒํ•˜๋ฉด %์—ฐ์‚ฐ์ž๋Š” ์—ฐ์‚ฐ์ž๋ณด๋‹ค ์šฐ์„ ์ˆœ์œ„๊ฐ€ ๋†’๊ณ  +ํ•ญ์ƒ ๋จผ์ € ํ‰๊ฐ€๋˜๊ธฐ ๋•Œ๋ฌธ์ž…๋‹ˆ๋‹ค. ํ‘œํ˜„์‹์˜ ์ผ๋ถ€๋ฅผ ๊ด„ํ˜ธ๋กœ ๋ฌถ์–ด ์ด ์šฐ์„  ์ˆœ์œ„๋ฅผ ๋ฌด์‹œํ•˜๊ฑฐ๋‚˜ ์˜๋„ํ•œ ํšจ๊ณผ๋ฅผ ๋ช…์‹œ์ ์œผ๋กœ ๋ช…ํ™•ํ•˜๊ฒŒ ํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค. ์ฐจ์ด์ ์„ ํ™•์ธํ•˜์‹ญ์‹œ์˜ค.

x = 5 + (7 % 2);    // x = 6 (same as without parenthesis)
x = (5 + 7) % 2;    // x = 0
 


๊ฐ€์žฅ ํฐ ์šฐ์„  ์ˆœ์œ„์—์„œ ๊ฐ€์žฅ ์ž‘์€ ์šฐ์„  ์ˆœ์œ„๋กœ C++ ์—ฐ์‚ฐ์ž๋Š” ๋‹ค์Œ ์ˆœ์„œ๋กœ ํ‰๊ฐ€๋ฉ๋‹ˆ๋‹ค.

์ˆ˜์ค€์šฐ์„ ์ˆœ์œ„ ๊ทธ๋ฃน์šด์˜์ž์„ค๋ช…๊ทธ๋ฃนํ™”

Level Precedence group Operator Description Grouping
1 ๋ฒ”์œ„ :: ๋ฒ”์œ„ ํ•œ์ •์ž ์™ผ์ชฝ์—์„œ ์˜ค๋ฅธ์ชฝ์œผ๋กœ
2 ์ ‘๋ฏธ์‚ฌ(๋‹จํ•ญ) ++ -- ํ›„์œ„ ์ฆ๊ฐ€/๊ฐ์†Œ ์™ผ์ชฝ์—์„œ ์˜ค๋ฅธ์ชฝ์œผ๋กœ
() ๊ธฐ๋Šฅ์  ํ˜•ํƒœ
[] ์•„๋ž˜ ์ฒจ์ž
. -> ํšŒ์› ์•ก์„ธ์Šค
3 ์ ‘๋‘์‚ฌ(๋‹จํ•ญ) ++ -- ์ ‘๋‘์‚ฌ ์ฆ๊ฐ€/๊ฐ์†Œ ์˜ค๋ฅธ์ชฝ์—์„œ ์™ผ์ชฝ์œผ๋กœ
~ ! ๋น„ํŠธ NOT / ๋…ผ๋ฆฌ NOT
+ - ๋‹จํ•ญ ์ ‘๋‘์‚ฌ
& * ์ฐธ์กฐ/์—ญ์ฐธ์กฐ
new delete ํ• ๋‹น/ํ•ด์ œ
sizeof ๋งค๊ฐœ๋ณ€์ˆ˜ ํŒฉ
(type) C ์Šคํƒ€์ผ ์œ ํ˜• ์ฃผ์กฐ
4 ํฌ์ธํ„ฐ ๋Œ€ ๋ฉค๋ฒ„ .* ->* ์•ก์„ธ์Šค ํฌ์ธํ„ฐ ์™ผ์ชฝ์—์„œ ์˜ค๋ฅธ์ชฝ์œผ๋กœ
5 ์‚ฐ์ˆ : ์Šค์ผ€์ผ๋ง * / % ๊ณฑํ•˜๊ธฐ, ๋‚˜๋ˆ„๊ธฐ, ๋ชจ๋“ˆ๋กœ ์™ผ์ชฝ์—์„œ ์˜ค๋ฅธ์ชฝ์œผ๋กœ
6 ์‚ฐ์ˆ : ๋”ํ•˜๊ธฐ + - ๋”ํ•˜๊ธฐ, ๋นผ๊ธฐ ์™ผ์ชฝ์—์„œ ์˜ค๋ฅธ์ชฝ์œผ๋กœ
7 ๋น„ํŠธ ์‹œํ”„ํŠธ << >> ์™ผ์ชฝ์œผ๋กœ ์ด๋™, ์˜ค๋ฅธ์ชฝ์œผ๋กœ ์ด๋™ ์™ผ์ชฝ์—์„œ ์˜ค๋ฅธ์ชฝ์œผ๋กœ
8 ๊ด€๊ณ„ํ˜• < > <= >= ๋น„๊ต ์—ฐ์‚ฐ์ž ์™ผ์ชฝ์—์„œ ์˜ค๋ฅธ์ชฝ์œผ๋กœ
9 ํ‰๋“ฑ == != ํ‰๋“ฑ / ๋ถˆํ‰๋“ฑ ์™ผ์ชฝ์—์„œ ์˜ค๋ฅธ์ชฝ์œผ๋กœ
10 ๊ทธ๋ฆฌ๊ณ  & ๋น„ํŠธ AND ์™ผ์ชฝ์—์„œ ์˜ค๋ฅธ์ชฝ์œผ๋กœ
11 ๋…์  ๋˜๋Š” ^ ๋น„ํŠธ XOR ์™ผ์ชฝ์—์„œ ์˜ค๋ฅธ์ชฝ์œผ๋กœ
12 ํฌํ•จ ๋˜๋Š” | ๋น„ํŠธ OR ์™ผ์ชฝ์—์„œ ์˜ค๋ฅธ์ชฝ์œผ๋กœ
13 ์ ‘์†์‚ฌ && ๋…ผ๋ฆฌ์  AND ์™ผ์ชฝ์—์„œ ์˜ค๋ฅธ์ชฝ์œผ๋กœ
14 ๋ถ„๋ฆฌ || ๋…ผ๋ฆฌ์  OR ์™ผ์ชฝ์—์„œ ์˜ค๋ฅธ์ชฝ์œผ๋กœ
15 ํ• ๋‹น ์ˆ˜์ค€ ํ‘œํ˜„์‹ = *= /= %= += -=
>>= <<= &= ^= |=
ํ• ๋‹น / ๋ณตํ•ฉ ํ• ๋‹น ์˜ค๋ฅธ์ชฝ์—์„œ ์™ผ์ชฝ์œผ๋กœ
?: ์กฐ๊ฑด ์—ฐ์‚ฐ์ž
16 ์‹œํ€€์‹ฑ , ์‰ผํ‘œ ๊ตฌ๋ถ„ ๊ธฐํ˜ธ ์™ผ์ชฝ์—์„œ ์˜ค๋ฅธ์ชฝ์œผ๋กœ

 

๋Œ“๊ธ€