๋ณ์์ ์์๋ฅผ ์ฐ์ฐ์๋ฅผ ์ฌ์ฉํ์ฌ ์ฐ์ฐ ์์ ์ ํ ์ ์์ต๋๋ค . ๋ค์์ ์ ์ฒด ์ฐ์ฐ์ ๋ชฉ๋ก์ ๋๋ค. ์ด ์์ ์์ ๋ชจ๋ ํญ๋ชฉ์ ์ ํ์๋ ์์ง๋ง ์ฐธ์กฐ์ฉ์ผ๋ก๋ ์ฌ์ฉํ ์ ์๋๋ก ๋ชจ๋ ์ฌ๊ธฐ์ ๋์ด๋์ด ์์ต๋๋ค.
๋์ ์ฐ์ฐ์(=)
๋์ ์ฐ์ฐ์๋ ๋ณ์์ ๊ฐ์ ํ ๋นํฉ๋๋ค.
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 | ์ํ์ฑ | , | ์ผํ ๊ตฌ๋ถ ๊ธฐํธ | ์ผ์ชฝ์์ ์ค๋ฅธ์ชฝ์ผ๋ก |
'๐ Development Study > ๐ป Win32API' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
๋ช ๋ น๋ฌธ ๋ฐ ํ๋ฆ ์ ์ด (0) | 2022.08.18 |
---|---|
๊ธฐ๋ณธ ์ ์ถ๋ ฅ (0) | 2022.08.17 |
์์ (0) | 2022.08.17 |
๋ณ์ ๋ฐ ์ ํ (0) | 2022.08.17 |
ํ๋ก๊ทธ๋จ์ ๊ตฌ์กฐ (0) | 2022.08.17 |
๋๊ธ