-/1. 기본적인 연산자/-
사칙 연산
-----------------------------------------------------------------------
#include <iostream>
using namespace std;
int main()
{
// 계산에 사용할 값 정의
int a = 8;
int b = 4;
// 사칙 연산을 한다.
int c = a + b; // 덧셈
int d = a - b; // 뺄셈
int e = a * b; // 곱셈
int f = a / b; // 나눗셈
int g = a % b; // 나눗셈의 나머지
// 결과 출력
cout << "8 + 4 = " << c << "\n";
cout << "8 - 4 = " << d << "\n";
cout << "8 * 4 = " << e << "\n";
cout << "8 / 4 = " << f << "\n";
cout << "8 % 4 = " << g << "\n";
return 0;
}
-----------------------------------------------------------------------
point
1. 사칙 연산을 담는 방법은
기존의 변수와 같이 우변에서 변수혹은 공식소스들이
처리되어 좌변의 변수에 삽입되는 형태이다.
2,. /기호는 나눗셈이며 %는 나눗셈의 나머지가 기록된다.
3. 위와같은 변수를 피연산자라고 부른다.
피연산자는 숫자도 변수도 될 수도 있기 때문이다.
대입 연산자
-----------------------------------------------------------------------
int main()
{
// 실험에 사용할 변수 정의
int a, b, c;
// 대입 연산의 결과를 다시 대입
a = b = c = 100;
return 0;
}
-----------------------------------------------------------------------
point
1. a, b, c의 변수는 모두 100의 값을 가지게 된다.
2. 모든 연산자가 그러는것은 아니지만 대부분의 연산자와
대입 연산자 에서는 연산이 오른쪽에서 왼쪽으로
수행되도록 C++에 정해져있다.
관계 연산자
-----------------------------------------------------------------------
#include <iostream>
using namespace std;
int main()
{
// 피연산자를 정의한다.
int a = 3;
int b = 5;
// 관계 연산자 사용
bool b1, b2, b3, b4, b5, b6;
b1 = a > b; // a가 b보다 크다
b2 = a >= b; // a가 b보다 크거나 같다
b3 = a < b; // a가 b보다 작다
b4 = a <= b; // a가 b보다 작거나 같다
b5 = a == b; // a와 b가 같다
b6 = a != b; // a와 b가 같지 않다
// bool 타입의 값을 문자로 출력하게 만든다.
cout << boolalpha;
// 결과를 출력
cout << a << " > " << b << " = " << b1 << "\n";
cout << a << " >= " << b << " = " << b2 << "\n";
cout << a << " < " << b << " = " << b3 << "\n";
cout << a << " <= " << b << " = " << b4 << "\n";
cout << a << " == " << b << " = " << b5 << "\n";
cout << a << " != " << b << " = " << b6 << "\n";
return 0;
}
-----------------------------------------------------------------------
point
1. 관계연산자의 역활을 피연산자의 참과 거짓을
주어진 공식대로 판별하는 것이 역활이다.
2. 연산자의 연산 우선 순서의 대부분은 현대 수학의
수식 연산 우선 순서와 일치하게 C++에 정의 되어있다.
3. boolalpha은 bool값의 0과 1을
false와 ture로 출력되도록 만들어준다.
AND 연산자
-----------------------------------------------------------------------
#include <iostream>
using namespace std;
int main()
{
// 모든 경우의 AND 현산 수행
bool b1, b2, b3, b4;
b1 = false && false;
b2 = false && true;
b3 = true && false;
b4 = true && true;
// 결과를 출력
cout << boolalpha;
cout << "false AND false = " << b1 << "\n";
cout << "false AND true = " << b2 << "\n";
cout << "true AND false = " << b3 << "\n";
cout << "true AND true = " << b4 << "\n";
return 0;
}
-----------------------------------------------------------------------
point
1. AND 연산은 두 개의 bool 타입 피연산자를 취하며
피연산자의 값이 모두 true인 경우에만 true의 결과 값을 반환한다.
관계 연산자와 논리 연산자를 함께 사용하기
-----------------------------------------------------------------------
#include <iostream>
using namespace std;
int main()
{
// 정보를 보관할 변수 정의
int age; // 나이
bool male; // 남성인가?
// age, male 값을 입력 받는다.
// (입력 받는 법 진도미달, 집적 대입한다)
age = 20; // 20세
male = ture; // 남성
// 조건을 만족하는지 검사한다.
bool ok; // 자격을 갖춘 사람인가?
ok = age > 19 && male == true;
return 0;
}
-----------------------------------------------------------------------
point
1. ok = age > 19 && male == true;에서
변수 age와 변수 male이 모두 true값을 얻을경우
true로 결과 값이 반환된다.
tip
1. AND와 OR 연산자
|
피연산자1 |
피연산자2 |
AND(&&) 결과 |
OR(||) 결과 |
|
false |
false |
false |
false |
|
false |
true |
false |
true |
|
true |
false |
false |
true |
|
true |
true |
true |
true |
AND, OR 연산자 함께 사용하기
-----------------------------------------------------------------------
int main()
{
// 키와 시력을 보관할 변수를 정의한다.
int height;
float eyesight;
// height, eyesight 값을 입력 받는다.
// 진도 미달 소스 코드 상에 집정 대입한다.
height = 175;
eyesight = 0.8f;
// 조건을 만족하는지 검사한다.
bool ok; // 자격을 갖춘 사람인가?
ok = height >= 160 && height <= 180 ||
eyesight >= 1.0f && eyesight <= 2.0f;
return 0;
}
-----------------------------------------------------------------------
point
1. OR 연산자는 피연산자 둘중 하나만
만족해도 true로 결과 값이 반환된다.
2. ok = height >= 160 && height <= 180 || eyesight >= 1.0f && eyesight <= 2.0f;
의 코드경우 이런방식의 코딩보단 가능한 괄호를 사용하여
ok = (height >= 160 && height <= 180) || (eyesight >= 1.0f && eyesight <= 2.0f);
와 같이 정리하여 가독성을 높이는 것이 좋다.
tip
1. &&와 ||의 연산방식은 조건만 맞으면
나머지 연산은 아예 처리조차 하지않는다.
AND 연산자 라면 둘중 하나만 false여도 결과는
false가 되기에 예를 들어서
int a,b;
a = 1;
b = 2;
bool b1;
b1 = (a >b) && (b = 10);
와 같은 연산경우 첫번째 a>b 에서 false임으로
뒤의 b=10의 연산은 연산조차 하지 않는다.
NOT 연산자
-----------------------------------------------------------------------
#include <iostream>
using namespace std;
int main()
{
// ! 연산자의 사용
bool b1, b2;
b1 = !true;
b2 = !false;
// 결과 출력
cout << boolalpha;
cout << "NOT true --> " << b1 << "\n";
cout << "NOT false --> " << b2 << "\n";
return 0;
}
-----------------------------------------------------------------------
point
1. NOT 연산자는 하나의 피연산자만을 받으며
피연산자의 값이 true라면 false를, false라면 true를 반환한다.
2. 사용법으로는 드모르간 법칙이있다.
(A AND B) = NOT (NOT A OR NOT B)
C++ 코드로 고치면
(A && B) = !(!A || !B)
가된다.
-/2. 비트단위 연산/-
정수 값을 2진수로 출력
-----------------------------------------------------------------------
#include <bitset> // bitset 사용을 위한 준비 작업
#include <iostream>
using namespace std;
int main()
{
// 다양한 타입의 변수를 준비한다.
char c = 1;
short int si = 2;
int i = 4;
// 각각 2진수와 10진수로 출력한다.
cout << "c = " << bitset<8>(c) << "(" << (int)c << ")\n";
cout << "si = " << bitset<16>(si) << "(" << si << ")\n";
cout << "i = " << bitset<32>(i) << "(" << i << ")\n";
return 0;
}
-----------------------------------------------------------------------
point
1. bitset<8>(c)와 같이 소스를 작성하면
<>에는 원하는 만큼의 비트 자리수만큼
()안의 변수를 2진수로 출력해 준다.
tip
1. 2진수를 10진수, 16진수로 변환하는 방법
2 -> 10진수 경우
|
512 |
256 |
128 |
64 |
32 |
16 |
8 |
4 |
2 |
1 |
|
1 |
0 |
1 |
0 |
1 |
1 |
0 |
1 |
0 |
1 |
보기와같은 2진수를 10진수로 변환할경우 693으로 변환이 된다.
2 -> 16진수 경우
|
1 0 |
1 0 1 1 |
0 1 0 1 |
|
2 |
11 |
5 |
|
2 |
B |
5 |
(10~15는 각각 A, B, C, D, E, F로 표기한다.)
2. 10진수, 16 진수를 2진수로 변환하는 방법
10 -> 2진수 경우
693| 1
346| 0
173| 1
86| 0
43| 1
21| 1
10| 0
5| 1
2| 0
1
10진수를 더 이상 나눌수 없을 때까지 2로나눈 다음
거꾸로 나열하여 쓰면 2진수로 변환된다.
16 -> 2진수 경우
|
2 |
B |
5 |
|
0 0 1 0 |
1 0 1 1 |
0 1 0 1 |
3. 흔히 비트 단위의 연산을 할 때는 16진수를 증겨 사용한다.
1, 2번의 예와같이 10진수를 이용할때보다 16진수의 경우가 2진수 변환이
용이하고 또한 실수가 적어지며 문자의 길이가 다소 짧아
덜 헷갈리고 가독성 또한 용이해지기 때문이다.
4. 비트 단위 논리 연산자는 한 비트를 대상으로 논리 연산을 수행한다.
이 비트 단위 논리 연산자는 피연산자의 각 비트에 대해서 논리 연산을 수행하며
이를 위한 연산자가 모두 4가지가있다.
각각 AND, OR, NOT, XOR을 의미하는 &, |, ~, ^가 있다.
이 연산자들의 피연산자는 일반적으로 정수 타입의 값이 되며
각 피연산자의 각 비트 별로 논리 연산을 수행한다.
예를 들어 32비트 정수라면 32번의 논리 연산을 수행한다.
비트 단위 논리 연산자 연산의 결과표
|
피연산자1의 i번째 비트 |
피연산자2의 i번째 비트 |
결과 값의 i번째 비트 | ||
|
AND |
OR |
XOR | ||
|
0 |
0 |
0 |
0 |
0 |
|
0 |
1 |
0 |
1 |
1 |
|
1 |
0 |
0 |
1 |
1 |
|
1 |
1 |
1 |
1 |
0 |
비트 단위 NOT 연산의 결과표
|
피연산자1의 i번째 비트 |
결과 값의 i번째 비트 |
|
NOT | |
|
0 |
1 |
|
1 |
0 |
비트 단위 논리 연산자의 사용
-----------------------------------------------------------------------
#include <bitset>
#include <iostream>
using namespace std;
int main()
{
// 피연산자를 준비한다.
unsigned char a, b;
a = 178;
b = 113;
// 비트 단위 논리 연산을 수행
unsigned char c1, c2, c3, c4;
c1 = a & b; // AND
c2 = a | b; // OR
c3 = a ^ b; // XOR
c4 = ~a; // NOT
// 결과를 출력한다.
// 괄호 안에는 10진수가 출력된다.
cout << "a = " << bitset<8>(a) << "(" << (unsigned int)a << ")\n";
cout << "b = " << bitset<8>(b) << "(" << (unsigned int)b << ")\n";
cout << "a & b = " << bitset<8>(c1) << "(" << (unsigned int)c1 << ")\n";
cout << "a | b = " << bitset<8>(c2) << "(" << (unsigned int)c2 << ")\n";
cout << "a ^ b = " << bitset<8>(c3) << "(" << (unsigned int)c3 << ")\n";
cout << "~a = " << bitset<8>(c4) << "(" << (unsigned int)c4 << ")\n";
return 0;
}
-----------------------------------------------------------------------
point
1. 이 소스에서 연산자를 char로 선언하고 밑에서 int로 출력하는것은
char타입은 8비트의 짧은 길이를 가져 보기 편하게 하기 위함이고
int로 출력하는것은 char 선언할경우 문자로 출력되기 때문이다.
2. 이 소스의 비트 단위 논리 연산을 수행 하는 부문의 설명
|
c1의 AND연산 |
c2의 OR연산 |
c3의 XOR연산 |
c4의 NOT연산 |
a = 10110010<178> b = 01110001<113> c = 00110000<48> |
a = 10110010<178> b = 01110001<113> c = 11110011<243> |
a = 10110010<178> b = 01110001<113> c = 11000011<195> |
a = 10110010<178> c = 01001101<77> |
tip
1. 비트단위 논리 연산자는 어디에 쓰일까.
가까운 예로 우리는 화면을 출력하는 소스에서 볼수있다.
특히 윈도우의 디스플레이 등록 정보 >> 속성에 보면은
색 품질에 16비트(트루컬러) 라는 용어를 접할수 있느대
이때 16비트 칼라는 1dot의 색상을 표시 하는대 16비트를 사용한다는 뜻이다.
대개는 RGB 당 5 6 5 비트를 할당하여 쓰거나
혹은 각각 5비트씩 할당하고 1비트는쓰지 않는 경우도 있다.
파랑색 부분의 값 구하기
-----------------------------------------------------------------------
#include <bitset>
#include <iostream>
using namespace std;
int main()
{
// 한 점의 색상을 보관하는 변수
// (임의의 값을 넣어둔다)
unsigned short color = 0x1234;
// 파란색을 제외한 나머지 비트를 지운다.
// 0x001f는 2진수로 0000 0000 0001 1111이다.
unsigned short blue;
blue = color & 0x001f;
// 결과 출력
cout <<"color = " << bitset<16>(color) << "(" << color << ")\n";
cout << "blue = " << bitset<16>(blue) << "(" << blue << ")\n";
return 0;
}
-----------------------------------------------------------------------
point
1. 0x001f는 2진수로 0000 0000 0001 1111이다.
2. blue = color & 0x001f;와 같은 소스는 특정 부분의
값을 추출하고자 하는 필터로써 이런 용도의
비트 단위 AND 연산을 마스킹이라고 부른다.
blue = color & 0x001f; 소스의 연산에 따른 마스킹
color = 0001001000110100<4660>
0x001f = 0000000000011111<31> AND
blue = 0000000000010100<20>
녹색 부분의 값 구하기
-----------------------------------------------------------------------
#include <bitset>
#include <iostream>
using namespace std;
int main()
{
// 한 점의 색상을 보관하는 변수
// (임의의 값을 넣어둔다)
unsigned short color = 0x1234;
// 녹색을 제외한 나머지 비트를 지운다.
// 0x07e0은 2진수로 0000 0111 1110 0000이다.
unsigned short green_temp;
green_temp = color & 0x07e0;
// 녹색의 비트들을 오른쪽 끝으로 이동시킨다.
unsigned short green;
green = green_temp >> 5;
// 결과 출력
cout <<" color = " << bitset<16>(color) << "(" << color << ")\n";
cout <<"green_temp = " << bitset<16>(green_temp) << "(" << green_temp << ")\n";
cout <<" green = " << bitset<16>(green) << "(" << green << ")\n";
return 0;
}
-----------------------------------------------------------------------
point
1. 0x07e0은 2진수로 0000 0111 1110 0000이다.
2. green_temp = color & 0x07e0;의 소스로
마스킹을 해서 녹색값을 추출한다.
3. green = green_temp >> 5;와 같은 소스는
쉬프트 연산이라 하여 비트들의 자리를 옮길 수 있다.
쉬프트 연산을 하면서 옴겨지는 자리만큼 옴겨지는 방향의
반대쪽에는 0으로 채워진다.
(>> 는 오른쪽 << 는 왼쪽, >> 5는 오른쪽으로 5칸)
빨간색 부분의 값 바꾸기
-----------------------------------------------------------------------
#include <bitset>
#include <iostream>
using namespace std;
int main()
{
// 한 점의 색상을 보관하는 변수
// (임의의 값을 넣어둔다)
unsigned short color = 0x1234;
// 빨간색 부분의 비트들을 0으로 만든다.
// 0x07ff는 2진수로 0000 0111 1111 1111이다.
unsigned short color_temp;
color_temp = color & 0x07ff;
// 새로운 빨간색의 값을 준비한다.
unsigned short red = 30;
// 빨간색의 값을 왼쪽 끝으로 옮긴다.
unsigned short red_temp;
red_temp = red << 11;
// 빨간색의 값을 색상에 넣는다.
unsigned short color_finished;
color_finished = color_temp | red_temp;
// 결과 출력
cout <<" color = " << bitset<16>(color) << "(" << color << ")\n";
cout <<" color_temp = " << bitset<16>(color_temp) << "(" << color_temp << ")\n";
cout <<" red = " << bitset<16>(red) << "(" << red << ")\n";
cout <<" red_temp = " << bitset<16>(red_temp) << "(" << red_temp << ")\n";
cout <<"color_finished = " << bitset<16>(color_finished) << "(" << color_finished << ")\n";
return 0;
}
-----------------------------------------------------------------------
point
1. 0x07ff는 2진수로 0000 0111 1111 1111이다.
2. 빨간색 부분의 값 바꾸기 소스를 설명하면
R의 밝기를 30으로 바꾸기위하여
color_temp = color & 0x07ff;마스킹 과정으로
빨강색값을 지운후
red를 선언한, 30의 값을 집어 넣은후
red를 왼쪽으로 11칸 쉬프트 연산후
red_temp에 저장한후
color_finished = color_temp | red_temp;
으로 합쳐 새로운 색깔을 만들었다.
tip
1. <<의 다양한 용도?
cout 객체로 환면에정보를 출력할떄도, 쉬프트 연산 하는 데도 <<를사용했었다.
cout 경우는 소스 왼쪽에 cout 객체가 있다면 화면에 출력하라는 의미이고
정수가 있으면 왼쪽으로 쉬프트하라는의미가 된다.
이는 C++의 모체가 되는 C 언어에서는 쉬프트 연산 기능만 존재 한다.
하지만 C++에서 연산자 오버로딩의 기능을 지원하면서 사용자가
연산자의 용도를 마음껏 확장하는 것이 가능해졌다.
부호 있는 값의 쉬프트
-----------------------------------------------------------------------
#include <bitset>
#include <iostream>
using namespace std;
int main()
{
// unsigned와 signed 변수에 같은값을 넣는다.
unsigned short us = 0xff00;
short s = (short)0xff00;
// 동일한 쉬프트를 수행한다.
unsigned short us_shift = us >> 4;
short s_shift_r = s >> 4;
// 결과 출력
cout << " us = " << bitset<16>(us) << "(" << us << ")\n";
cout << " s = " << bitset<16>(s) << "(" << s << ")\n";
cout << "us >> 4 = " << bitset<16>(us_shift) << "(" << us_shift << ")\n";
cout << " s >> 4 = " << bitset<16>(s_shift_r) << "(" << s_shift_r << ")\n";
return 0;
}
-----------------------------------------------------------------------
point
1. unsigned short us_shift = us >> 4;와 같이 쉬프트 연산을
하는데 있어서 값 대신 변수를 집어 넣어 연산 할 수도 있다.
2. us와 s 변수의 내부적인 상태는 동일하나 변수의
해석 방식의 차이로 인하여 us는 65280이 s는 -256이 된다.
(unsigned short 타입이 경우에는 새로 추가하는 비트의 값이
0인 반면에 signed short 타입의 경우에는 1의 값으로 설정한다.
이러한 차의 점은 컴퓨터가 부호를 유지하기 위한 작동이기 때문이다.
결과에서 -값을 유지하기 위하여 1을 채워넣는 것이다.
반대로 왼쪽으로 쉬프트 하는 경우는 부호에 관계없이 0으로 채워진다.
tip
1. 쉬프트 연산은 곱하기로 이용 할 수있다.
쉬프트 연산의 정의는 비트를 이동하는 것이지만,
곱하기 혹은 나누기를 대신 할수도 있다.
1비트씩 쉬프트 하면 곱하기 2의(2ⁿ) 효과가 있다.
예로
3 = 00000011 = 3
3 << 1 = 00000110 = 3 * 2
3 << 2 = 00001100 = 3 * 4
3 << 3 = 00011000 = 3 * 8
반대로 오른쪽으로 쉬프트하는 경우에는
나누기 2의(2ⁿ) 효과가 있다.
이런쓰기 방식은 C의 논리 과정을 거치지않고 비트로 집적
연산 해주기에 게임과 같이 속도와 최적화가 필요한 종목에선 자주쓰인다.
예로 어떤 변수에 320을 곱해야 하는 경우에는
(x << 8) + (x << 60)와 같이 쓸수 있다.
위를 풀면
(x * 2^8) + (x * 2^6)
x * (256 + 64)
x * 320
이 된다.
++, -- 연산자의 사용
-----------------------------------------------------------------------
#include <iostream>
using namespace std;
int main()
{
// 4개의 변수를 동일한 값으로 채운다.
int A, B, C, D;
A = B = C = D = 3;
// 다양하게 ++, -- 연산자를 사용한다.
int ppA, Bpp, mmC, Dmm;
ppA = ++A;
Bpp = B++;
mmC = --C;
Dmm = D--;
// 결과를 출력한다.
cout << " A, B, C, D : " << A << ", " << B << ", " << C << ", " << D << "\n";
cout << " ++A, B++, --C, D-- : " << ppA << ", " << Bpp << ", " << mmC << ", " << Dmm << "\n";
return 0;
}
-----------------------------------------------------------------------
point
1. // 다양하게 ++, -- 연산자를 사용한다.
int ppA, Bpp, mmC, Dmm;
ppA = ++A;
Bpp = B++;
mmC = --C;
Dmm = D--;
이소스의 출력은 각각
A, B, C, D : 4, 4, 2, 2
++A, B++, --C, D-- : 4, 3, 2, 3
의 결과가 나온다.
먼저 ++이 뒤에 선언 된경우는 증강 연산이 된후
삽입될 변수에 전달하고 다음 소스로 넘어간다.
++이 앞에선언 된경우는 삽입될 변수를 먼저 전달하고
증강 연산을 처리후에 다음 소스로 넘어간다.
나머지또한 동일하다.
ppA = ++A;
를 풀으면
A = A + 1;
ppA = A;
Bpp = B++;
를 풀으면
Bpp = B;
B = B + 1;
이 된다.
tip
1. 연산자의 축약형
|
축약형 |
같은 의미의 수식 |
|
a += b; |
a = a + b; |
|
a -= b; |
a = a - b; |
|
a *= b; |
a = a * b; |
|
a /= b; |
a = a / b; |
|
a %= b; |
a = a % b; |
|
a &= b; |
a = a & b; |
|
a |= b; |
a = a | b; |
|
a ^= b; |
a = a ^ b; |
|
a <<= b; |
a = a << b; |
|
a >>= b; |
a = a >> b; |
연산 중 발생하는 형변환
-----------------------------------------------------------------------
#include <iostream>
using namespace std;
int main()
{
// 동일한 값을 가진 변수를 선언한다.
int i = 10;
float f = 10.0f;
// 두 변수를 동일한 수로 나눈다.
float i_div_4, f_div_4;
i_div_4 = i / 4;
f_div_4 = f / 4;
// 결과 출력
cout << "i = " << i << "\n";
cout << "f = " << f << "\n";
cout << "i / 4 = " << i_div_4 << "\n";
cout << "f / 4 = " << f_div_4 << "\n";
return 0;
}
-----------------------------------------------------------------------
point
1. C++의 연산 중의 형변환은 오직 피연산자의 타입에만 영향을 받는다.
결과를 받는 변수의 타입은아무런 영향을 받지 않는다.
즉 i_div_4 = i / 4;부분에서 피연산자가 모두
int 타입이므로 결과 역시 int 타입이 된다.
그렇기 때문에 소수점 이하 부분이 짤린 2를 반환한다.
이와 달리 f_div_4 = f / 4;부분에서는 피연산자의 한 쪽이
float 타입이기 때문에 다른 한 쪽, 즉 4도 float 타입으로 형변환한다.
결과 역시 float 타입이 되고 2.5를 반환하는 것이다.
tip
1. 만약 피연산자 중 한 쪽은 long 타입이고 다른 한 쪽은 float 타입이다.
이경우 두 타입의 덧셈을 수행 할경우 규칙에 의하면 long 타입의 피연산자가
float 타입으로 형변환한 후에 덧셈을 실행한다.
C++에서는 이렇게 피연산자의 타입이 동일하지 않은 경우에
형변환을 통해서 타입을 일치하는 규칙이 있다.
이런 형변환의 기본 규칙은 간단하게 두연산자 중에서 보다
큰 타입 쪽으로 형변환이 발생하는 것이다.
long double > double > float > unsigned long > long > usigned int > int가
일반적인 순서다.
int보다 작은 타입들은 정수형 승진이라는 과정을 통해 자동적으로
int혹은 unsigned int로 형변환하기에 순서에 존재하지는 않는다.
2. long int와 unsigned int
한 가지 예외는 피연산자의 한 쪽이 long 타입이고 다른 한 쪽이
unsigned int 타입인 경우에는 두 가지가능성이 있다.
기본 규칙에 의하면 나머지 한 쪽이 long 타입으로 형변환해야 하지만,
만약에 long 타입이 unsigned int 타입의 값을 보관할 수 없는 경우라면
두 피연산자 모두 unsigned long 타입으로 형변환한다.
invalid-file'보관소 ▦ ━━ > 작업 기록' 카테고리의 다른 글
| [프롤로그] (0) | 2008.06.14 |
|---|---|
| 슈팅게임 (시스탬 프로그래밍) (3) | 2008.06.14 |
| 1-3 정보의 종류 (0) | 2008.06.14 |
| 1-2 변수 정보를 담는 방법 (0) | 2008.06.14 |