C++은 많은 스크립트 언어와 달리 타입 제약이 엄격한(Strongly-Typed) 언어이다.

모든 변수는 타입을 가지며, 한 번 정해진 타입은 절대 변하지 않음

Intrinsic Type

char 컴파일러에 따라서 unsigned signed default가 다름(문자 혹은 짧은 숫자)

short

int

long

long long

unsigned

signed char을 제외하고는 default

singed, unsigned는 default로 int형 사용

float

double

long double long double은 double과 같거나 더 크다

일반적으로 float는 32비트(4byte), double은 64비트(8byte), long double은 80비트(10byte) 사용

bool 논리값(true | false)

변수는 가능한한 늦게 선언하는 것이 좋다.

일반적으로 변수를 처음 사용하기 직전에 선언하는 것이 좋으며, 초기화 할 수 있는 상태 이전에는 선언하지 않는 것이 좋다.

int i3=5;

auto i4=i3+7; // auto를 사용하면, i4가 자동으로 int형으로 선언됨

auto를 사용하면, 타입이 자동으로 정해지지만, 동일하게 유지하며, 무엇이든 int로 변형한뒤, i4에 할당함

Constant

const int ci1=2;

// const int ci3; error 발생(상수는 값을 지정해 주어야 함)

const float pi=3.141592;

const char cc='c';

const bool cmp=ci1<pi;

상수는 변수로 사용할 수 있는 곳 사용할 수 있다.(값이 수정되지 않아야 함)

상수들은 컴파일하는 동안 이미 그 값을 알고 있기 때문에, 다양한 최적화를 할 수 있음

(타입의 인수로 사용)

Literal

2 int(정수는 자릿수에 따라서 int, long, unsigned long 타입으로 구분)

2u unsigned

2l long

2ul unsigned long

2.0 double

2.0f float

2.0l long double

리터럴의 타입을 명시적(강제 변환, Coercion)으로 선언할 필요 없음

리터널의 특징

- 유용함

표준 라이브러리로 복소수를 제공한다. 이때, 실수부와 허수부의 타입은 사용자가 매개변수화 할 수 있음

std::complex<float> z(1.3, 2.4), z2;

// complex는 float형으로 정의했기 때문에 float형과만 연산 가능

// z2=2*z; int형과 계산 불가능

// z2=2.0*z; double형과 계산 불가능

z2=2.0f*z;

- 애매 모호함

함수를 서로 다른 인수 타입으로 오버로딩했을 때, 0과 같은 애매한 인수에 대하여

0u와 같이 한정된 인수는 정확하게 일치하는 타입이 있음

- 정확함

long double 타입은 double 보다 많은 값을 가질 수 있음

long double third1=0.333333333333333; // 값을 잃을 수 있음

long double third1=0.333333333333333l; // 더 정확하게 값을 가짐

2, 8, 16진수

int o=042; // int o1=34; 0으로 시작하는 리터널은 8진수를 의미

int h=0xfa; // int h2=250; 0x or 0X으로 시작하는 리터널은 16진수를 의미

int b=0b11111010; // int b=250; 0b or 0B로 시작하는 리터널은 2진수를 의미(C++ 14)

// C++14부터는 긴 숫자의 가독성을 위해서 `를 사용해서 숫자를 분리해도 무방

long d=6`546`686`616`861`129l;

unsigned long ulx=0x139`ae3b`2ab0`94f3;

//문자열 리터널은 기본적으로 char[]을 사용

char s1[]="Old C style";

// 혹은 string 타입을 통해 문자열 리터널에서 직접 생성

#include <string>

std::string s2="In C++ better like this";

// 긴 텍스트에 대하여 아래와 같이 부분 문자열로 분할 가능

std:string s3="This is a very long and clumsy text"

"that is too long for one line.";

Not Narrowd Initialization

초기화 할때, 지정된 타입보다 큰 값이 할당되게 되면, 앞쪽 일부 비트가 버려지게 된다.

C++ 11 부터는 데이터가 손실되지 않음(축소되지 않음, not Narrowed)를 확인하는 초기화를 도입

유니폼 초기화(Uniform Initialization), 중괄호 초기화(braced Initialization)

long l={1234567890123}; // 중괄호 안의 값들은 축소할 수 없음

컴파일러 축소 보호를 통해 값을 초기화 할 때, 정밀도를 잃지 않음을 확인할 수 있다.

int i1=3.14; // 축소되지만, 컴파일 됨

int i1n={3.14}; // 축소 오류: 소수 부분 소실

unsigned u2=-3; // 축소되지만, 컴파일 됨

unsigned u2n={-3}; // 축소 오류: 음수 불가능

double d;

float f2={d}; // 축소 오류 발생

unsigned u3={3};

int i2={2};

unsigned u4={i2}; //축소 오류: 음수 불가능

int i3={u3}; // 축소 오류: 큰 값 모두 나타낼 수 없음

범위(global & local)

Global Define

모든 함수의 바깥에 선언되며, 코드 어디에서나 참조할 수 있다.

전역 변수는 사용하지 않는 것이 좋다

Local Define

지역 변수는 함수 안에서 선언되며, 가시성/가용성은 해당 함수 선언부의 {} 이내로 제한된다.

int main(){

{const double pi=3.1415925435897932384;}

std::cout<<"pi is"<<pi<<".\n"; // 오류: pi는 {} 안에서만 사용 가능

}

변수 숨기기

같은 이름의 변수가 중첩된 범위에 있으면, 오직 하나의 변수만 볼 수 있다.

안쪽 범위에 있는 변수는 바깥쪽 범위에 있는, 이름이 같은 변수를 숨긴다.

int main()

{

int a=5; // a#1을 정의

{

a=3; // a#1을 할당

int a; // a#2를 정의

a=8; // a#2를 할당(a#1은 숨겨짐)

{

a=7; // a#2를 할당

}

a=11; // a#1에 할당(a#2 out of scope)

return 0;

}

위에서 a#1의 수명은 main() 함수가 끝날 때까지 이다.

그러나 a#1은 a#1의 선언 때부터, a#2의 선언 전까지만 보이고(가시성),

a#2를 포함하는 불록이 닫힌 후에 다시 보이게 된다.

동일한 범위에 같은 변수 이름을 두 번 정의하면, 오류가 발생

범위를 사용하면 바깥에 변수가 정의되어 있는지 신경쓰지 않아도 된다(충돌이 발생하지 않음)

namespace를 사용하면, 중첩과 접근성을 더욱 유용하게 관리할 수 있다.

(static 변수는 프로그램이 끝날 때 까지 살아있지만, 범위 안에서만 보인다.- 사용시 유의)

Variables