이전 포스트에서 나비에-스토크스 방정식을 이산화 하는 방법에 대해 알아보았다.

📘 유체 시뮬레이션(1) - Navier-Stokes 방정식

압력 투영(pressure projection)은 그리드를 이용하여 문제를 해결하지만, 이류(advection)는 압력을 이용한 해결이 어려워 그리드 내 입자를 이용하여 풀어야 했다.

그렇기 때문에 파티클에 대한 물리량을 그리드로 바꾸고 저장하는 과정과, 반대로 그리드의 물리량을 파티클에 저장하는 과정이 필요하다.

이 과정은 크게 PIC(Particle-In-Cell)과, FLIP(Fluid-Implicit-Particle) 두가지 방법으로 나뉜다.

이 중 특히 FLIP에 대하여 자세히 알아보고자 한다.

Ships, Splashes, and Waves on a Vast Ocean 논문에서는 전반적인 FLIP과정에서 Animating Sand as a Fluid 논문에 제시된 방법을 따랐다고 되어 있다.

따라서 Animating Sand as a Fluid 에서 사용한 방법을 기반으로 알아보았다.

FLIP pseudocode

1) 입자 값 q_p를 그리드 값 q_i,j,k로 바꾼다. 2) 그리드 값 q_i,j,k를 그리드에 저장한다. 3) 압력 투영, 외부 힘 등을 계산하여 그 결과인 q(new)_i,j,k를 얻는다. 4) 각각의 입자에 대해 그리드에서 변경된 값 (delta)q_i,j,k = q(new)_i,j,k - q_i,j,k를 보간하여 입자의 값에 추가한다. 5) 그리드 속도장 내 입자들에 이류를 적용한다.

(q: 물리량. 속도에 대해 다루고 있으므로 아래에서는 q를 u로 바꿔서 서술하였다)

각 단계들을 좀 더 자세히 살펴보자.

** 1,2) Particle to Grid - 입자의 값 q_p를 그리드 값 q_i,j,k로 바꾸고 저장 **

논문에서는 2x2x2 크기의 그리드 하나에 8개의 입자를 담았다.

그런다음 각 그리드 포인트는 근처 입자들의 가중 평균 값을 가지게 된다. 여기서 '근처'의 기준은 그리드 점을 중심으로 한 그리드 셀 폭의 2배인 큐브에 포함되는 것으로 정의하였다.

이걸 수식으로 나타내면 아래와 같을 것이다.

(점 A에 저장되는 속도의 값)

가중치는 standard trilinear weighting을 이용하였다고 되어 있다.

** 3) 압력 투영을 계산하여 그 결과인 q(new)_i,j,k를 얻는다. **

먼저 중력에 대한 힘을 계산해야 한다. 이건 간단하다. y성분의 속도를 g*timestep 만큼 증가시키면 된다.

그런 다음 압력 투영을 적용해야 한다. 이전 글에서 압력을 구하는 방정식인 포아송 방정식을 이산화 하고 이를 행렬 곱으로 표현하였다.

이렇게 표현된 식을 더 단순화 하여 Ap = d의 형태로 표현할 수 있다. 따라서 Ap = d로 부터 압력을 얻어야 하며 이 때 conjugate gradient method를 이용한다.

그리고 여기서 구해진 압력을 나비에-스토크스 방정식의 pressure projection과 관련된 수식에 넣으면 업데이트 된 물리량(여기선 속도)를 얻을 수 있다.

이렇게 해서 중력과 압력 투영이 적용된 새로운 물리량을 얻었다. PIC에서는 이 값을 그대로 기존 값과 바꾸지만 FLIP에서는 기존 값과 변경된 값의 차이를 이용한다.

** 4) 각각의 입자에 대해 그리드에서 변경된 값 (delta)q_i,j,k = q(new)_i,j,k - q_i,j,k를 보간하여 입자의 값에 추가한다. **

이렇게 새로운 속도에서 기존 속도를 뺀 값을 구한 다음, 그 값을 보간하여 기존 입자의 값에 추가해준다.

이를 수식으로 나타내면 아래와 같다.

위 수식에서 2D의 상황이라 가정하고 A,B,C,D 4개만 적었는데 실제로 우리는 3D를 다루니 4개가 아닌 8개의 그리드 지점에서 기록된 속도 변화를 삼선형 보간(trilinear interpolate)해야 된다.

** 5) 그리드 속도장 내 입자들에 이류를 적용한다. **

이제 중력과 압력 투영이 적용된 값을 입자에 업데이트 했으니, 입자에 이류를 적용하면 된다.

해당 논문에서는 CFL 조건에 의해 제한된 5개의 서브스텝들이 있는 RK2 ODE 솔버를 이용하였다고 되어 있다.

CFL은 적절한 time step을 구하는 것에 대한 조건으로 이를 적용하여 각 서브스텝에서 입자가 1개의 그리드 셀 이상을 움직이지 못하도록 한다.

RK2 ODE 솔버는 2차 Runge-Kutta 방법이다.

이전 포스트에서 이류를 해결하기 위해 semi-lagrangian 방법을 이용해서 입자의 현재 위치 Xg에서 과거 위치 Xp를 구할 때 아래와 같은 간단한 방법을 이용했었다.

여기서 좀 더 발전한 방법이 2차 Runge-Kutta 방법이다.

이런식으로 하나의 time step에서 두번에 걸쳐 Xp 값을 구하는 것이다. 1/2 timestep에서의 중간 위치를 구하고, 그 위치를 이용하여 최종적으로 Xp를 얻는 방법이다.

이제 정말로 Xp를 구했다. 입자가 시작된 위치 Xp를 알았으니 그 위치에서의 물리량만 알면 이류 문제가 해결된다.

그런데 과거의 위치 Xp가 현재 표현되고 있는 그리드에 없을 가능성이 있다. 그럴 경우 인근 그리드 포인트에서 보간하여 적절한 근사치를 얻을 수 있다.

여기서도 마찬가지로 삼선형 보간을 이용할 수 있다.

이렇게 하여 전반적인 FLIP이 적용되는 과정에 대해 알아보았다.

Ships, Splashes, and Waves on a Vast Ocean 논문을 이해하는 것을 목표로 Robert Bridson 의 Fluid Simulation for Computer Graphics 등을 기반으로 정리한 내용입니다.

1. Navier-Stokes 방정식

유체의 움직임을 제어하는 기본방정식은 나비에-스토크스 방정식이다.

위 식에서 u가 유체의 속도장을 의미한다. 참고로 마지막 항은 점성에 대한 것인데, 점성이 없는 물에 대해 다룰 것이므로 해당 항은 고려하지 않는다.

위 식이 나비에-스토크스 방정식이고, 아래 식은 유체가 비압축성이 되도록 하는 식이다. 즉 두 식을 이용하여 비압축성 유체의 움직임을 표현할 수 있다.

• *비압축성 유체란 ? * 압축을 가하였을 때 부피가 변하지 않는 유체, 다른 물리량(압력, 온도)등의 변화가 밀도에 영향을 미치지 않는 유체를 말한다. 대부분의 액체는 비압축성이다. 물이 꽉 차있는 페트병에 물을 압축시켜 더 채워넣을 수는 없다. 이게 비압축성을 의미한다. 그리고 기체는 압축성이다.

2. 오일러(Eulerian) 관점과 라그랑지안 (Lagrangian) 관점

연속체의 움직임에 대해 생각할 때, 운동을 추적하는 데는 두 가지 접근법, 라그랑지안 관점과 오일러 관점이 있다.

라그랑지안은 입자 하나하나를 따라가면서 이 입자가 어떻게 변하는지를 살펴보는 것이고, 오일러 관점에서는 입자를 추적하지 않고, 어느 고정된 '위치'를 기준으로 그 위치의 물리량이 어떻게 변하는지를 살펴본다.

예를 들어 온도 10도인 입자가 지나가고 온도 20도인 입자가 지나간다고 했을 때, 오일러 관점에서는 그 온도 10인 입자가 온도가 변하는지 안변하는지에는 관심이 없고 단지 여기 우리가 보고있는 위치의 온도가 10도에서 20도로 변했다 이런 관점으로 말하는 것이다.

라그랑지안 관점은 입자 시스템에, 오일러 관점은 고정된 그리드 시스템에 해당한다고 하기도 한다.

유체역학에서는 보통 오일러관점을 이용한다.

그런데 오일러 관점에서는 입자를 추적하지 않으니까 주어진 입자의 물리량이 얼마나 빠르게 변하는지, 예를 들어 가속도 같은 것들을 판단할 수 가 없다.

그래서 오일러 관점에서 물질을 추적하면서 미분하기 위해 등장한게 물질 미분(material derivate)이다.

어떤 물리량에 대한 수식(ex. q(t,x) - 시간 t, 위치 x에서 물리량 q의 값)를 그냥 통으로 미분해버리면 물질 미분식이 나온다.

그리고 이 물질 미분을 이용하여 아까 말한 나비에-스토크스 방정식을 표현하면, 오일러 관점에서의 비압축성 나비에-스토크스 방정식이 된다. 이게 논문에서의 주된 방정식이다.

3. Numerical Simulation - Split

이제 저 방정식으로 표현되는 유체를 컴퓨터로 시뮬레이션 하려면 이산화 과정이 필요하다. 이산화는 연속적인 수치를 이산적인, 불연속적인 수치로 변화시키는 것이다.

그러기 위해 먼저 복잡한 나비에-스토크스 방정식을 분할한다.

방정식을 3개로 나눈 다음, 어떤 항을 계산하고, 그 효과를 포함시키면서 갱신하고 이런식으로 진행된다.

나비에-스토크스 방정식을 아래처럼 3개로 쪼갠다.

** 1. 이류(advection) : ** 이류란 물리량(농도, 온도 등)의 차이로 인해 유체가 흐르는 것을 말한다. 우리는 속도에 관심이 있으므로 물리량 q를 아래처럼 u로 놓았다. 이류 항에서는 아래 간단한 이류 방정식을 풀면 된다.

논문에서는 초기 속도를 u-, 이류 후 속도를 u, 압력 투영 후 속도를 u+라고 보았다.

즉, 위 식을 풀어 우리는 u-에서 u로 값을 업데이트 한다.

그리고 여기다가 중력을 고려하면 된다. 그게 두번째 항이다.

** 2. body force : ** 부피 전체에 걸쳐 작용하는 힘이다. 여기서는 중력만을 의미하는 것으로 보인다.

** 3. 압력 투영 및 비압축성 (pressure projection + incompressibility) : ** 우리는 비압축성 유체를 다루기 때문에 비압축성 제약을 강제해야 한다. 그리고 그걸 하게 되는 항이 이 3번째 항이다. 압력이 부피가 축소되지 않도록 하는 일을 한다고 보기 때문에 여기서 이걸 고려한다.

여기서 일단 앞 식, 속도장을 시간에 대해 편미분 한 식을 이산화해보자.

시간에 대한 미분식을 이렇게 이산화 하면 3번째 항은 아래와 같이 변한다.

논문에서는 아래와 같이 pressure projection 후 속도 u+에 대한 식으로 표현하였다.

여기서 우리가 모르는 것 즉 구해야되는 것은 압력 P이다. 논문에서는 이를 구하기 위해 포아송 방정식(Poisson's equation)을 이용한다.

이 식을 푸는 방법이 BEM과 FLIP에서 다르다. BEM은 아직 공부하지 않았으니 우선 FLIP에서 이를 푸는 방법만 알아보자.

4. How to get Pressure

우선 기본적으로 포아송 방정식을 풀어 압력을 구하기 위해 유한차분(finite difference)을 이용한다.

유한차분이란 함숫값의 차를 이용해 미분계수를 근사하는 방법이다. 이렇게 말하면 잘 안와닿을 수 있는데,

아래와 같은 함수 f(x)가 있다고 가정해보자.

그럼 이 함수에서 도함수 f'(x)는 아래와 같이 근사할 수 있다.

이게 유한차분이다.

이걸 하는 이유는 포아송 방정식을 이산화하기 위해서이다.

그리고 2D 이상에서 이 유한차분을 실행하는 방법이 '그리드(Grid)'이다. 공간을 그리드로 차분화(Discretization)하여, 아래 그림 처럼 x의 성분, y의 성분, 압력 등을 다 다른 위치에 저장한다.

압력을 그리드의 중앙에, x성분을 세로선의 중앙에 u로, y성분을 가로선의 중앙에 v로 저장한다.

그럼 이걸 이용하여 아까 포아송 방정식의 첫번째 식의 우변(상수 제외)을 이산화해보자.

첫번째 식은 그냥 공식이다.

그리고 이걸 그리드 격자를 기반으로 이산화 한 것이 두번째 줄의 식이다.

그리고 이 식은 행렬의 곱으로 표현할 수 있다.

이 행렬곱을 보면 좌변이 div에 대한 식, 우변이 속도에 대한 식이라는 걸 알 수 있다. 즉 div를 이산화한게 저 좌변의 식이라는 거 같은데, 이건 좀 더 알아봐야 될 거 같다.

이렇게 해서 우변을 이산화 했다!

그럼 이제 같은 방법으로 좌변에서 divP를 이산화해보자.

마찬가지로 행렬 곱으로 나타내면 아래와 같다.

이렇게 하여 압력과 관련된 포아송 방정식을 모두 이산화 하였고, 행렬 곱으로까지 나타내었다 !

정리해보면 아래와 같다.

이렇게 해서 나비에-스토크스의 세번째 식, pressure projection이 얼추 해결되어 보인다.

그럼 이제 첫번째 식 advection을 이산화하는 방법에 대해 알아보자.

5. Semi-Lagrangian Advection

advection을 위에서 사용한 방법처럼 이산화하기는 어렵다.

대신 여기에서는 semi-Lagrangian method 라고 불리는 방법을 이용한다.

공간의 어떤 점 x에서 q의 새로운 값을 얻기 위해서는 개념적으로 x에 도달하는 입자를 찾아 q의 값을 구할 수 있다.

이 논리를 그리드에 적용한게 semi-Lagrangian method이다.

예시를 들어 자세히 살펴보면 다음과 같다.

그렇기 때문에 현재 어떤 그리드 포인트에서의 물리량을 알고 싶으면 속도장을 따라 역추적하면 된다.

그렇다면 Xp의 위치는 어떻게 알아낼까?

입자는 아래 방정식에 따라 ∆t의 시간동안 Xg까지 움직인다.

따라서 Xg의 위치로 Xp의 위치를 구하면 아래와 같다.

단순하게, u(Xg)는 속도에 관한 식이고, ∆t는 시간이니까 시간*속도해서 ∆t 시간동안 이동한 거리만큼을 빼준 것이다.

이런식으로 어떤 입자가 시작한 위치인 Xp를 구하고 나면, 이 Xp에서의 물리량 q가 현재 Xg에서의 물리량이 된다.

이렇게 해서 유체 시뮬레이션의 기본이 되는 나비에-스토크스 방정식을 3개로 분할하고, 각각을 이산화하는 방법에 대해 알아보았다.

다음 글에서는 FLIP에 대해 더 알아보도록 하자! 🙂

** 1) Diffuse **

디퓨즈는 난반사라고 보면 된다. 난반사는 디퓨즈 표면이라 불리는 이상적인 표면으로 들어온 빛이 모든 방향으로, 같은 강도로 반사되는 것을 말한다. 물체 표면 위 점 p에 들어오는 빛의 양을 정의하려면 점 p의 노멀과 빛 벡터 l을 내적하면 된다.

** n·l = |n||l|cosθ **

근데 빛이 들어오는 입사각이 90도 보다 크면 이게 음수가 된다. 빛의 세기가 음수가 될 순 없으므로 이 경우 n·l 을 0으로 처리해준다.

** max(n·l,0) **

위 식은 p에 들어오는 빛의 '강도'를 결정하는 식이다.

반사되는 빛의 색상은 다음과 같다.

** sd * md **

sd : 광원의 색상(RGB) md : 물체의 디퓨즈 계수(diffuse reflectance) (s : light source, m : material)

광도와 색상을 곱하면 퐁 모델의 디퓨즈 항이 완성된다.

** max(n·l,0) * (sd*md) **

** 2) Specular **

스페큘러는 정반사다. 이는 물체 표면에 하이라이트를 만드는데 사용된다.

아까 디퓨즈에서 난반사는 모든 방향으로 동일하게 반사되므로 카메라의 위치를 고려할 필요가 없었다. 그러나 정반사의 경우 카메라의 위치에 따라 빛이 들어오고 안들어오고가 달라지기 때문에 이를 고려해주어야 한다.

빛 벡터 l이 입사각 = 반사각으로 반사되는데, 그 반사되는 빛이 r이고 p에서 카메라를 향하는 벡터가 v다.

우선 반사 벡터 r을 계산해보면 ** r = 2n(n·l)-l ** 이다.

하이라이트를 볼 수 있는 영역은 r을 중심으로 한 원뿔 모양으로 묘사할 수있다. v가 원뿔 안에 놓이면 하이라이트를 볼 수 잇는 것이다.

원뿔 속에서 하이라이트가 감소되는 정도는 ** (r·v)^sh ** 이다.

sh : 매끈함의 정도. r과 v가 다른 경우 sh가 커질수록 하이라이트는 급격하게 감소한다.

퐁 모델의 스페큘러 항은 다음과 같다.

* (max(r·v, 0))^sh \ Ss * Ms **

Ss : 광원의 색상 Ms : 물체의 스페큘러 계수

Ss는 일반적으로 Sd와 같은 같을 가지고 Ms는 물체 표면의 하이라이트가 광원의 색을 반영하기 위해 gray-scale로 표현된다.

** 3) Ambient **

공간 내 다양한 물체로부터 반사된 빛을 앰비언트 빛 이라고 부른다. 이는 간접 조명에 해당한다. 앰비언트 반사는 아래와 같이 간단하게 정의된다. * Sa \ Ma **

Sa : 앰비언트 빛의 색상(RGB) Ma : 앰비언트 계수

최종적으로 퐁 모델은 앞서 다룬 3가지 항인 디퓨즈, 스패큘러, 앰비언트를 모두 더 해 아래와 같이 정의된다.

* max(n·l,0) * (sd*md) + (max(r·v, 0))^sh \ Ss * Ms + Sa * Ma **

위 내용을 참고하여 정리한 내용입니다.

Tutorial7 : 텍스처 매핑

📌 Texture Mapping

텍스처 매핑은 2D 이미지를 3D 형상에 투영하는 것을 말한다. 그리기 위해서는 표면의 점들이 2D 이미지와 어떻게 대응되는지 명시해야 한다.

이번 튜토리얼의 예시에서는 정점에 의해 텍스처 좌표가 결정되며, 보간된다.

📌 Creating a Shader Resource from the Texture and Sampler State

텍스처는 셰이더 리소스 뷰를 만드는 데 사용되는 2D 이미지이다.

hr = D3DX11CreateShaderResourceViewFromFile( g_pd3dDevice, L"seafloor.dds", NULL, NULL, 
         &g_pTextureRV, NULL );

셰이더가 필터링(filtering), addressing 등의 방식을 제어하는 sampler state를 만들어야 한다. 텍스쳐 addressing은 UV좌표가 0과 1 사이가 아닌 다른 값이 되었을 때, 어떻게 표현될 것인 지를 결정하는 옵션이다. sampler state를 생성하기 위해 D3D11Device::CreateSamplerState()를 호출한다.

    // Create the sample state
    D3D11_SAMPLER_DESC sampDesc;
    ZeroMemory( &sampDesc, sizeof(sampDesc) );
    sampDesc.Filter = D3D11_FILTER_MIN_MAG_MIP_LINEAR;
    sampDesc.AddressU = D3D11_TEXTURE_ADDRESS_WRAP;
    sampDesc.AddressV = D3D11_TEXTURE_ADDRESS_WRAP;
    sampDesc.AddressW = D3D11_TEXTURE_ADDRESS_WRAP;
    sampDesc.ComparisonFunc = D3D11_COMPARISON_NEVER;
    sampDesc.MinLOD = 0;
    sampDesc.MaxLOD = D3D11_FLOAT32_MAX;
    hr = g_pd3dDevice->CreateSamplerState( &sampDesc, &g_pSamplerLinear );

📌 Defining the Coordinates (좌표계 정의하기)

이미지를 큐브에 매핑하기 전에 먼저 큐브의 각 정점에 텍스처 좌표를 정의해야 한다. 사용된 좌표계는 [0, 1]로 표준화 되었다. (텍스처의 왼쪽 상단 모서리는 (0,0), 오른쪽 하단 모서리는 (1,1))

먼저 정점을 정의할 때 텍스처 좌표를 포함시켜 주었다.

struct SimpleVertex
{
    XMFLOAT3 Pos;
    XMFLOAT2 Tex;
};

그런 다음 셰이더에 input layout도 업데이트하여 포함시켜주었다.

// Define the input layout
D3D11_INPUT_ELEMENT_DESC layout[] =
{
    { "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0 },
    { "TEXCOORD", 0, DXGI_FORMAT_R32G32_FLOAT, 0, 12, D3D11_INPUT_PER_VERTEX_DATA, 0 },
};

input layout이 변경되었으므로 해당 정점 셰이더 입력도 일치하도록 수정해야 한다.

struct VS_INPUT
{
    float4 Pos : POSITION;
    float2 Tex : TEXCOORD;
};

마지막으로 정점에 대응되는 텍스처 좌표를 입력해준다. 큐브의 각 꼭지점은 텍스처의 모서리에 해당한다. 이렇게 하면 각 꼭짓점이 (0,0) (0,1) (1,0) 또는 (1,1)을 좌표로 갖는 단순 매핑이 만들어집니다.

// Create vertex buffer
SimpleVertex vertices[] =
{
    { XMFLOAT3( -1.0f, 1.0f, -1.0f ), XMFLOAT2( 0.0f, 0.0f ) },
    { XMFLOAT3( 1.0f, 1.0f, -1.0f ), XMFLOAT2( 1.0f, 0.0f ) },
    { XMFLOAT3( 1.0f, 1.0f, 1.0f ), XMFLOAT2( 1.0f, 1.0f ) },
    { XMFLOAT3( -1.0f, 1.0f, 1.0f ), XMFLOAT2( 0.0f, 1.0f ) },

    { XMFLOAT3( -1.0f, -1.0f, -1.0f ), XMFLOAT2( 0.0f, 0.0f ) },
    { XMFLOAT3( 1.0f, -1.0f, -1.0f ), XMFLOAT2( 1.0f, 0.0f ) },
    { XMFLOAT3( 1.0f, -1.0f, 1.0f ), XMFLOAT2( 1.0f, 1.0f ) },
    { XMFLOAT3( -1.0f, -1.0f, 1.0f ), XMFLOAT2( 0.0f, 1.0f ) },

    { XMFLOAT3( -1.0f, -1.0f, 1.0f ), XMFLOAT2( 0.0f, 0.0f ) },
    { XMFLOAT3( -1.0f, -1.0f, -1.0f ), XMFLOAT2( 1.0f, 0.0f ) },
    { XMFLOAT3( -1.0f, 1.0f, -1.0f ), XMFLOAT2( 1.0f, 1.0f ) },
    { XMFLOAT3( -1.0f, 1.0f, 1.0f ), XMFLOAT2( 0.0f, 1.0f ) },

    { XMFLOAT3( 1.0f, -1.0f, 1.0f ), XMFLOAT2( 0.0f, 0.0f ) },
    { XMFLOAT3( 1.0f, -1.0f, -1.0f ), XMFLOAT2( 1.0f, 0.0f ) },
    { XMFLOAT3( 1.0f, 1.0f, -1.0f ), XMFLOAT2( 1.0f, 1.0f ) },
    { XMFLOAT3( 1.0f, 1.0f, 1.0f ), XMFLOAT2( 0.0f, 1.0f ) },

    { XMFLOAT3( -1.0f, -1.0f, -1.0f ), XMFLOAT2( 0.0f, 0.0f ) },
    { XMFLOAT3( 1.0f, -1.0f, -1.0f ), XMFLOAT2( 1.0f, 0.0f ) },
    { XMFLOAT3( 1.0f, 1.0f, -1.0f ), XMFLOAT2( 1.0f, 1.0f ) },
    { XMFLOAT3( -1.0f, 1.0f, -1.0f ), XMFLOAT2( 0.0f, 1.0f ) },

    { XMFLOAT3( -1.0f, -1.0f, 1.0f ), XMFLOAT2( 0.0f, 0.0f ) },
    { XMFLOAT3( 1.0f, -1.0f, 1.0f ), XMFLOAT2( 1.0f, 0.0f ) },
    { XMFLOAT3( 1.0f, 1.0f, 1.0f ), XMFLOAT2( 1.0f, 1.0f ) },
    { XMFLOAT3( -1.0f, 1.0f, 1.0f ), XMFLOAT2( 0.0f, 1.0f ) },
};

📌 Bind Texture as Shader Resource (텍스처를 셰이더 리소스로 바인딩)

텍스처와 sampler state는 이전 튜토리얼에서 살펴본 Constant와 같은 객체이다. 셰이더가 사용하기 전에 ID3D11DeviceContext::PSSetSamplers(), ID3D11DeviceContext::PSSetShaderResources() 등을 호출해주어야 한다.

    g_pImmediateContext->PSSetShaderResources( 0, 1, &g_pTextureRV );
    g_pImmediateContext->PSSetSamplers( 0, 1, &g_pSamplerLinear );

이렇게 하면 셰이더에서 텍스처를 사용할 준비가 끝난다.

📌 Applying the Texture (텍스처 적용하기)

텍스처를 매핑하기 위해 픽셀 셰이더에서 texture lookup function을 호출한다. 2D 텍스처를 조회한 다음 샘플 색상을 반환한다.

아래 픽셀 셰이더는 이 함수를 호출하여 메시 색상(또는 머터리얼 색상)으로 곱한 다음 최종 색상을 출력한다.

• txDiffuse : 우리가 리소스뷰 g_pTextureRV를 바인딩할 때 전달된 텍스처를 저장하는 객체

// Pixel Shader
float4 PS( PS_INPUT input) : SV_Target
{
    return txDiffuse.Sample( samLinear, input.Tex ) * vMeshColor;
}

정점 셰이더를 통해 텍스처 좌표를 전달해야 한다.

// Vertex Shader
PS_INPUT VS( VS_INPUT input )
{
    PS_INPUT output = (PS_INPUT)0;
    output.Pos = mul( input.Pos, World );
    output.Pos = mul( output.Pos, View );
    output.Pos = mul( output.Pos, Projection );
    output.Tex = input.Tex;

    return output;
}

📌 Constant Buffers (상수 버퍼)

Direct3D 11에서 Constant Buffer를 사용하여 셰이더 상수(셰이더 변수)를 설정할 수 있다. Constant Buffer는 셰이더 상수를 업데이트하는데 필요한 bandwidth를 줄인다.

이전 튜토리얼에서는 하나의 Constant Buffer를 이용하여 필요한 모든 셰이더 상수를 보관했다. 그러나 Constant Buffer를 효율적으로 사용하는 가장 좋은 방법은 셰이더 변수를 업데이트 빈도에 따라 구성하는 것이다. 이를 통해 어플리케이션은 셰이더 상수를 업데이트 하는데 필요한 bandwidth를 최소화 할 수 있다.

예를 들어 이 튜토리얼에서는 상수를 세가지 구조로 그룹화 하였다. 하나는 모든 프레임에서 변경되는 변수, 다른 하나는 창 크기가 변경될 때만 변경되는 변수, 다른 하나는 처음 한 번 설정된 후 변경되지 않는 변수이다.

    cbuffer cbNeverChanges
    {
        matrix View;
    };

    cbuffer cbChangeOnResize
    {
        matrix Projection;
    };

    cbuffer cbChangesEveryFrame
    {
        matrix World;
        float4 vMeshColor;
    };

Constant Buffer를 사용하려면 각 버퍼에 대해 ID3D11Buffer 객체를 생성해야 한다. 그런 다음 ID3D11DeviceContext::UpdateSubresource()를 호출하여 필요한 경우 다른 상수 버퍼에 영향을 미치지 않고 각 상수 버퍼를 업데이트 할 수 있다.

    //
    // Update variables that change once per frame
    //
    CBChangesEveryFrame cb;
    cb.mWorld = XMMatrixTranspose( g_World );
    cb.vMeshColor = g_vMeshColor;
    g_pImmediateContext->UpdateSubresource( g_pCBChangesEveryFrame, 0, NULL, &cb, 0, 0 );

위 내용을 참고하여 정리한 내용입니다.

Tutorial6 : 라이팅

램버튼 조명(lambertian lighting)을 적용해보자.

📌 Lighting

램버트 조명은 빛으로부터의 거리에 관계없이 균일한 강도를 가진다. 빛이 표면에 닿으면 반사되는 빛의 양은 빛이 표면에 미치는 입사각에 따라 계산된다.

각도의 계산은 단순 내적으로 계산된다.

이번 튜토리얼에서 사용된 빛은 directional lighting이다. 태양처럼 물체가 어디에 있든 빛이 비추는 방향이 동일하다고 보며, 개별 물체에 비추는 빛의 강도는 고려하지 않는다.

다른 종류의 빛으로는 중앙에서 균일한 빛을 발산하는 point light과, 모든 물체에 동일하게 적용하지 않는 spot light이 있다.

📌 Initializing the Lights (빛 초기화)

이 튜토리얼에는 두 개의 광원이 있다. 하나는 정적으로 정육면체의 위, 뒤에 놓이고, 다른 하나는 정육면체 주위를 돈다.

조명은 셰이더에 의해 계산되므로 변수들은 선언된 다음 바인딩되어야 한다. 이 샘플에서는 광원의 방향과 색상 값만 있으면 된다. 첫 번째 빛은 회색이고 고정되어 있으며, 두 번째 빛은 궤도를 도는 빨간 빛이다.

    // Setup our lighting parameters
    XMFLOAT4 vLightDirs[2] =
    {
        XMFLOAT4( -0.577f, 0.577f, -0.577f, 1.0f ),
        XMFLOAT4( 0.0f, 0.0f, -1.0f, 1.0f ),
    };
    XMFLOAT4 vLightColors[2] =
    {
        XMFLOAT4( 0.5f, 0.5f, 0.5f, 1.0f ),
        XMFLOAT4( 0.5f, 0.0f, 0.0f, 1.0f )
    };

빛의 방향이 항상 중앙을 행하도록 회전 행렬을 적용한다. XMVector3Transform 함수는 벡터와 행렬을 곱하는데 사용된다. 이전 튜토리얼에서는 변환 행렬만 월드 행렬에 곱한다음 셰이더로 전달하여 변환을 수행했다. 그러나 이 경우에는 단순성을 위해 CPU에서 빛을 변환하는 작업을 한다.

    // Rotate the second light around the origin
    XMMATRIX mRotate = XMMatrixRotationY( -2.0f * t );
    XMVECTOR vLightDir = XMLoadFloat4( &vLightDirs[1] );
    vLightDir = XMVector3Transform( vLightDir, mRotate );
    XMStoreFloat4( &vLightDirs[1], vLightDir );

빛의 방향과 색상은 모두 행렬처럼 셰이더에 전달된다. 관련 변수가 호출되어 설정되고 매개 변수가 전달된다.

    //
    // Update matrix variables and lighting variables
    //
    ConstantBuffer cb1;
    cb1.mWorld = XMMatrixTranspose( g_World );
    cb1.mView = XMMatrixTranspose( g_View );
    cb1.mProjection = XMMatrixTranspose( g_Projection );
    cb1.vLightDir[0] = vLightDirs[0];
    cb1.vLightDir[1] = vLightDirs[1];
    cb1.vLightColor[0] = vLightColors[0];
    cb1.vLightColor[1] = vLightColors[1];
    cb1.vOutputColor = XMFLOAT4(0, 0, 0, 0);
    g_pImmediateContext->UpdateSubresource( g_pConstantBuffer, 0, NULL, &cb1, 0, 0 );

📌 Rendering the Lights in the Pixel Shader (픽셸 셰이더에 빛 렌더링 하기)

빛과 노멀을 내적하면 빛의 효과(색상)를 계산할 수 있다. 이 값은 범위를 [0. 1]로 변환하는 saturate 함수를 통해 전달된다. 마지막으로, 두 개를 합쳐 최종 색이 결정된다.

표면의 머터리얼은 계산에 포함되지 않는다고 가정하여 표면의 최종적인 색깔 = 빛의 색깔이다.

    //
    // Pixel Shader
    //
    float4 PS( PS_INPUT input) : SV_Target
    {
        float4 finalColor = 0;

        //do NdotL lighting for 2 lights
        for(int i=0; i<2; i++)
        {
            finalColor += saturate( dot( (float3)vLightDir[i],input.Norm) * vLightColor[i] );
        }
        return finalColor;
    }

일단 픽셸 셰이더를 통과하면, 픽셀들은 빛에 의해 변조될 것이고, 큐브 표면에 각 빛이 미치는 영향을 볼 수 있다.

Tutorial5 : 다른 개체 공전

📌 Transformation (변환)

정점에서 수행할 수 있는 변환에는 3가지 유형이 있다. 이동, 회전, 스케일링. XNA Math 라이브러리에 이동, 회전, 스케일링, 월드-뷰 변환, 뷰-투영 변환과 같은 API가 포함되어 있다.

📌 Translation (이동)

🔎 이동에 사용되는 행렬

    1  0  0  0
    0  1  0  0
    0  0  1  0
    a  b  c  1

여기서 (a, b, c)는 이동할 방향과 거리를 정의하는 벡터이다. 예를 들어 x축으로 -5만큼 이동하게 하려면 아래 행렬을 곱하면 된다.

🔎 x축으로 -5만큼 이동

    1  0  0  0
    0  1  0  0
    0  0  1  0
   -5  0  0  1   

📌 Rotation (회전)

회전은 원점을 통과하는 X, Y, Z 축을 중심으로 일어난다. 예를 들어 [1 0]를 반시계로 90도 회전시키면 [0 1]이 된다.

🔎 y축을 기준으로 시계 방향으로 i도 회전시키는 행렬

    cosΐ  0  -sinΐ   0
     0    1     0    0
    sinΐ  0   cosΐ  0
     0    0     0    1

📌 Scaling (스케일링)

스케일링은 축 방향을 따라 확대하거나 축소하는 것을 말한다. 모든 방향으로 크기를 조정할수도 있고 하나의 축만 따라 크기를 조정할 수도 있다.

🔎 스케일링 시키는 행렬

    p  0  0  0
    0  q  0  0
    0  0  r  0
    0  0  0  1

📌 Multiple Transformations (다중 변환)

벡터에 다중 변환을 적용하려면 첫 번째 변환 행렬을 곱한 다음 그 행렬에 두 번째 변환 행렬을 곱하면 된다.

📌 Creating the Orbit (궤도 생성하기)

이 튜토리얼에서는 제자리에서 회전하는 큐브와, 자신의 축에 대해 회전함과 동시에 다른 큐브를 회전 하는 큐브 2개를 만들 것이다.

XNA Math에 회전, 이동 및 스케일링 행렬을 생성하는 데 도움이 되는 기능이 있다.

• XMMatrixRotationX, XMMatrixRotationY, XMMatrixRotationZ : x축, y축, z축 중심 회전
• XMMatrixTranslation : 매개변수로 받은 점을 이동
• XMMatrixScaling : 스케일링. 기본 축을 따라서만 조정되며 임의의 축을 따라 스케일링을 하고 싶으면 스케일링 행렬에 적절한 회전 행렬을 곱하면 된다.

첫 번째 정육면체는 제자리에서 회전하고 궤도의 중심 역할을 할 것이다. XMMatrixRotationY 함수를 호출하면 된다. 큐브는 각 프레임에 설정된 양만큼 회전한다.

    // 1st Cube: Rotate around the origin
    g_World1 = XMMatrixRotationY( t );

두 번째 정육면체는 첫 번째 정육면체 주위를 공전한다. 먼저 정육면체의 크기가 30%로 축소된 다음, 축(이 경우 z축)을 따라 회전한다. 궤도를 돌게 하기 위해 원점에서 멀리 떨어진 곳으로 이동시킨다음 y축을 따라 회전한다. 원하는 결과는 4개의 행렬(mScale, mSpin, mTranslate, mOrbit)의 곱으로 얻을 수 있다.

    // 2nd Cube:  Rotate around origin
    XMMATRIX mSpin = XMMatrixRotationZ( -t );
    XMMATRIX mOrbit = XMMatrixRotationY( -t * 2.0f );
    XMMATRIX mTranslate = XMMatrixTranslation( -4.0f, 0.0f, 0.0f );
    XMMATRIX mScale = XMMatrixScaling( 0.3f, 0.3f, 0.3f );
    g_World2 = mScale * mSpin * mTranslate * mOrbit;

t : 시간

시간을 이용하여 업데이트를 시키므로 t 값을 증가시켜 주어야 한다.

    // Update our time
    t += XM_PI * 0.0125f;

렌더링을 하기 전에 셰이더에 대해 상수 버퍼를 업데이트 해야 한다. 월드 변환 행렬은 큐브마다 고유하므로 모든 큐브에 각각 적용된다.

    //
    // Update variables for the first cube
    //
    ConstantBuffer cb1;
    cb1.mWorld = XMMatrixTranspose( g_World1 );
    cb1.mView = XMMatrixTranspose( g_View );
    cb1.mProjection = XMMatrixTranspose( g_Projection );
    g_pImmediateContext->UpdateSubresource( g_pConstantBuffer, 0, NULL, &cb1, 0, 0 );

    //
    // Render the first cube
    //
    g_pImmediateContext->VSSetShader( g_pVertexShader, NULL, 0 );
    g_pImmediateContext->VSSetConstantBuffers( 0, 1, &g_pConstantBuffer );
    g_pImmediateContext->PSSetShader( g_pPixelShader, NULL, 0 );
    g_pImmediateContext->DrawIndexed( 36, 0, 0 );

    //
    // Update variables for the second cube
    //
    ConstantBuffer cb2;
    cb2.mWorld = XMMatrixTranspose( g_World2 );
    cb2.mView = XMMatrixTranspose( g_View );
    cb2.mProjection = XMMatrixTranspose( g_Projection );
    g_pImmediateContext->UpdateSubresource( g_pConstantBuffer, 0, NULL, &cb2, 0, 0 );

    //
    // Render the second cube
    //
    g_pImmediateContext->DrawIndexed( 36, 0, 0 );

📌 The Depth Buffer (깊이 버퍼)

Depth Buffer가 없다면 궤도를 도는 작은 정육면체가 뒤를 돌 때 다른 정육면체 뒤가 아닌 앞에 그려질 것이다. 따라서 깊이 버퍼를 사용하여 Direct3D 화면에 그려진 모든 픽셀의 깊이를 판단해주어야 한다. Direct3D 11의 깊이 버퍼는 화면에 그려지는 모든 픽셀을 해당 화면 공간 픽셀의 깊이 버퍼에 저장된 값과 비교하여 확인한다. 렌더링 되는 픽셀의 z값이 버퍼에 이미 있는 값보다 작거나 같으면 픽셀이 그려지고, Depth Buffer의 값이 새로 그린 픽셀의 깊이로 업데이트 된다. 반면 그리려는 픽셀의 z값이 Depth Buffer에 기존에 있는 값보다 크면 픽셀은 버려지고 깊이 버퍼의 z 값은 변경되지 않는다.

🔎 Depth Buffer의 DepthStencilView를 작성하여 Depth Stencil texture를 사용한다는 것을 알게 한다.

    // Create depth stencil texture
    D3D11_TEXTURE2D_DESC descDepth;
    ZeroMemory( &descDepth, sizeof(descDepth) );
    descDepth.Width = width;
    descDepth.Height = height;
    descDepth.MipLevels = 1;
    descDepth.ArraySize = 1;
    descDepth.Format = DXGI_FORMAT_D24_UNORM_S8_UINT;
    descDepth.SampleDesc.Count = 1;
    descDepth.SampleDesc.Quality = 0;
    descDepth.Usage = D3D11_USAGE_DEFAULT;
    descDepth.BindFlags = D3D11_BIND_DEPTH_STENCIL;
    descDepth.CPUAccessFlags = 0;
    descDepth.MiscFlags = 0;
    hr = g_pd3dDevice->CreateTexture2D( &descDepth, NULL, &g_pDepthStencil );
    if( FAILED(hr) )
        return hr;

    // Create the depth stencil view
    D3D11_DEPTH_STENCIL_VIEW_DESC descDSV;
    ZeroMemory( &descDSV, sizeof(descDSV) );
    descDSV.Format = descDepth.Format;
    descDSV.ViewDimension = D3D11_DSV_DIMENSION_TEXTURE2D;
    descDSV.Texture2D.MipSlice = 0;
    hr = g_pd3dDevice->CreateDepthStencilView( g_pDepthStencil, &descDSV, &g_pDepthStencilView );
    if( FAILED(hr) )
        return hr;

새로 만든 Depth Stencil Buffer를 사용하려면 device에 바인딩해야 한다. 이 작업은 Depth Stencil View를 OMSetRenderTargets 함수의 세 번째 매개변수로 전달하여 수행된다.

    g_pImmediateContext->OMSetRenderTargets( 1, &g_pRenderTargetView, g_pDepthStencilView );

렌더 타겟과 마찬가지로 렌더링 전에 Depth Buffer를 초기화해야 한다.

    //
    // Clear the depth buffer to 1.0 (max depth)
    //

위 내용을 참고하여 정리한 내용입니다.

Tutorial4 : 3D 객체 만들기

📌 3D Spaces (3D 공간)

컴퓨터 그래픽스에서는 3D 공간을 주로 데카르트 좌표계(Cartesian coordinate system)에서 가장 흔하다. 이 좌표계는 왼손 좌표계와 오른손 좌표계로 나뉜다.

📌 Object Space

object space는 3D 모델을 만들 때 사용하는 공간을 말한다.

📌 World Space

World Space는 씬의 모든 사물이 공유하는 공간이다. 렌더링하려는 객체들의 위치를 정의한다.

📌 View Space

View space(camera space)는 전체 씬이 사용된다는 점에서 World space와 유사하다. 그러나 원점이 viewer나 camera냐 가 다르다. (World Space는 viewer의 좌표가 원점, Camera Space은 camera 좌표가 원점)

📌 Projection Space (투영 공간)

투영 공간은 뷰 스페이스에서 투영 변환을 적용한 후의 공간을 말한다. X, Y는 -11 이고, Z는 01 이다.

📌 Screen Space (스크린 공간)

스크린 공간은 프레임 버퍼의 위치를 참조하는데 사용된다. 프레임 버퍼는 보통 2D 텍스처이기 때문에 스크린 공간 역시 2D 공간이다. 왼쪽 상단 모서리가 0,0 이다.

📌 Space-to-space Transformation (공간 변환)

파이프라인에 World, View, Projection transfrom 3가지 변환이 있다.

📌 World Transformation (월드 변환)

정점을 객체 공간(Object Space)에서 월드 공간(World Space)로 변환한다. 크기 조절, 회전, 이동 등이 있다. 씬의 물체들은 각각 고유한 월드 변환 행렬을 가진다.

📌 View Transformation

정점을 월드 공간에서 뷰 공간으로 변환한다. 뷰 변환 행렬은 viewer나 카메라가 아닌 정점에 적용된다. 즉 카메라의 관점에서 정점을 이동시킨다. XNA Math에는 view matrix를 계산하기 위해 XMMatrixLookAtLH()라는 API가 종종 사용된다. 카메라가 어디에 있는지, 어디를 보고 있는지, 업벡터 등을 알려주면 이에 상응하는 뷰 매트릭스를 얻을 수 있다.

📌 Projection Transformation (투영 변환)

투영 변환은 월드, 뷰 공간과 같은 3D 공간에서 투영 공간으로 정점을 변환한다. 투영 공간에서 정점의 X, Y 좌표는 3차원 공간에서 정점의 X/Z, Y/Z 비율에 의해 구해진다.

3D 공간을 정의하는 매개 변수 중 하나를 FOV(Field-Of-View)라고 한다. FOV는 특정 방향을 바라볼 때 특정 위치에서 어떤 물체가 보이는지를 나타낸다.

컴퓨터 그래픽스에서 FOV는 view frustum에 포함되어 있다. view frustum은 3D에서 6개의 평면으로 정의된다.

GPU는 view frustum 밖에 있는 개체는 뺀다. 이 과정을 클리핑(clipping) 이라고 한다. 클리핑 결과 view frustum은 육면체(상자)가 된다.

Direct3D 11에서 투영 행렬을 얻는 가장 쉬운 방법은 XMMatrixPerspectiveFovLH() 메소드를 호출하는 것이다. 매개변수는 FOVy, Aspect, Zn, Zf 4개 이다.

• FOVy : y 방향 시야 범위
• Aspect : 가로(view space width) 세로(height) 비율
• Zn : near Z 값
• Zf : far Z 값

📌 Using Transformation

앞서 하나의 삼각형을 화면에 렌더링 할때는 정점 버퍼가 바로 투영 공간에 있도록 했기 때문에 변환을 할 필요가 없었다. 이제 정점 버퍼가 객체 공간에 정의되도록 한 후에 정점 셰이더를 수정하여 정점을 객체 공간에서 투영 공간으로 변환해보자.

📌 Modifying the Vertex Buffer (정점 버퍼 수정하기)

🔎 큐브

SimpleVertex vertices[] =
    {
        { XMFLOAT3( -1.0f,  1.0f, -1.0f ), XMFLOAT4( 0.0f, 0.0f, 1.0f, 1.0f ) },
        { XMFLOAT3(  1.0f,  1.0f, -1.0f ), XMFLOAT4( 0.0f, 1.0f, 0.0f, 1.0f ) },
        { XMFLOAT3(  1.0f,  1.0f,  1.0f ), XMFLOAT4( 0.0f, 1.0f, 1.0f, 1.0f ) },
        { XMFLOAT3( -1.0f,  1.0f,  1.0f ), XMFLOAT4( 1.0f, 0.0f, 0.0f, 1.0f ) },
        { XMFLOAT3( -1.0f, -1.0f, -1.0f ), XMFLOAT4( 1.0f, 0.0f, 1.0f, 1.0f ) },
        { XMFLOAT3(  1.0f, -1.0f, -1.0f ), XMFLOAT4( 1.0f, 1.0f, 0.0f, 1.0f ) },
        { XMFLOAT3(  1.0f, -1.0f,  1.0f ), XMFLOAT4( 1.0f, 1.0f, 1.0f, 1.0f ) },
        { XMFLOAT3( -1.0f, -1.0f,  1.0f ), XMFLOAT4( 0.0f, 0.0f, 0.0f, 1.0f ) },
    };

이 8개의 점을 통해 정육면체를 형성하는 삼각형을 지정해야 한다.

많은 삼각형들은 같은 꼭짓점을 공유할 것이므로 8개의 점만 지정한 다음 Driect3D가 삼각형에 대해 어떤 점을 선택해야 하는지 알려주는 방법을 상요할 것이다. 이는 인덱스 버퍼(index buffer)를 통해 수행된다. 인덱스 버퍼는 버퍼의 정점 인덱스를 참조하여 각 삼각형에서 사용할 점을 지정하는 리스트를 포함한다.

인덱스 버퍼는 정점 버퍼와 매우 유사하다.

🔎 index buffer

    // Create index buffer
    WORD indices[] =
    {
        3,1,0,
        2,1,3,

        0,5,4,
        1,5,0,

        3,4,7,
        0,4,3,

        1,6,5,
        2,6,1,

        2,7,6,
        3,7,2,

        6,4,5,
        7,4,6,
    };

    D3D11_BUFFER_DESC bd;
    ZeroMemory( &bd, sizeof(bd) );
    bd.Usage = D3D11_USAGE_DEFAULT;
    bd.ByteWidth = sizeof( WORD ) * 36;        // 36 vertices needed for 12 triangles in a triangle list
    bd.BindFlags = D3D11_BIND_INDEX_BUFFER;
    bd.CPUAccessFlags = 0;
    bd.MiscFlags = 0;
    InitData.pSysMem = indices;
    if( FAILED( g_pd3dDevice->CreateBuffer( &bd, &InitData, &g_pIndexBuffer ) ) )
        return FALSE;

array를 WORD를 이용하여 선언해주었으므로 sizeof(WORD)를 이용하여 bd의 ByteWidth를 지정해주었다.

Direct3D가 삼각형을 생성할 때 이 인덱스 버퍼를 참조하도록 설정해야 한다.

 // Set index buffer
    g_pImmediateContext->IASetIndexBuffer( g_pIndexBuffer, DXGI_FORMAT_R16_UINT, 0 );

📌 Modifying the Vertex Shader (정점 셰이더 수정하기)

정점 셰이더에서 객체에서 월드 공간으로, 월드에서 뷰 공간으로, 뷰 공간에서 투영공간으로 변환을 진행해야 한다.

가장 먼저 할 일은 3개의 상수 버퍼(constant buffer) 변수를 정의하는 것이다. 상수 버퍼는 어플리케이션이 셰이더에 전달해야 하는 데이터를 저장하는데 사용된다.

우리가 사용할 세가지 변수는 월드, 뷰, 투영 변환 행렬이다.

이 행렬들을 이용하여 정점 셰이더에서 위치를 변환한다.

🔎 변수 선언 및 새로운 정점 셰이더

    cbuffer ConstantBuffer : register( b0 )
    {
        matrix World;
        matrix View;
        matrix Projection;
    }

    //
    // Vertex Shader
    //
    VS_OUTPUT VS( float4 Pos : POSITION, float4 Color : COLOR )
    {
        VS_OUTPUT output = (VS_OUTPUT)0;
        output.Pos = mul( Pos, World );
        output.Pos = mul( output.Pos, View );
        output.Pos = mul( output.Pos, Projection );
        output.Color = Color;
        return output;
    }

📌 Setting up the Matrices (행렬 설정하기)

렌더링 할 때 사용할 변환을 저장한 세 개의 행렬도 정의해야 한다. 렌더링하기 전에 이러한 행렬의 값을 Constant buffer에 복사한다. 그러고 난 후 Draw()를 호출하여 렌더링을 시작하면, 정점 셰이더는 Constant Buffer에 저장된 행렬을 읽는다.

    ID3D11Buffer* g_pConstantBuffer = NULL;
    XMMATRIX g_World;
    XMMATRIX g_View;
    XMMATRIX g_Projection;

ID3D11Buffer 객체를 만들기 위해서는 ID3D11Device::CreateBuffer()를 사용하고 D3D11_BIND_CONSTANT_BUFFER를 명시해야 한다.

    D3D11_BUFFER_DESC bd;
    ZeroMemory( &bd, sizeof(bd) );
    bd.Usage = D3D11_USAGE_DEFAULT;
    bd.ByteWidth = sizeof(ConstantBuffer);
    bd.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
    bd.CPUAccessFlags = 0;
    if( FAILED(g_pd3dDevice->CreateBuffer( &bd, NULL, &g_pConstantBuffer ) ) )
        return hr;

다음으로 할 일은 변환을 수행하기 위해 사용할 세 가지 행렬을 만드는 것이다. 우리는 삼각형이 XY 평면에 평행하게 원점에 위치하기를 원한다. 객체 공간의 정점버퍼에서 이런식으로 이미 저장되어 있으므로 월드 변환은 기본 행렬이 된다. 카메라가 [0 1 -5]에 위치하며 [0 1 0]을 바라보게 하고자, XMMatrixLookAtLH()를 호출하여 계산할 수 있다. +Y 방향이 위쪽으로 유지되어야 한다. 마지막으로 투영 행렬을 얻기 위해 XMMatrixPerspectiveFovLH()를 호출한다. 이 세가지 행렬은 전역 변수 g_World, g_View, g_Projection에 저장된다.

📌 Updating Constant Buffers (상수 버퍼 업데이트 하기)

행렬을 상수 버퍼에 기록해야 렌더링할 때 GPU가 읽을 수 있다. ID3D11DeviceContext::UpdateSubresource() API를 사용하여 셰이더의 상수 버퍼와 동일한 순서로 저장된 행렬에 포인터를 전달 할 수 있다. 이를 위해 셰이더의 상수 버퍼와 동일한 레이아웃을 가진 구조체를 만들 것이다.

    //
    // Update variables
    //
    ConstantBuffer cb;
    cb.mWorld = XMMatrixTranspose( g_World );
    cb.mView = XMMatrixTranspose( g_View );
    cb.mProjection = XMMatrixTranspose( g_Projection );
    g_pImmediateContext->UpdateSubresource( g_pConstantBuffer, 0, NULL, &cb, 0, 0 );

위 내용을 참고하여 정리한 내용입니다.

Tutorial3 :

1) 그래픽 파이프라인을 통해 삼각형을 그리는 과정 알아보기

2) 셰이더

📌 Shaders (셰이더)

Direct3D 11은 정점 셰이더, 지오메트리 셰이더, 픽셀 셰이더를 지원한다. 정점 셰이더는 정점을 입력으로 받아 정점 버퍼를 통해 GPU로 전달되는 모든 정점에 대해 한 번씩 실행된다. 지오메트리 셰이더는 점, 선, 삼각형 등을 입력으로 받아 각각 한 번씩 실행된다. 픽셀 셰이더는 렌더링하고자 하는 픽셀마다 한 번씩 실행된다.

지오메트리 셰이더는 선택사항이다.

실행 순서 : 정점 셰이더 -> (지오메트리 셰이더) -> 레스터라이저 -> 픽셀 셰이더

📌 Vertex Shaders (정점 셰이더)

정점 셰이더의 가장 중요한 역할은 변환(transformation)이다. 예를 들어 삼각형이 2D 텍스처 버퍼에 그려질 때 GPU는 꼭짓점이 그려질 버퍼 상의 점의 2D 좌표를 알아야 한다. 우선 이 튜토리얼에서는 변환을 진행하지 않는다.

Direct3D 11 튜토리얼에서는 셰이더를 HLSL(High-Level Shading Language)로 작성하였다.

정점 셰이더는 다음과 같다.

🔎 정점 셰이더

    float4 VS( float4 Pos : POSITION ) : SV_POSITION
    {
        return Pos;
    }

📌 Pixel Shaders (픽셀 셰이더)

모니터는 픽셀들의 2차원 격자이고, 각각의 픽셀들은 독립적인 색깔을 가지고 있다. 따라서 우리가 보는 삼각형은 실제로는 아래 그림에서 오른쪽과 같은 형태이다.

세 개의 정점으로 정의된 삼각형을 픽셀 모음으로 변환하는 과정을 레스터라이즈라고 한다. GPU는 먼저 렌더링되는 삼각형에 포함되는 픽셀을 결정한다. 그런 다음 각 픽셀에 대해 활성 픽셀 셰이더를 호출한다. 픽셸 셰이더의 주된 목적은 정점 셰이더나 지오메트리부터 입력을 얻어서 각 픽셀의 색깔을 계산하는 것이다. 이 색상을 계산한 다음 다시 파이프라인으로 보낸다.

🔎 픽셀 셰이더

    float4 PS( float4 Pos : SV_POSITION ) : SV_Target
    {
        return float4( 1.0f, 1.0f, 0.0f, 1.0f );    // Yellow, with Alpha = 1
    }

SV_Target : 렌더 타겟 형식으로의 출력을 의미

📌 Creating the Shaders (셰이더 만들기)

D3DX11CompileFromFile()를 호출하여 만들 수 있다.

🔎 어플리케이션 코드에서 셰이더 만들기

    // Create the vertex shader
    if( FAILED( D3DX11CompileFromFile( "Tutorial03.fx", NULL, NULL, "VS", "vs_4_0", D3DCOMPILE_ENABLE_STRICTNESS, NULL, NULL, &pVSBlob, &pErrorBlob, NULL ) ) )
        return FALSE;

    // Create the pixel shader
    if( FAILED( D3DX11CompileFromFile( "Tutorial03.fx", NULL, NULL, "PS", "ps_4_0", D3DCOMPILE_ENABLE_STRICTNESS, NULL, NULL, &pPSBlob, &pErrorBlob, NULL ) ) )
        return FALSE;

위 내용을 참고하여 정리한 내용입니다.

Tutorial2 : 삼각형 그리기

📌 Elements of a Triangle (삼각형의 요소)

GPU가 삼각형을 렌더링하기 위해서는 삼각형의 꼭짓점 위치 3개가 주어져야 한다.

정점 버퍼에 꼭짓점 3개를 저장하면 된다.

📌 Input Layout

정점은 위치, 노멀, 색상, 텍스처 좌표(텍스처 매핑에 이용) 등을 가지고 있다. 정점 레이아웃은 이러한 속성들이 메모리에 어떻게 위치하는지를 나타낸다. (각 속성들이 어떤 데이터 타입을 이용하는지, 각 속성의 사이즈는 얼마인지, 저장된 순서 등)

각 속성은 다른 타입을 가지고 있기 때문에 정점은 일반적으로 구조체로 표현한다. 정점의 사이즈는 구조체의 사이즈로 쉽게 얻을 수 있다.

struct SimpleVertex
{
    XMFLOAT3 Pos; // Position
};

이걸 GPU에 공급하기 위해서는 input layout을 알고 있어야 한다. (GPU는 이게 정점에 대한 정보라는걸 모른다)

Direct3D 11에서 input layout은 GPU가 이해할 수 있는 형태로 정점 구조체를 설명하는 것이다. 각 정점 속성들은 D3D11_INPUT_ELEMENT_DESC 구조체를 이용하여 설명될 수 있다.

D3D11_INPUT_ELEMENT_DESC에 대해 좀 더 자세히 알아보자.

🔎 ** D3D11_INPUT_ELEMENT_DESC **

• SemanticName

: Semantic name은 요소의 성격이나 목적을 설명하는 문자열로 GPU에게 이게 뭔지 (정점인지, 노멀인지 등)을 알려주는 것이다. 여기선 POSITION이다.

• SemanticIndex

: 정점은 동일한 성질의 여러 속성을 가질 수 있다. 예를 들어 색상이 2개 일수도 있고 텍스처 좌표가 2개 일 수도 있다. 이 때 같은 COLOR 이라는 Semantic name을 쓰면서 Semantic index를 0과 1로 설정해준다.

• Format

: 요소에 사용할 데이터 타입을 정의한다. 예를 들어 DXGI_FORMAT_R32G32B32_FLOAT은 3개의 32비트 float을 가지고 있어 총 12byte가 된다.

• InputSlot

: Direct3D 11에서 GPU에 최대 16개의 정점 버퍼가 동시에 공급될 수 있다. 각 정점 버퍼는 0부터 15까지의 숫자를 가진다. InputSlot이 이 숫자를 이용해서 뭘 가져올건지 알려주는 역할을 한다.

• AlignedByteOffset

: AlignedByteOffeset은 GPU에 메모리 상에서 정점 버퍼가 시작되는 위치를 알려준다.

• InputSlotClass

: 여기엔 일반적으로 D3D11_INPUT_PER_VERTEX_DATA를 쓴다.

• InstanceDataStepRate

: 인스턴스화에 사용된다. 튜토리얼에서는 인스턴스화를 사용하지 않으므로 0으로 설정한다.

이제 D3D11_INPUT_ELEMENT_DESC 배열을 채워 놓으면 다음과 같다.

// Define the input layout
D3D11_INPUT_ELEMENT_DESC layout[] =
{
    { "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0 },  
};
UINT numElements = ARRAYSIZE(layout);

📌 Vertex Layout

// Create the input layout
if( FAILED( g_pd3dDevice->CreateInputLayout( layout, numElements, pVSBlob->GetBufferPointer(), 
        pVSBlob->GetBufferSize(), &g_pVertexLayout ) ) )
    return FALSE;
// Set the input layout
g_pImmediateContext->IASetInputLayout( g_pVertexLayout );

📌 Creating Vertex Buffer

초기화할동안 해야할 일 중 하나는 정점 데이터를 저장한 정점 버퍼(vertex buffer)를 만드는 것이다. Direct3D 11에서 정점 버퍼를 만들려면 D3D11_BUFFER_DESC, D3D11_SUBRESOURCE_DATA 두가지 구조체를 만들고 ID3D11Device::CreateBuffer()를 호출해야 한다.

정점 버퍼에 복사될 데이터는 아래 코드에서 SimpleVertex에 저장된 3개의 정점들이다. 정점 버퍼가 생성된 후 ID3D11DeviceContext::IASetVertexBuffers()를 호출한다.

🔎 vertex buffer 만들기

// Create vertex buffer
SimpleVertex vertices[] =
{
    XMFLOAT3( 0.0f, 0.5f, 0.5f ),
    XMFLOAT3( 0.5f, -0.5f, 0.5f ),
    XMFLOAT3( -0.5f, -0.5f, 0.5f ),
};
D3D11_BUFFER_DESC bd;
ZeroMemory( &bd, sizeof(bd) );
bd.Usage = D3D11_USAGE_DEFAULT;
bd.ByteWidth = sizeof( SimpleVertex ) * 3;
bd.BindFlags = D3D11_BIND_VERTEX_BUFFER;
bd.CPUAccessFlags = 0;
bd.MiscFlags = 0;
D3D11_SUBRESOURCE_DATA InitData; 
ZeroMemory( &InitData, sizeof(InitData) );
InitData.pSysMem = vertices;
if( FAILED( g_pd3dDevice->CreateBuffer( &bd, &InitData, &g_pVertexBuffer ) ) )
    return FALSE;

// Set vertex buffer
UINT stride = sizeof( SimpleVertex );
UINT offset = 0;
g_pImmediateContext->IASetVertexBuffers( 0, 1, &g_pVertexBuffer, &stride, &offset );

📌 Primitive Topology

Primitive Topology 는 GPU가 삼각형을 렌더링하는데 필요한 3개의 정점을 얻는 방법을 말한다.

만약 삼각형을 2개 그리고 싶다면 GPU에 6개의 정점을 보내면 되고 이 때 topology를 삼각형 리스트(triangle list)라고 부른다. 삼각형 리스트는 이해가 쉽지만, 비효율적이다. 여러개의 삼각형이 정점을 공유하는 경우 한 정점이 여러번 저장된다.

A B C C B D

위 그림처럼 삼각형이 두개의 꼭짓점을 공유한다면 먼저 그려진 삼각형에서 두 개의 정점을 사용하고 정점 버퍼에서 한개만 가져온다면 훨씬 효율적일 것이다. 이렇게 할 때 topology는 triangle strip이다. triangle strip을 이용하면 두번째 삼각형을 그릴 때 이전 삼각형에서 마지막 두 정점을 가져오고, 정점 버퍼에서 그 다음 정점을 하나 가져온다.

A B C D

위 도형의 경우 아래와 같이 전달된다.

A B C D E

두번째, 네번째, 여섯번째 삼각형 등은 반시계방향으로 정점이 주어진다. (기본적으론 시계)

🔎 삼각형 리스트를 이용하여 topology 설정

// Set primitive topology
g_pImmediateContext->IASetPrimitiveTopology( D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST );

📌 Rendering the Triangle

이제 삼각형을 렌더링해보자. 렌더링을 위해 정점 셰이더와 픽셀 셰이더 두개를 만들었다. 정점 셰이더는 삼각형의 정점들을 올바른 위치로 변환(space transform)하는 역할을 한다. 픽셀 셰이더는 삼각형의 각 픽셀의 색상을 계산한다. (이건 다음 튜토리얼에서)

이러한 셰이더들을 사용하려면 각각 ID3D11DeviceContext::VSSetShader(), ID3D11DeviceContext::PSSetShader()을 호출하면 된다.

마지막으로 ID3D11DeviceContext::Draw()를 호출하여 현재 정점 버퍼, 정점 레이아웃, primitive topology 등을 사용하여 GPU가 렌더링하도록 하면 된다.

Draw()의 첫 번째 매개변수는 GPU로 보낼 정점 수이고, 두 번째 매개변수는 보낼 첫번째 정점의 인덱스이다. 우리는 하나의 삼각형을 렌더링하고 정점 버퍼의 처음에서부터 하기 때문에 각각 3, 0 에 해당한다.

// Render a triangle 
g_pImmediateContext->VSSetShader( g_pVertexShader, NULL, 0 );
g_pImmediateContext->PSSetShader( g_pPixelShader, NULL, 0 );
g_pImmediateContext->Draw( 3, 0 );

위 내용을 참고하여 정리한 내용입니다.

📌 Setting Up The Direct3D 11 Device (Direct3D 11 장치 설정)

3D 장면을 렌더링할 때 가장 먼저 해야 할 일은 device, immediate context, swap chain 세 가지 객체를 만드는 것이다.

(immediate context는 direct3d 11에 새로 등장한 객체임)

1) 디바이스(device) 는 리소스를 만든다.

2) immediate context는 버퍼에 렌더링을 수행한다.

3) 스왑 체인(swap chain) 은 장치가 렌더링되는 버퍼를 가져와서 실제 모니터 화면에 콘텐츠를 표시하는 역할을 한다. 스왑 체인에는 두 개 이상의 버퍼가 있는데, 보통 백 버퍼와 프론트 버퍼가 있다. 프론트 버퍼가 현재 사용자에게 제공되고 있는 버퍼이고, 백 버퍼는 앞으로 그려질 타겟이다. 따라서 다 그려지고 나면 백 버퍼가 프런트 버퍼가 된다.

스왑 체인을 만들기 위해 생성하려는 스왑 체인을 설명하는 DXGI_SWAPCHAIN_DESC 구조체를 체워야 한다.

🔎 ** DXGI_SWAPCHAIN_DESC **

** BackBufferUsage ** : 백 버퍼가 어떻게 쓸건지.

백 버퍼로 렌더링을 해주고자 하므로 BackBufferUsage로 DXGI_USAGE_RENDER_TARGET_OUTPUT 으로 설정해주었다.

** OutputWindow ** : 어떤 창에 이미지를 표시할 건지

이렇게 설정이 다 채워지고 나면 아래 함수를 호출할 수 있다.

** D3D11CreateDeviceAndSwapChain ** : 장치와 스왑 체인을 생성하는 함수

🔎 ** 디바이스와 스왑 체인을 만드는 코드 **

DXGI_SWAP_CHAIN_DESC sd;
ZeroMemory(&sd, sizeof(sd));
sd.BufferCount = 1; 
sd.BufferDesc.Width = 640;
sd.BufferDesc.Height = 480;
sd.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
sd.BufferDesc.RefreshRate.Numerator = 60; // 60프레임
sd.BufferDesc.RefreshRate.Denominator = 1;
sd.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT; // swap chain 백 버퍼 용도 - 렌더링
sd.OutputWindow = g_hWnd;
sd.SampleDesc.Count = 1; // 
sd.SampleDesc.Quality = 0; // 다중 샘플링을 이용하지 않으므로
sd.Windowed = TRUE;

if (FAILED(D3D11CreateDeviceAndSwapChain(NULL, D3D_DRIVER_TYPE_HARDWARE, NULL, 0, featureLevels, numFeatureLevels,
    D3D11_SDK_VERSION, &sd, &g_pSwapChain, &g_pd3dDevice, NULL, &g_pImmediateContext))) 
{
    return FALSE;
}

다음으로 할 일은 스왑 체인의 백 버퍼를 render target으로 바인딩해야 하기위해 render target view를 작성하는 것이다.

render target view는 https://m.blog.naver.com/PostView.naver?isHttpsRedirect=true&blogId=agebreak&logNo=60114584311 에 쉽게 설명이 되어있다.

먼저 백 버퍼의 객체를 얻기 위해 GetBuffer()을 호출한다. 이번에는 기본 render target view만 있으면 되므로 CreateRenderTargetView의 두번째 매개변수는 NULL에 해당한다.

render target view를 만들었으면 immediate context에서 OMSetRenderTargets()를 호출하여 파이프라인에 바인딩할 수 있다. 최종적으로 파이프라인 렌더링의 결과물이 백 버퍼에 기록된다.

🔎 ** render target view를 만들고 설정 **

// Create a render target view
ID3D11Texture2D* pBackBuffer;
if (FAILED(g_pSwapChain->GetBuffer(0, __uuidof(ID3D11Texture2D), (LPVOID*)&pBackBuffer)))
    return FALSE;
hr = g_pd3dDevice->CreateRenderTargetView(pBackBuffer, NULL, &g_pRenderTargetView);
pBackBuffer->Release();
if (FAILED(hr))
    return FALSE;
g_pImmediateContext->OMSetRenderTargets(1, &g_pRenderTargetView, NULL);

마지막으로 해야하는 것은 뷰포트를 초기화하는 것이다. 뷰포트는 clip space coordinate이다. (X와 Y는 -11, Z는 01) 왼쪽 상단 점을 (0, 0)이다. 너비 및 높이는 렌더 대상의 크기와 동일하게 설정한다.

🔎 viewport 초기화

  D3D11_VIEWPORT vp;
  vp.Width = (FLOAT)width;
  vp.Height = (FLOAT)height;
  vp.MinDepth = 0.0f;
  vp.MaxDepth = 1.0f;
  vp.TopLeftX = 0;
  vp.TopLeftY = 0;
  g_pImmediateContext->RSSetViewports( 1, &vp );

📌 Modifying the Message Loop (메세지 루프 수정하기)

GetMessage()는 대기열에 메세지가 없으면 GetMessage()가 차단되어 메세지를 사용할 수 있을 때까지 반환되지 않는다. 메세지가 안들어오더라도 그동안 다른 걸 수행해야 하므로GetMessage()대신 PeekMessage()를 사용한다. PeekMessage()는 대기열에 메세지가 없어도 PeekMessage()가 즉시 반환되어 렌더링을 할 수 있다.

🔎 GetMessage() 대신 PeekMessage() 사용하기

    MSG msg = {0};
    while( WM_QUIT != msg.message )
    {
        if( PeekMessage( &msg, NULL, 0, 0, PM_REMOVE ) )
        {
            TranslateMessage( &msg );
            DispatchMessage( &msg );
        }
        else
        {
            Render();  // Do some rendering
        }
    }

📌 The Rendering code (렌더링 코드)

렌더링은 Render() 함수에서 완료된다. 예시에서는 단일 색으로 화면을 칠했다. 이를 위해 ClearRanderTargetView() 함수를 이용한다. 화면을 채우고 싶은 색상을 설정한다음 ClearRenderTargetView()에 전달한다. 백 버퍼를 채우면 스왑 체인의 Present() 메소드를 호출하여 렌더링을 완료한다.

** Present() ** : 스왑 체인의 백 버퍼를 사용자가 볼 수 있도록 화면에 표시하는 역할

🔎 렌더링

    void Render()
    {
        //
        // Clear the backbuffer
        //
        float ClearColor[4] = { 0.0f, 0.125f, 0.6f, 1.0f }; // RGBA
        g_pd3dDevice->ClearRenderTargetView( g_pRenderTargetView, ClearColor );

        g_pSwapChain->Present( 0, 0 );
    }

위 내용을 참고하여 정리한 내용입니다.

모듈1. 첫 번째 Windows 프로그램

4) 창 그리기 5) 창 닫기 6) 어플리케이션 상태 관리

📍 Creating a Window

창을 처음 표시할 때나, 창의 일부를 다시 그려야 할 때 운영체제는 창에 WM_PAINT 메세지를 보낸다.

우리는 여기서 Client Area만 그리면 된다. 그리고 업데이트 영역이 남아있는 동안에는 다른 WM_PAINT 메세지를 보낼 필요가 없다는 것을 운영체제에게 알린다. 이 업데이트 영역은 클라이언트 영역 그리기를 완료한 후 지우면 된다.

다른 창으로 창의 일부를 가렸다가 다시 보이게 된 상황에서도 해당 부분이 업데이트 영역에 추가되고 창에 다른 WM_PAINT 메세지가 표시된다.

창을 늘이는 경우에도 마찬가지이다.

🔎 전체 클라이언트 영역 단색으로 채우기

switch (uMsg)
{
    case WM_PAINT:
    {
        PAINTSTRUCT ps;
        HDC hdc = BeginPaint(hwnd, &ps);

        // All painting occurs here, between BeginPaint and EndPaint.

        FillRect(hdc, &ps.rcPaint, (HBRUSH) (COLOR_WINDOW+1));

        EndPaint(hwnd, &ps);
    }
    return 0;
}

1) BeginPaint 함수를 호출하여 그리기 작업 시작 : PAINTSTRUCT 구조체를 요청에 대한 정보로 채우는 함수

2) 현재 업데이트 영역은 PAINTSTRUCT의 rcPaint 멤버에 저장 (업데이트 영역은 클라이언트 영역 기준)

3) FillRect로 시스템 정의 창 배경색을 이용하여 업데이트 영역을 단일 색으로 채우기

4) 그리기 작업이 완료되면 EndPaint 호출

🔎 FillRect

FillRect(hdc, &ps.rcPaint, (HBRUSH) (COLOR_WINDOW+1));

두번째 매개변수 : 채울 사각형의 좌표 여기서는 PAINTSTRUCT의 rcPaint 멤버이며 rcPaint에는 전체 클라이언트 영역이 포함된다.

📍 Closing the Window

사용자가 창을 닫으면 창에서 WM_CLOSE 메세지가 수신된다. WM_CLOSE 메세지는 창을 닫기 전에 사용자에게 메세지를 표시하며 창을 닫으려면 DestroyWindow 함수를 호출, 그렇지 않으면 운영 체제에서 메세지를 무시하고 창을 삭제하지 않는다(WM_CLOSE 메세지가 0을 반환)

🔎 프로그램이 WM_CLOSE를 처리하는 방법

case WM_CLOSE:
    if (MessageBox(hwnd, L"Really quit?", L"My application", MB_OKCANCEL) == IDOK)
    {
        DestroyWindow(hwnd);
    }
    // Else: User canceled. Do nothing.
    return 0;

이 경우 사용자가 확인(OK)을 클릭하면 프로그램에서 DestroyWindow를 호출하고, 그렇지 않고 취소(Cancle)을 클릭하면 호출을 건너뛰고 창이 열린 상태로 유지된다.

사용자에게 메세지를 표시하지 않고 창을 닫으려면 DefWindowProc을 이용할 수 있다. WM_CLOSE의 경우 DefWindowProc은 DestroyWindow를 자동으로 호출한다.

창이 제거될 때 WM_DESTROY 메세지를 받는다. 이 메세지는 소멸하기 전에 전송되며, 일반적으로 PostQuitMessage를 호출하여 WM_DESTOY에 응답한다.

case WM_DESTROY:
    PostQuitMessage(0);
    return 0; 

🔎 WM_CLOSE 및 WM_DESTROY 메세지를 처리하는 일반적인 방법

📍 Managing Application State

윈도우 프로시저는 상태가 저장되지 않기 때문에 한 함수 호출에서 다음 함수 호출로 어플리케이션의 상태를 추적하는 방법이 필요하다.

🔎 전역 변수에 모두 배치

소규모 프로그램에서 good. 대규모에서는 좋지않다. (윈도우 프로시저가 많다, 전역 변수 확산)

🔎 ** CreateWindowEx 함수 **

모든 데이터 구조를 창에 전달한는 방법을 제공한다. 이 함수가 호출되면 윈도우 프로시저에 다음 두 개의 메세지를 보낸다.

• WM_NCCREATE
• WM_CREATE

이 두 메세지는 창이 표시되기 전에 전송된다.

CreateWindowEx의 마지막 매개 변수는 void* 형식의 포인터이다.

이제 이 매개변수를 사용하여 어플리케이션 데이터를 창에 전달하는 방법을 알아보자.

1) 상태 정보를 보유하는 클래스 또는 구조체를 정의한다.

struct StateInfo { };

2) CreateWindowEx를 호출하는 경우 최종 * void 매개 변수에서 이 구조체에 대한 포인터를 전달 **

StateInfo *pState = new (std::nothrow) StateInfo;

if (pState == NULL)
{
    return 0;
}

// Initialize the structure members (not shown).

HWND hwnd = CreateWindowEx(
    0,                              // Optional window styles.
    CLASS_NAME,                     // Window class
    L"Learn to Program Windows",    // Window text
    WS_OVERLAPPEDWINDOW,            // Window style

    // Size and position
    CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,

    NULL,       // Parent window    
    NULL,       // Menu
    hInstance,  // Instance handle
    pState      // Additional application data
    );

WM_NCCREATE 및 WM_CREATE 각 메세지의 lParam 매개 변수는 CREATESTRUCT 구조체에 대한 포인터이다. 그리고 이 CREATETRUCT 구조체에는 CreateWindowEx에 전달한 포인터가 포함되어 있다.

🔎 데이터 구조에 대한 포인터 추출

1) lParam 매개 변수를 캐스팅하여 CREATESTRUCT 구조체 얻기

CREATESTRUCT *pCreate = reinterpret_cast<CREATESTRUCT*>(lParam);

2) lpCreateParams를 캐스팅하여 사용자 고유의 데이터 구조에 대한 포인터 얻기

pState = reinterpret_cast<StateInfo*>(pCreate->lpCreateParams);

3) SetWindowLongPtr 함수를 호출하고 포인터를 데이터 구조에 전달

SetWindowLongPtr(hwnd, GWLP_USERDATA, (LONG_PTR)pState);

: 이렇게 하면 항상 GetWindowLongPtr을 호출하여 창에서 포인터를 다시 얻을 수 있다.

LONG_PTR ptr = GetWindowLongPtr(hwnd, GWLP_USERDATA);
StateInfo *pState = reinterpret_cast<StateInfo*>(ptr);

이 방법은 클래스의 창을 2개 이상 만드는 경우에 유용하다. GetWindwoLongPtr의 호출을 작은 도우미 함수로 래핑하는 것이 편리하다.

inline StateInfo* GetAppState(HWND hwnd)
{
    LONG_PTR ptr = GetWindowLongPtr(hwnd, GWLP_USERDATA);
    StateInfo *pState = reinterpret_cast<StateInfo*>(ptr);
    return pState;
}

🔎 최종적으로 작성한 윈도우 프로시저

LRESULT CALLBACK WindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
    StateInfo *pState;
    if (uMsg == WM_CREATE)
    {
        CREATESTRUCT *pCreate = reinterpret_cast<CREATESTRUCT*>(lParam);
        pState = reinterpret_cast<StateInfo*>(pCreate->lpCreateParams);
        SetWindowLongPtr(hwnd, GWLP_USERDATA, (LONG_PTR)pState);
    }
    else
    {
        pState = GetAppState(hwnd);
    }

    switch (uMsg)
    {


    // Remainder of the window procedure not shown ...

    }
    return TRUE;
}

📍 Dynamic Storage Allocation (동적 메모리 할당)

고정된 사이즈 자료구조를 이용할 경우 프로그램을 수정하고, 다시 컴파일하지 않고는 size를 변경할수가 없다.

따라서 C는 동적 메모리 할당(Dynamic Storage Allocation) 기능을 제공한다. 이는 실행 시간동안 사용할 메모리 공간을 할당받는 것을 말한다.

📌 Memory Allocation Functions (메모리 할당 함수들)

🔎 메모리 할당 함수들

• malloc : 메모리를 할당받고, 초기화는 하지 않는다.
• calloc : 메모리를 할당받고, 0으로 초기화한다.
• realloc : malloc이나 calloc으로 할당받는 메모리의 크기를 변경할 때 사용한다.

보통 malloc이 가장 많이 쓰인다.

어떤 타입이 할당될지 모르기 때문에 함수는 void* 형식을 반환한다. void*은 어떤 타입으로도 변신이 가능하다.

📌 Null Pointers (널 포인터)

동적 할당 함수를 호출할 때, 그만큼 충분한 공간이 남아있지 않을 가능성이 있다. 그럼 함수는 null pointer를 반환한다. null pointer는 아무것도 가리키지 않는 포인터이다. 따라서 함수의 반환값을 포인터 변수에 저장한 후에 반드시 null pointer인지 검사를 해주어야 한다.

null pointer는 매크로에 의해 NULL로 선언되어있다. 보통 #include <stdlib.h>를 이용한다. 따라서 malloc의 반환 값을 아래와 같이 테스트할 수 있다.

p = malloc(10000);
if (p == NULL) { 
    /* allocation failed */
}

p == NULL이라고 쓰는 대신 if (!p) ... 도 가능하다.

📍 Dynamic Allocated Strings

(동적 할당된 문자열)

📌 Using malloc to Allocate Memoery for a String (malloc으로 문자열 함수에 메모리 할당하기)

🔎 malloc 함수

void *malloc(size_t size); 

malloc은 size만큼의 메모리를 할당하고 포인터를 반환한다.

char의 size는 1이기 때문에 malloc을 이용하여 문자열 함수에 메모리를 할당하는 것은 쉽다.

🔎 문자열 함수에 n개의 문자를 저장할 공간 할당하기

p = malloc(n+1);

그럼 할당을 할 때 p는 char* 이 된다.

📌 Using Dynamic Storage Allocation in String Functions (문자열 함수에서 동적 메모리 할당하기)

두 문자열이 주어졌을 때, 둘다 바꾸지 않고 문자열을 합쳐보자. 그러려면 먼저 두 문자열의 길이를 측정한 다음 malloc을 이용하면 된다. 그 다음 첫번째 문자열을 새 공간에 복사한다음 strcat을 호출하여 두번째 문자열을 연결한다.

🔎 malloc을 이용하여 문자열 합치기

char* concat(const char* s1, const char* s2)
{
    char* result;

    result = malloc(strlen(s1) + strlen(s2) + 1);
    if (result == NULL) {
        printf("Error : malloc failed in concat\n");
        exit(EXIT_FAILURE);
    }
    strcpy(result, s1);
    strcat(result, s2);
    return result; 
}

📌 Arrays of Dynamically Allocated Strings (동적 할당 문자열의 배열)

앞서 문자열을 2차원 배열에 저장하면 공간이 낭비된다는 문제로 인해, 문자열을 포인터로 가리키는 배열을 이용하였다. 이는 동적 할당된 문자열에도 이용될 수 있다.

📌 [Program] Printing a One-Month Reminder List (Revisited) (한 달 리마인더 목록 프린트하기)

#include <stdlib.h>
#include <string.h>
#include <stdio.h>

#define MAX_REMIND (50)
#define MSG_LEN (60)

int read_line(char str[], int n);

int main()
{
    char* reminders[MAX_REMIND];
    char day_str[3], msg_str[MSG_LEN + 1];
    int day, i, j, num_remind = 0;

    for (;;) {
        if (num_remind == MAX_REMIND) {
            printf("-- No space left --\n");
            break; 
        }

        printf("Enter day and reminder : ");
        scanf("%2d", &day);
        if (day == 0)
            break;
        sprintf(day_str, "%2d", day);
        read_line(msg_str, MSG_LEN);

        for (i = 0; i < num_remind; i++)
            if (strcmp(day_str, reminders[i] < 0))
                break;
        for (j = num_remind; j > i; j--)
            reminders[j] = reminders[j - 1];

        reminders[i] = malloc(2 + strlen(msg_str) + 1);
        if (reminders[i] == NULL) {
            printf("-- No space left --\n");
            break; 
        }

        strcpy(reminders[i], day_str);
        strcat(reminders[i], msg_str);

        num_remind++;
    }

    printf("\nDay Reminder\n");
    for (i = 0; i < num_remind; i++)
        printf(" %s\n", reminders[i]);

    return 0; 
}

int read_line(char str[], int n)
{
    int ch, i = 0;

    while ((ch = getchar()) != '\n')
        if (i < n)
            str[i++] = ch;
    str[i] = '\0';
    return i; 
}

📍 Dynamic Allocated Arrays (동적 할당된 배열)

C에서는 프로그램이 실행 중에 배열에 공간을 할당할 수 있다.

📌 Using malloc to Allocate Storage for an Array (malloc으로 배열 메모리 할당하기)

문자열에서와 가장 큰 차이점은 요소의 크기가 반드시 1byte가 아니라는 점이다. 따라서 sizeof 연산자를 이용하여 크기를 계산해주어야 한다.

n개의 정수를 담는 array를 만들어보자.

먼저 포인터 변수를 선언해준다.

int *a;

n이 이미 선언되어 있을 때, 아래와 같이 malloc을 이용하여 공간을 할당할 수 있다.

a = malloc(n * sizeof(int));

이렇게 하고 나면 a를 배열의 이름으로 사용할 수 있다.

📌 The calloc Function (calloc 함수)

calloc은 <stdlib.h>에 선언되어 있다.

🔎 calloc 함수

void *calloc(size_t nmemb, size_t size);

calloc은 size 크기의 변수를 nmemb개 만큼 저장할 수 있도록 한다.

메모리를 할당한 다음 calloc은 0으로 초기화한다.

🔎 calloc 함수 사용 예시

a = calloc(n, sizeof(int)); 

struct point { int x, y; } *p;
p = calloc(1, sizeof(struct point)); 

📌 The realloc Function (realloc 함수)

realloc은 할당된 메모리(ex.array)의 크기를 조절한다.

🔎 realloc 함수

void *realloc(void *ptr, size_t size);

ptr은 반드시 malloc, calloc, realloc에 의해 얻어진 메모리 블록을 가리켜야한다. size는 블록의 새로운 사이즈를 말한다. 보통은 재할당된 메모리를 ptr이 다시 가리킨다.

메모리 블록의 크기를 줄이라는 요청을 받았을 때 realloc은 블록에 저장된 데이터를 이동시키지 않고 축소해야 한다. 확장할 때도 마찬가지이다. 만약 블록 뒤에 오는 바이트가 사용되고 있어 확장할 수 없을 때, realloc은 새 블록을 다른 곳에 할당한 다음 이전 블록의 내용을 새 블록에 복사한다.

📍 Deallocating Storage (메모리 해제)

malloc과 다른 메모리 할당 함수는 힙(heap)이라고 하는 저장소 풀(storage pool)에서 메모리 블록을 가져온다. 이러한 함수를 너무 자주 호출하거나 큰 메모리 블록을 요청하면 힙이 소진되어 함수가 널 포인터를 반환할 수 있습니다. 심지어 할당된 메모리를 추적하지 못해 공간을 낭비할 수 있다.

p = malloc(...);
q = malloc(...);
p = q; 

위 예제의 경우 아래처럼 되므로 첫번째 block은 영원히 쓰이지 않는다.

이렇게 더 이상 쓰이지 않는 메모리를 garbage라고 부른다. 이런 garbage가 발생하는 프로그램에서는 메모리 누수(memory leak)이 발생한다. 몇몇 언어에서는 garbage collector을 제공하여 자동으로 처리해주나 C는 그렇지 않다. 대신 free 함수를 이용하여 불필요한 메모리를 해제해 주어야 한다.

📌 The free function (free 함수)

free 함수는 <stdlib.h>에 들어 있다.

🔎 free 함수

void free(void *ptr);

🔎 free 함수 사용 예시

p = malloc(...);
q = malloc(...);
free(p);
p = q;

이렇게 하여 p가 가리키는 메모리 블락을 해제할 수 있다. 이 때 free의 인수는 메모리 할당 함수에 의해 반환된 포인터이어야 한다.

📌 The "Dangling Pinter" Problem ("매달린 포인터" 문제)

free(p)는 p가 가리키는 것은 해제하지만 p 자체를 바꾸지는 않는다. 따라서 아래와 같이 사용하게 되면 혼돈을 야기한다.

char *p = malloc(4);
...
free(p);
...
strcpy(p, "abc"); /*** WRONG ***/

여러 포인터들이 같은 메모리 블록을 가리킬 수 있기 때문에 매달린 포인터들은 찾기 어려울 수 있다. 블록이 해제되면 모든 포인터가 매달린 상태로 유지된다.

📍 Linked Lists (연결 리스트)

연결 리스트(linked list)는 각 노드가 데이터와 포인터를 가지고 한 줄로 연결되어 있는 것을 말한다.

마지막 노드는 null pointer를 가지고 있다.

연결 리스트는 배열의 대안이 될 수 있다. 연결 리스트를 이용하면 쉽게 요소를 추가하고 삭제할 수 있다. 그러나 "random access"는 불가능하다. 어레이의 경우 모든 요소에 접근하는데 동일한 시간이 소요되지만 연결 리스트의 경우 가까울수록 빠르다.

📌 Declaring a Node Type (노드형 선언하기)

노드가 정수와 다음 노드를 가리키는 포인터만을 가지고 있다고 가정하자.

struct node {
    int value; /* data stored in the node */
    struct node* next; /* pointer to the next node */
};

list가 어디에서부터 시작하는지를 추적하기 위해 첫번째 노드를 가리키는 변수가 필요하다. 이를 first라고 하였다.

struct node *first = NULL:

처음엔 비어 있으므로 first에 NULL값을 부여하였다.

📌 Creating a Node (노드 생성하기)

노드를 아래 3단계로 생성한다.

1) 노드를 위한 메모리를 할당한다. 2) 노드에 데이터를 저장한다. 3) 리스트에 노드를 넣는다.

노드를 생성할 때 노드를 목록에 삽입할 때까지 노드를 일시적으로 가리킬 수 있는 변수가 필요하다. 이를 new_node라고 하자.

struct node *new_node;

malloc을 사용하여 새 노드에 메모리를 할당하고 반환 값을 new_node에 저장한다.

new_node = malloc(sizeof(struct node)); 

다음으로, 데이터를 새 노드의 value에 저장한다.

(*new_node).value = 10;

📌 The -> Operator (-> 연산자)

-> 연산자 : 포인터를 사용하여 구조체의 멤버에 접근

🔎 -> 연산자 사용 예시

new_node->value = 10; 

-> 연산자는 *과 .의 결합이라고 보면 된다. new_node가 가리키는 값을 찾은다음 그 구조체의 멤버를 선택한다.

-> 연산자는 lvalue를 생성한다.

🔎 -> 연산자 사용 예시 (2) - scnaf에서

scanf("%d", &new_node->value); 

📌 Inserting a Node at the Beginning of a Linked List (연결 리스트 시작점에 노드 추가하기)

new_node : node가 삽입되는 지점을 가리킨다. first : 연결리스트의 첫번째 노드를 가리킨다.

이 두가지를 이용하여 연결 리스트의 첫번째에 노드를 추가할 수 있다.

먼저 new_node의 next 멤버가 첫번째 노드에 저장된 것을 가리키게 한다.

new_node->next = first;

두번째로, first가 new_node를 가리키게 한다.

first = new_node 

🔎 비어있는 연결 리스트에 10 추가 후 20 추가

이러한 과정을 add_to_list라는 이름의 함수로 만들어보자. 파라미터는 list(추가 전 리스트의 첫번째 노드를 가리키는 포인터), n(첫번째 노드에 저장할 정수) 두가지 이다.

struct node* add_to_list(struct node* list, int n)
{
    struct node* new_node;

    new_node = malloc(sizeof(struct node));
    if (new_node == NULL) {
        printf("Error : malloc failed in add_to_list\n");
        exit(EXIT_FAILURE);
    }
    new_node->value = n;
    new_node->next = list;
    return new_node; 
}

first가 가리키는 지점은 변하지 않았으므로 add_to_list를 다시 호출하기 전에 반환값을 first에 저장해주어야 한다.

first = add_to_list(first, 10);
first = add_to_list(first, 20);

🔎 add_to_list 사용 예시 - 사용자가 입력한 정수 넣기

struct node* read_numbers(void) { struct node* first = NULL; int n;

printf("Enter a series of integers (0 to terminate) : ");
for (;;) {
    scanf("%d", &n);
    if (n == 0)
        return first;
    first = add_to_list(first, n);
}

}

📌 Searching a Linked List (연결 리스트에서 탐색하기)

🔎 포인터 p를 이용하여 노드 추적

for (p = first; p != NULL; p = p->next) {
    ...
}

🔎 search_list (1)

struct node* search_list(struct node* list, int n)
{
    struct node* p;

    for (p = list; p != NULL; p = p->next)
        if (p->value == n)
            return p;
    return NULL
}

🔎 search_list (2)

두번째 방법은 p를 이용하지 않고 list 자체를 이용하는 것이다.

struct node* search_list(struct node* list, int n)
{
    for (; list != NULL; list = list->next)
        if (list->value == n)
            return list;
    return NULL;
}

list는 복사본이기 때문에 바꿔도 상관없다.

🔎 search_list (3)

세번째 방법은 while 문을 이용하는 것이다.

struct node* search_list(struct node* list, int n)
{
    while (list != NULL && list->value != n)
        list = list->next;
    return list;
}

📌 Deleting a Node from a Linked List (연결 리스트에서 노드 삭제하기)

연결리스트의 큰 장점은 노드를 삭제하기가 쉽다는 것이다. 노드를 삭제하는 것은 다음 3단계로 이루어진다.

1) 지울 노드가 있는 곳으로 간다. 2) 삭제된 노드를 "통과"하도록 이전 노드를 변경한다. 3) free를 호출하여 삭제된 노드가 사용하던 공간을 지운다.

1번 단계에서 지울 노드가 있는 곳으로 가면 2번 단계에서 이전 단계에 대한 일을 수행할 수가 없다. 이 문제를 "trailing pointer" 기술을 이용하여 해결할 수 있다. 1단계에서 목록을 검색할 때 현재 노드를 가리키는 포인터(cur) 뿐만 아니라 이전 노드를 가리키는 포인터(prev)도 있게 한다.

for (cur = list, prev = NULL; cur != NULL && cur->value != n; prev = cur, cur = cur->next); 

30 -> 40 -> 20 -> 10 이 연결되어 있는 연결리스트에서 20을 찾는다고 할 때 위 구문을 이용하여 1단계를 수행하면 아래와 같이 된다.

여기서 2단계를 수행하면 다음과 같다.

🔎 삭제할 노드의 이전 노드와 다음 노드를 연결해주기

prev->next = cur-> next;

🔎 20 삭제

free(cur);

이 세가지 과정을 통해 원하는 정수를 삭제하도록 하는 함수를 만들어보면 다음과 같다.

🔎 delete_from_list

struct node* delete_from_list(struct node* list, int n)
{
    struct node* cur, * prev;

    for (cur = list, prev = NULL; cur != NULL && cur->value != n; prev = cur, cur = cur->next);

    if (cur == NULL)
        return list; /* n was not found */
    if (prev == NULL)
        list = list->next; /* n is in the first node */
    else
        prev->next = cur->next; /* n is in some other node */
    free(cur);
    return list; 
}

📌 Ordered Lists (정렬된 리스트)

정렬된 리스트 : 노드들이 순서대로 정렬되어 있는 경우 이 경우 노드를 삽입하는 것은 더 어렵지만 검색은 더 빠르다.

📌 [Program] Maintaining a Prats Database (Revisited) (부품 데이터베이스 유지관리 (재방문))

🔎 inventory2.c

/* Maintains a parts database (linked list version) */

#include <stdio.h>
#include <stdlib.h>
#include "readline.h"

#define NAME_LEN (25)

struct part {
    int number;
    char name[NAME_LEN + 1];
    int on_hand;
    struct part* next;
};

struct part* inventory = NULL; /* points to first part */

struct part* find_part(int number);
void insert(void);
void search(void);
void update(void);
void print(void);

int main(void)
{
    char code;

    for (;;) {
        printf("Enter operation code : ");
        scanf(" %c", &code);
        while (getchar() != '\n');
        switch (code) {
        case 'i': insert();
            break;
        case 's': search();
            break;
        case 'u': update();
            break;
        case 'p': print();
            break;
        case 'q': return 0;
        default: printf("Illegal code\n");
        }
        printf("\n");
    }
}

struct part* find_part(int number)
{
    struct part* p;

    for (p = inventory; p != NULL && number > p->number; p = p->next);
    if (p != NULL && number == p->number)
        return p;
    return NULL;
}

void insert(void)
{
    struct part* cur, * prev, * new_node;

    new_node = malloc(sizeof(struct part));
    if (new_node == NULL) {
        printf("Database is full; can't add more parts.\n");
        return;
    }

    printf("Enter part number : ");
    scanf("%d", &new_node->number);

    for (cur = inventory, prev = NULL; cur != NULL && new_node->number > cur->number; prev = cur, cur = cur->next);
    if (cur != NULL && new_node->number == cur->number) {
        printf("Part already exists.\n");
        free(new_node);
        return; 
    }

    printf("Enter part name : ");
    read_line(new_node->name, NAME_LEN);
    printf("Enter quantity on hand : ");
    scanf("%d", &new_node->on_hand);

    new_node->next = cur;
    if (prev == NULL)
        inventory = new_node;
    else
        prev->next = new_node; 
}

void search(void)
{
    int number;
    struct part* p;

    printf("Enter part number : ");
    scanf("%d", &number);
    p = find_part(number);
    if (p != NULL) {
        printf("Part name : %s\n", p->name);
        printf("Quantity on hand : %d\n", p->on_hand);
    } 
    else {
        printf("Part not found.\n");
    }
}

void update(void)
{
    int number, change;
    struct part* p;

    printf("Enter part number : ");
    scanf("%d", &number);
    p = find_part(number);
    if (p != NULL) {
        printf("Enter change in quantity on hand : ");
        scanf("%d", &change);
        p->on_hand += change;
    }
    else
        printf("Part not found.\n");
}

void print(void)
{
    struct part* p;
    printf("Part Number Part Name Quantity on Hand");
    for (p = inventory; p != NULL; p = p->next)
        printf("%7d        %-25s11d\n", p->number, p->name, p->on_hand);
}

📍 Pointers to Pointers (포인터의 포인터)

포인터를 매개변수로 받는 함수가 다른 곳을 가리키게 함으로써 변수를 수정하고자 할 때 포인터의 포인터를 이용한다.

앞서 작성한 add_to_list에서는 new_node를 반환한다. 여기서 new_node를 반환하는 대신에 list가 new_node를 가리키도록 바꾼다고 해보자.

list = new_node 

포인터는 pass by value기 때문에 위 구문은 잘 작동하지 않는다.

올바른 코드는 다음과 같다.

🔎 포인터의 포인터를 이용한 add_to_list

void add_to_list(struct node** list, int n)
{
    struct node* new_node;

    new_node = malloc(sizeof(struct node));
    if (new_node == NULL) {
        printf("Error : malloc failed in add_to_list\n");
        exit(EXIT_FAILURE);
    }
    new_node->value = n;
    new_node->next = *list;
    *list = new_node; 
}

이렇게 하면 new_node의 next가 원래 list가 가리키던 곳(첫번째였던 노드)를 가리키게 되고, list가 가리키는 곳은 new_node로 변한다.

📍 Pointers to Functions (함수 포인터)

함수들도 메모리 위치를 차지하기 때문에 C에서는 포인터가 함수를 가리키는 것도 가능하다.

📌 Function Pointers as Arguments (입력변수로서의 함수 포인터)

점 a부터 b까지 적분하는 함수를 만든다고 할 때 f를 함수에 대한 포인터로 선언할 것이다.

double integrate(double (*f) (double), double a, double b);

f앞에 포인터를 붙여서 f가 포인터를 반환하는 함수가 아니라 함수에 대한 포인터임을 나타낸다. * 없이 그냥 함수처럼 보이게 쓰는 것도 가능하다.

double integrate(double f(double), double a, double b);

integrate를 호출할 때 첫 번째 인수로 함수 이름을 제공한다. 예를 들어 아래 함수는 sin 함수를 0부터 ㅠ/2까지 적분한다.

result = integrate(sin, 0.0, PI/2);

컴파일러는 함수 호출을 위한 코드를 생성하는 대신 함수에 대한 포인터를 생성한다. 따라서 위 코드에서 sin을 호출하는 것이 아니라 integrate에 sin의 포인터를 전달하는 것이 된다.

이 개념은 a가 배열의 이름인 경우 a[i]는 배열의 한 요소를 나타내고, a 자체는 배열에 대한 포인터 역할을 하는 것과 유사하다.

마찬가지로 f가 함수라면 f(x)는 함수의 호출로 생각하지만, f 그자체는 함수에 대한 포인터로 취급한다.

integrate에서 아래와 같이 f가 가리키는 함수를 호출한다.

y = (*f)(x);

*f가 f가 가리키는 함수를 나타내기 때문에, integrate(sin, 0.0, PI/2) 가 실행되는 동안 *f의 호출은 사실상 sin의 홀출과 같다.

📌 The qsort Function (qsort 함수)

C 라이브러리의 유용한 함수들의 대부분이 함수 포인터를 인수로 받는다. 그 중 하나가 <stdlib.h>의 qsort 함수이다.

qsort는 우리가 선택한 기준에 따라 모든 배열을 정렬할 수 있는 기능이다.

정렬되는 배열의 요소들은 어떤 타입이든 될 수 있기 때문에, 구조체나 공유체 타입의 qsort는 두 배열 요소 중 어떤 것이 "더 작은"지 결정하는 방법을 가르쳐야 한다. 비교 함수(comparison function)을 작성하여 qsort에게 정보를 제공할 것이다.

void qsort(void* base, size_t nmemb, size_t size, int (*compar)(const void*, const void*));

base : 어레이의 첫 번째 원소를 가리킨다. nmemb : 정렬되어야 할 원소의 갯수 size : 각 원소의 사이즈 (바이트 단위) compar : 비교할 함수를 가리키는 포인터

🔎 qsort 사용 예시

qsort(inventory, num_parts, sizeof(structpart), compare_parts);

🔎 compare_parts 함수 작성하기

qsort에서는 매개변수로 void* 유형을 받지만, void* 포인터를 통해 part 구조체의 멤버에 접근할 수가 없다. 이 멤버들은 struct part* 유형의 포인터가 필요하다.

이러한 문제 해결을 위해 compare_parts의 매개변수 p, q를 struct part*의 변수에 할당하여 원하는 유형으로 변환하였다.

int compare_parts(const void* p, const void* q)
{
    const struct part* p1 = p;
    const struct part* q1 = q;

    if (p1->number < q1->number)
        return -1;
    else if (p1->number == q1->number)
        return 0;
    else
        return 1; 
}

p와 q는 const 포인터기 때문에 const로 선언된 변수에만 할당될 수 있다.

📌 Other Uses of Function Pointers (함수 포인터의 여러 응용)

함수 포인터를 변수에 저장하거나 배열의 요소 또는 구조체나 공용체의 멤버로서 사용할 수 있다. 함수 포인터를 반환하는 함수를 작성할 수도 있다.

🔎 함수에 대한 포인터를 저장할 수 있는 변수

void (*pf)(int);

pf는 int형의 파라미터를 받고, 반환 값이 void 형인 모든 함수를 가리킬 수 있다.

pf가 가리키는 함수를 호출하는 방법은 다음과 같다.

(*pf)(i);

또는

pf(i);

🔎 요소가 함수 포인터인 배열

void (*file_cmd[])(void) = { new_cmd, open_cmd, close_cmd, close_all_cmd };

배열 첨자를 이용하여 함수를 호출할 수 있다.

(*file_cmd[n]))(); /* or file_cmd[n](); */

📌 [Program] Tabulating the Trigonometric Functions (삼각함수 표로 보여주기)

🔎 cos, sin 및 tan 함수의 값을 보여주는 표를 출력

/* Tabulates values of trigonometric functions */

#include <math.h>
#include <stdio.h>

void tabulate(double (*f)(double), double first, double last, double incr);

int main(void)
{
    double final, increment, initial;

    printf("Enter initial value : ");
    scanf("%lf", &initial);

    printf("Enter final value : ");
    scanf("%lf", &final);

    printf("Enter increment : ");
    scanf("%lf", &increment);

    printf("\n      x           cos(x)"
              "\n   -------    -------\n");
    tabulate(cos, initial, final, increment);

    printf("\n      x           sin(x)"
        "\n   -------    -------\n");
    tabulate(sin, initial, final, increment);

    printf("\n      x           tan(x)"
        "\n   -------    -------\n");
    tabulate(tan, initial, final, increment);

    return 0; 
}

void tabulate(double (*f)(double), double first, double last, double incr)
{
    double x;
    int i, num_intervals;

    num_intervals = ceil((last - first) / incr);
    for (i = 0; i <= num_intervals; i++) {
        x = first + i * incr;
        printf("%10.5f %10.5f\n", x, (*f)(x));
    }
}

📌 [C99] Restricted Pointers (제한 포인터)

🔎 restrict

int* restrict p;

위처럼 restrict로 선언된 포인터를 제한 포인터(restricted pointer)라고 부른다.

이렇게 선언하면 p가 가리키는 개체가 담긴 메모리에는 다른 포인터가 접근할 수 없다.

객체에 접근하는 두 가지 이상의 방법을 aliasing이라고 한다.

int* restrict p;
int* restrict q;

p = malloc(sizeof(int));

q = p;
*q = 0; /* casus undefined behavior */

p가 제한 포인터이기 때문에, *q = 0 이 정의되지 않는다.

제한된 포인터 p가 외부 저장소 클래스 없이 로컬 변수로 선언되면, restrict는 p로 선언된 블록이 실행될 때만 p에 적용된다.

restrict 사용법을 더 알아보기 위해 <string.h>에 있는 memcpy와 memmove를 알아보자.

🔎 memcpy

void *memcpy(void* restrict s1, const void* restrict s2, size_t n); 

memcpy는 한 개체에서 다른 개체로 바이트를 복사한다.

• s2 : 복사할 데이터
• s1 : 복사본의 대상
• n : 복사할 바이트 수 s1, s2에 restrict를 사용하는 것은 복사할 것과 복사본의 대상이 겹치지 않아야 한다는 것을 나타낸다.

반대로 memmove에서는 restrict를 사용하지 않는다.

🔎 memmove

void *memmove(void *s1, const void *s2, size_t n);

차이점은 소스와 타깃이 겹치더라도 memmove는 작동이 된다는 것이다.

예를 들어, memmove를 이용하여 어레이의 원소들을 한칸씩 옮길 수 있다.

memmove(&a[0], &a[1], 99 * sizeof(int));

restrict는 컴파일러에 정보를 제공하여 보다 효율적인 코드를 생성함으로써 최적화(optimization)을 한다.

그러나 모든 컴파일러가 최적화를 시도하는 것은 아니기 때문에 대부분의 프로그래머가 제한을 사용하지 않는다.

📌 [C99] Flexible Array Members (유동적 배열 멤버)

문자열 저장을 좀 더 유동적이게 할 수 있는 방법을 알아보자

struct vstring {
    int len;
    char chars[N];
};

이런 고정 메모리 배열은 문자열의 길이를 제한하고 메모리를 낭비한다.

C 프로그래머들은 전통적으로 문자 길이를 1로 선언하고 각 문자열을 동적으로 할당함으로써 이 문제를 해결해왔다.

struct vstring {
    int len;
    char chars[1];
};
...
struct vstring* str = malloc(sizeof(struct vstring) + n - 1);
str->len = n;

이런 바법은 "struct hack"이란 이름으로 알려져 있다.

struct hack의 유용성 때문에 C99에서는 유동적 배열 멤버(flexible array member) 기능이 추가되었다.

🔎 flexible array member

struct vstring {
    int len;
    char chars[]; /* flexible array member - C99 only */
};
...
struct vstring* str = malloc(sizeof(struct vstring) + n);
str->len = n;

유동적 배열 멤버를 담고 있는 구조체는 완전하지 않은 유형(incomplete type)이다. 이러한 타입은 다른 구조체의 멤버가 되거나 어레이의 원소가 될 수 없다. 하지만 어레이가 이 구조체를 가리키는 포인터를 포함할 수는 있다.

위 내용을 참고하여 정리한 내용입니다.

모듈1. 첫 번째 Windows 프로그램

1) 창 만들기 2) 창 메세지 3) 창 프로시저 작성

📍 Creating a Window

📌 Window Classes

창 클래스(Window Class)는 여러 창에서 공통적으로 사용할 수 있는 동작의 집합을 말한다. 예를 들어 버튼 그룹에서 각 버튼은 버튼을 클릭할 때 유사한 동작을 포함한다. 물론 버튼이 완전히 동일하지는 않고, 각 창에 대해 고유한 데이터를 인스턴스 데이터(instance data)라고 한다.

창 클래스는 C++의 "class"가 아님을 이해하는 것이 중요하다. 창 클래스는 운영 체제에서 내부적으로 사용하는 데이터 구조로 런타임에 시스템에 등록된다. 새 창 클래스로 등록 하려면 먼저 구조체를 입력하면된다.

const wchar_t CLASS_NAME[] = L"Sample Window Class";

WNDCLASS wc = { };

wc.lpfnWndProc = WindowProc;
wc.hInstance = hInstance;
wc.lpszClassName = CLASS_NAME;

🔎 구조체 멤버 설정

• lpfnWndProc : 윈도우 프로시저(Window procedure)라는 응용 프로그램 정의 함수에 대한 포인터이다. 창의 동작 대부분을 정의한다.

• Hinstance : 응용 프로그램 인스턴스에 대한 핸들로, Wwinmain의 hinstance 매개 변수에서 이 값을 가져온다.

• lpszClassName : 창 클래스를 식별하는 문자열이다.

그런 다음 구조체의 주소를 RegisterClass 함수에 전달한다. 이 함수는 windows 클래스를 운영 체제에 등록한다.

RegisterClass(&wc);

📌 Creating the Window

창의 새 인스턴스를 만들려면 CreateWindowEx 함수를 호출하면 된다.

HWND hwnd = CreateWindowEx(0, // Optional window styles
    CLASS_NAME,  // Window class 
    L"Learn to Program Windows", // Window text
    WS_OVERLAPPEDWINDOW, // Window style

    // Size and Position
    CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,

    NULL, // Parent window
    NULL, // Menu
    hInstance, // Instance handle
    NULL // Additional application data
    );

if (hwnd = NULL)
{
    return 0; 
}

• 마지막 매개변수는 void* 형식의 임의의 데이터에 대한 포인터이다. 이 값을 사용하여 데이터 구조를 윈도우 프로시저에게 전달할 수 있다.

CreateWindowEx는 새 창에 대한 핸들을 반환하거나, 실패할 경우 0을 반환한다. 창을 표시하려면 창 핸들을 ShowWindow 함수에 전달하면 된다.

ShowWindow(hwnd, nCmdShow);

hwnd는 CreateWindowEx에서 반환되는 창 핸들이며 nCmdShow는 창을 최소화하거나 최대화 하는데 사용할 수 있다. 운영체제에서는 Wwinmain 함수를 통해 이 값을 프로그램에 전달한다.

🔎 창 만들기(전체 코드)

// Register the window class.
const wchar_t CLASS_NAME[] = L"Sample Window Class";

WNDCLASS wc = { };

wc.lpfnWndPRoc = windowProc;
wc.hInstance = hInstance;
wc.lpszClassName = CLASS_NAME;

RegisterClass(&wc);

// Create the window 

HWND hwnd = CreateWindowEx(0, // Optional window styles
    CLASS_NAME,  // Window class 
    L"Learn to Program Windows", // Window text
    WS_OVERLAPPEDWINDOW, // Window style

    // Size and Position
    CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,

    NULL, // Parent window
    NULL, // Menu
    hInstance, // Instance handle
    NULL // Additional application data
    );

if (hwnd = NULL)
{
    return 0; 
}

위 코드를 실행하면 아래와 같이 Learn to Program Windows 라는 이름의 창이 만들어진다.

📍 Window Messages (Get Started with Win32 and C++)

GUI 어플리케이션은 사용자 및 운영체제의 이벤트에 응답해야 한다.

• 사용자의 이벤트 : 마우스 클릭, 키 스트로크, 터치 스크린 제스처 등
• 운영 체제 이벤트 : 프로그램 동작에 영향을 줄 수 있는 것들. ex. 사용자가 새 하드웨어 디바이스를 연결하는 등

이러한 이벤트들은 미리 예측할 수 없기에 Windows 메세지 전달 모델(message-passing model)을 이용한다. 운영 체제는 메세지를 전달하여 어플리케이션 창과 통신한다.

예를 들어 사용자가 마우스 왼쪽 버튼을 누르면 창에 다음과 같은 메세지가 간다.

#define WM_LBUTTONDOWN    0x0201

창에 메세지를 전달하기 위해 운영체제는 해당 창에 등록된 윈도우 프로시저를 호출한다.

📌 The Message Loop

어플리케이션에는 수많은 메세지가 오고가기 때문에 메세지를 검색하고 올바른 창으로 전달하는 루프가 필요하다.

운영체제는 창 만드는 각 스레드에 대해 창 메세지에 대한 큐를 만드는데, 이 큐는 해당 스레드에서 만든 모든 창에 대한 메세지를 포함한다.

큐를 직접 조작할 수는 없으나 GetMessage 함수를 호출하여 메세지를 끌어올 수 있다.

MSG msg;
GetMessage(&msg, NULL, 0, 0);

이 함수는 큐의 헤드에서 첫번째 메세지를 제거한다. 큐가 비어 있으면 다른 메세지가 큐에 대기될 때까지 함수가 차단된다. GetMessage가 다른 메세지를 기다리는 동안 계속 실행되는 추가 스레드를 만들 수 있다.

GetMessage의 첫번째 매개변수는 MSG 구조체의 주소로 함수가 성공하면 메세지에 대한 정보로 MSG 구조체를 지운다.

MSG를 직접 검사하지는 않고, 다른 두 함수에 전달한다.

TranslateMessage(&msg);
DispatchMessage(&msg);

• TranlateMessgae : 키보드 입력을 문자로 변환, DispatchMessage전에 호출해야 한다.

• DispatchMessage : 메세지의 대상인 윈도우 프로시저를 호출하도록 운영체제에게 지시한다. 즉 운영체제는 창 테이블에서 창 핸들을 찾고 창과 연결된 함수 포인터를 찾아 함수를 호출한다.

예를 들어 사용자가 마우스 왼쪽 버튼을 누를 경우 아래의 순서로 작동한다.

1) 운영체제는 WM_LBUTTONDOWN 메세지를 메세지 큐에 넣는다. 2) 프로그램에서 GetMessage 함수를 호출한다. 3) GetMessage는 큐에서 WM_LBUTTONDOWN 메세지를 끌어와 MSG 구조를 채운다. 4) 프로그램에서 TranslateMessage 및 DispatchMessage 함수를 호출한다. 5) DispatchMessage 내에서 운영체제는 윈도우 프로시저를 호출한다. 6) 윈도우 프로시저는 메세지에 응답하거나 무시할 수 있다.

프로그램이 실행되는 동안 메세지는 계속 큐에 도착하므로 지속적으로 메세지를 받아서 Dispatch 하는 루프가 있어야 한다. 따라서 다음과 같은 루프가 필요하다.

🔎 지속적으로 메세지를 받아서 Dispatch 하는 루프

// Correct.

MSG msg = { };
while (GetMessage(&msg, NULL, 0, 0) > 0)
{
    TranslateMessage(&msg);
    DispatchMessage(&msg);
}

어플리케이션을 종료하고 메세지 루프를 중단하려면 PostQuitMessage 함수를 호출한다.

🔎 PostQuitMessage 함수

    PostQuitMessage(0);

여기서 주의깊게 볼 점은 윈도우 프리시저가 WM_QUIT 메세지를 받지 않아 이 메세지에 대한 case 문이 필요 없다는 것이다.

📌 Posted Messages versus Sent Messages

• 메세지 게시(Post) : 메세지가 메세지 큐로 이동하고 루프를 통해 Dispatch
• 메세지 전송(Send) : 큐를 건너뛰고 운영 체제에서 윈도우 프로시저를 직접 호출

📍 Writing the Window Procedure

🔎 윈도우 프로시저

LRESULT CALLBACK WindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam);

• hwnd : 창에 대한 핸들

• Umsg : 메세지 코드 (ex. WM_SIZE : 창의 크기가 조절되었음)

• wParam & lParam : 추가 데이터

• LRESULT : 프로그램에서 Windows 에게 반환하는 정수 값. 이 값의 의미는 메세지 코드에 따라 달라진다.

• CALLBACK : 함수에 대한 호출 규칙

🔎 일반적인 코드

switch (uMsg)
{
    case WM_SIZE: // Handle window resizing

    // etc
}

일반적인 윈도우 프로시저는 수십 개의 메세지를 처리하므로 시간이 길어질 수 있어, 코드를 모듈식으로 만들고자 개별 함수에서 각 메세지를 처리하도록 한다. 이 때 윈도우 프로시저에서 wParam, lParam을 캐스팅하고 함수에 전달한다.

🔎 WM_SIZE 메세지

LRESULT CALLBACK WindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
    switch (uMsg)
    {
    case WM_SIZE:
    {
        int width = LOWORD(lParam); // Macro to get the low-order word
        int height = HIWORD(lParam);  // Macro to get the high-order word

        // Respond to the message :
        OnSize(hwnd, (UINT)wParam, width, height);
    }
    break;
    }
}

void OnSize(HWND hwnd, UINT flag, int width, int height)
{
    // Handle resizing 
}

📍 Default Message Handling

윈도우 프로시저에서 특정 메세지를 처리하지 않는 경우에는 메세지 매개 변수를 DefWindowProc 함수에 직접 전달한다.

🔎 매개 변수를 DefWindowProc 함수에 전달

return DefWindowProc(hwnd, uMsg, wParam, lParam);

📍 Avoiding Bottlenecks in Your Window Procedure

윈도우 프로시저는 실행되는 동안 동일한 스레드(thread)에 생성된 windows에 대한 다른 메세지를 차단한다. 이런 점으로 문제가 발생했을 때는 Windows에 기본 제공되는 멀티태스킹 기능 중 하나를 사용하여 작업을 다른 스레드로 이동해야 한다.

• 새 스레드를 만든다.
• 스레드 풀(thread pool)을 사용한다.
• 비동기 I/O 호출을 사용한다.
• 비동기 프로시저 호출을 사용한다.

위 내용을 참고하여 정리한 내용입니다.

📍 Windows Coding Conventions

📌 Typedefs

Integer types

Boolean Type

WinDef.h에는 BOOL과 함께 사용되는 두가지 값이 정의되어 있다.

#define FALSE 0
#define TRUE 1

그러나 BOOL 형식을 반환하는 대부분의 함수는 참일 경우 0은 아니지만 1도 아닌 값이 반환될 수 있다.

따라서 아래처럼 작성하면 안된다.

if (result == TRUE) // wrong !!
{
  ...
}

아래는 맞는 표현들이다.

if (SomeFunctionThatReturnsBoolean())
{
  ...
}

// or

if (SomeFunctionThatReturnsBoolean() != FALSE)
{
  ...
}

Pointer Types

Windows에서 포인터는 일반적으로 이름 앞에 P나 LP를 붙여서 표현한다. 예를 들어 LPRECT는 RECT에 대한 포인터이다.

RECT가 사각형을 설명하는 구조체라고 할 때 RECT의 포인터는 다음과 같다.

RECT* rect; // Pointer to a RECT structure
LPRECT rect; // The same 
PRECT rect; // Also the same

P는 포인터이고, LP는 long 포인터를 의미한다. LP는 16비트 코드를 32비트 Windows에 쓸 때 유용하게 사용되었으나 현재는 P와 LP는 구분되지 않으며 동일하게 쓰인다. 포인터를 나타낼 때 보통은 P를 쓴다.

Pointer Precision Types

• DWORD_PTR
• INT_PTR
• LONG_PTR
• ULONG_PTR
• UINT_PTR

위 포인터 정밀도 타입들은 32비트, 64비트 등의 환경에 맞게 정의되어 있다. 즉 32비트에서는 32비트 포인터, 64비트에서는 64비트 포인터가 된다.

따라서 이러한 형식은 정수를 포인터로 캐스팅하는 상황에서 사용된다. 포인터 산술이나, 루프로 전체 바이트 범위를 반복할 때 등에서도 사용된다. 또 32비트에서 64비트로 확장하는 경우도 가능하다. 이 경우에는 포인터의 크기는 여전히 4byte이다.

📍 Working with Strings

Windows는 기본적으로 UTF-16 인코딩을 사용하여 유니코드 문자를 나타내어 각 문자는 16비트로 인코딩된다. UTF-8 문자를 8비트 ANSI 문자와 구별하기 위해 wide 문자라고 부른다.

• ASCII : 1960년대 미국에서 정의한 표준화한 부호체계
• ANSI : 8비트로 확장한 ASCII 코드
• UNICODE : ANSI로는 한국, 중국, 일본과 같은 문자 표현에 한계가 있어 용량을 크게 확장한 2바이트 기반의 코드
• UTF-8 : 유니코드를 8비트 숫자의 집합으로 나타낸 것

Visual C++ 컴파일러는 wide 문자에 대해 wchar_t를 지원하며 WinNT(헤더파일)에는 아래 typedef가 정의되어 있다.

typedef wchar_t WCHAR;

wide 문자, 문자열을 작성하려면 앞에 L을 붙이면 된다.

wchar_t a = L'a';
wchar_t *str = L"hello";

문자열 관련 typedef는 다음과 같다

📌 Unicode and ANSI Functions

Windows에 대한 유니코드 지원을 도입하는 경우 두 개의 병렬 API를 이용한다. (ANSI 문자열과 유니코드 문자열 용)

🔎 창 제목 표시줄의 텍스트를 설정하는 두 가지 함수

• Setwindowtexta : ANSI 문자열 사용
• Setwindowtextw : 유니코드 문자열 사용

내부적으로 ANSI 버전은 문자열을 유니코드로 전환한다.

또한 Windows 헤더는 아래와 같은 매크로를 지원한다.

#ifdef UNICODE
#define SetWindowText SetWindowTextW
#else 
#define SetWindowText SetWindowTextA
#endif

ANSI 문자열은 호환되지 않는 언어가 많기 때문에 유니코드 버전을 쓰는 것이 좋다. Windows의 최신 API에는 ANSI 버전이 없고 유니코드 버전만 있다.

📌 TCHARs

응용 프로그램이 여러 윈도우 버전을 모두 지원해야 하는 경우 대상 플랫폼에 따라 ANSI 또는 유니코드 문자열에 대해 동일한 코드를 컴파일 하는 것이 유용하다. 따라서 Windows SDK는 플랫폼에 따라 문자열을 유니코드나 ANSI로 매핑하는 매크로를 재공한다.

예를 들어 아래 코드는

SetWindowText(TEXT("My Application"));

둘 중 하나가 된다.

SetWindowTextW(L"My Application"); // 유니코드
SetWindowTextA("My Application"); // ANSI

몇몇 헤더는 전처리기 기호 UNICODE를 이용하고 다른 것들은 _UNICODE 를 이용하기 때문에 둘다 define 해주어야 한다.

Visual C++ 에서는 default로 설정된다.

📍 What Is a Window?

창을 생각하면 보통 위와 같은 창을 떠올린다. 이러한 창을 application window 또는 main window 라고 한다. 일반적으로 제목 표시줄, 최소화, 최대화 버튼 및 기타 표준 UI 요소가 있는 프레임이 있다.

프레임은 운영 체제가 창의 해당 영역 부분을 관리하기 때문에 비 클라이언트 영역 (non-client area)라고 부른다.

프레임 내의 영역은 클라이언트 영역(client area)이다.

다른 유형의 창은 다음과 같다.

이러한 버튼과 같은 UI control도 창이다. control과 어플리케이션 창은 서로 통신할 수 있다.

창을 다음과 같이 생각하는 것이 좋다

• 화면의 특정 부분을 차지한다.
• 특정 시점에 표시될 수도, 표시되지 않을 수도 있다.
• 자신을 그리는 방법을 알고 있다.
• 사용자 또는 운영 체제의 이벤트에 응답한다.

📌 Parent Windows and Owner Windows

control 창은 어플리케이션 창의 자식이다. 또 modal 대화 상자가 표시될 때, 어플리케이션 창은 소유자(owner)창이고 대화 상자는 소유된(owned)창이다.

📌 Window Handles

window는 개체이며 코드와 데이터가 모두 있지만 C++ 클래스는 아니다. 대신 프로그램은 핸들(handle) 이라는 값을 사용하여 창을 참조한다. 핸들은 기본적으로 개체를 식별하는데 사용되는 숫자일 뿐이다. Windows가 만든 모든 창이 담긴 큰 테이블이 있다고 간주하고, 이 테이블을 사용하여 핸들로 창을 조회한다. 창 핸들의 데이터 형식은 일반적으로 HWND이다. (aitch-wind로 발음) 창 핸들은 창을 만드는 함수 CreateWindow 및 CreateWindowEx에서 반환된다.

창에서 작업을 수행하려면 일반적으로 HWND 값을 매개 변수로 받는 일부 함수를 호출한다. 예를 들어 화면의 창 위치를 변경하려면 MoveWindow 함수를 호출한다.

BOOL MoveWindow(HWND hWnd, int X, int Y, int nWidth, int nHeight, BOOL bRepaint);

여기서 첫번째 매개변수 HWND hWnd가 이동하려는 창에 대한 핸들이다.

핸들은 포인터가 아니다.

📌 Screen and Window Coordinates

좌표는 디바이스에 독립적인 픽셀(device-independent pixels)로 측정된다.

작업에 따라 화면을 기준으로, 창(프레임 포함)을 기준으로 또는 창의 클라이언트 영역을 기준으로 좌표를 측정할 수 있다.

각 경우에 원점(0,0)은 항상 영역의 왼쪽 위 모퉁이이다.

📍 WinMain: The Application Entry Point

모든 Windows 프로그램에는 WinMain 또는 wWinMain 이라는 진입점 함수가 포함되어 있다.

int WINAPI wWinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, PWSTR pCmdLine, int nCmdShow);

• hinstance : "인스턴스에 대한 핸들" 또는 "모듈에 대한 핸들"이라고 한다. 운영 체제는 이 값을 사용하여 메모리에 로드될 때 실행 파일(exe)를 식별한다. 인스턴스 핸들은 특정 Windows 함수(ex.아이콘 또는 비트맵 로드)에 필요하다.
• hPrevInstance : 16비트 Windows에서 사용되었으나 지금은 의미가 없다.
• pCmdLine : 명령줄 인수를 유니코드 문자열로 포함
• nCmdShow : 기본 어플리케이션 창이 최소화, 최대화 또는 정상적으로 표시되는지 여부를 표시하는 플래그

함수는 int 값을 반환하며 이 반환 값이 운영체제에서 사용되지는 않지만 반환 값을 사용하여 작성하는 다른 프로그램에 전달할 수 있다.

• WINAPI : 호출 규칙. 함수가 호출자로부터 매개 변수를 받는 방법을 정의. 예를 들어 스택에 매개 변수가 표시되는 순서를 정의한다.

WinMain 함수는 명령줄 인수가 ANSI 문자열로 전달된다는 점을 제외하고 wWinMain과 동일하다.

🔎 빈 WinMain 함수

INT WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
    PSTR lpCmdLine, INT nCmdShow)
{
    return 0;
}

📍 Exercises

1. 가능하다. 구두점(.)을 이용하여 사용할 수 있다.

2. (a)

   struct {
    double real;
    double imaginary;
   } c1, c2, c3; 

   (b)

   struct {
    double real;
    double imaginary;
   } c1{ 0.0, 1.0 }, c2{ 1.0, 0.0 }, c3;

   (c)

   c1 = c2

   (d)

   c3.real = c1.real + c2.real;
   c3.imaginary = c3.imaginary + c2.imaginary;

3. (a)

   struct complex {
    double real;
    double imaginary;
   };

(b)

struct complex c1, c2, c3;

(c)

struct complex make_complex(double real, double imaginary) {
    return (struct complex) { real, imaginary };
}

(d)

struct complex add_complex(struct complex a, struct complex b) {
    return (struct complex) { a.real + b.real, a.imaginary + b.imaginary };
}

4. typedef struct {
    double real;
    double imaginary;
   } complex;
   

complex c1, c2, c3;

complex make_complex(double real, double imaginary) { return (complex) { real, imaginary }; }

complex add_complex(complex a, complex b) { return (complex) { a.real + b.real, a.imaginary + b.imaginary }; }

5. 
(a)
~~~ c
struct date {
    int month;
    int day;
    int year;
};

int day_of_year(struct date d)
{
    int day = 0;
    int days_month[12] = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };

    if (((d.year % 4 == 0 && d.year % 100 != 0) || d.year % 400 == 0))
        day++;

    for (int i = 0; i < d.month; i++)
        day += days_month[i];

    return day + d.day; 
}

(b)

int compare_dates(struct date d1, struct date d2) {
    int day_of_d1 = day_of_year(d1);
    int day_of_d2 = day_of_year(d2);

    if (day_of_d1 > day_of_d2)
        return -1;
    else if (day_of_d1 < day_of_d2)
        return 1;
    else
        return 0;
}

6.

struct time split_time(long total_seconds)
{
    struct time t; 

    t.hours = total_seconds / 3600;
    total_seconds %= 3600;

    t.minutes = total_seconds / 60;
    total_seconds %= 60;

    t.seconds = total_seconds;

    return t;
}

7. (a) (약분하기)

struct fraction reduce_fraction(struct fraction f) {

    int n = f.numerator;
    int d = f.denominator;

    int temp;
    while (n % d != 0) {
        temp = d;
        d = n % d;
        n = temp;
    }

    f.numerator /= d;
    f.denominator /= d;

    return f;
}

(b)

struct fraction add_fraction(struct fraction f1, struct fraction f2) {
    struct fraction f; 

    f.denominator = f1.denominator * f2.denominator;
    f.numerator = f1.numerator * f2.denominator + f1.denominator * f2.numerator;

    f = reduce_fraction(f);

    return f;
}

(c)

struct fraction sub_fraction(struct fraction f1, struct fraction f2) {
    struct fraction f;

    f.denominator = f1.denominator * f2.denominator;
    f.numerator = f1.numerator * f2.denominator - f1.denominator * f2.numerator;

    f = reduce_fraction(f);

    return f;
}

(d)

struct fraction multi_fraction(struct fraction f1, struct fraction f2) {
    struct fraction f;

    f.denominator = f1.denominator * f2.denominator;
    f.numerator = f1.numerator * f2.numerator;

    f = reduce_fraction(f);

    return f;
}

(e)

struct fraction multi_fraction(struct fraction f1, struct fraction f2) {
    struct fraction f;

    f.denominator = f1.denominator * (1/f2.denominator);
    f.numerator = f1.numerator * (1/f2.numerator);

    f = reduce_fraction(f);

    return f;
}

8. (a)

struct color MAGENTA =  {255, 0, 255};

(b)

struct color MAGENTA =  {.red = 255, .blue = 255};

9. (a)

   struct color make_color(int red, int green, int blue) {
    if (red < 0)
        red = 0;
    else if (red > 255)
        red = 255;
    if (blue < 0)
        blue = 0;
    else if (blue > 255)
        blue = 255;
    if (green < 0)
        green = 0;
    else if (green > 255)
        green = 255;
   
    return (struct color) { red, green, blue };
   }

(b)

int getRed(struct color c) {
    return c.red;
}

(c)

bool equal_color(struct color color1, struct color color2) {
    if (color1.red == color2.red && color1.green == color2.green && color1.blue == color2.blue)
        return true; 
}

(d)

struct color brighter(struct color c) {
    if (c.red + c.green + c.blue == 0)
        return (struct color) { 3, 3, 3 };

    if (c.red > 0 && c.red < 3)
        c.red = 3;
    if (c.green > 0 && c.green < 3)
        c.green = 3;
    if (c.blue > 0 && c.blue < 3)
        c.blue = 3;

    c.red /= 0.7;
    c.green /= 0.7;
    c.blue /= 0.7;

    if (c.red > 255)
        c.red = 255;
    if (c.green > 255)
        c.green = 255;
    if (c.blue > 255)
        c.blue = 255;

    return c;
}

(e)

struct color darker(struct color c) {
    c.red *= 0.7;
    c.green *= 0.7;
    c.blue *= 0.7;

    return c;
}

10. (a)

    int area = (r.lower_right.x - r.upper_left.x) * (r.lower_right.y - r.upper_left.y);

(b)

struct point rectangle_center(struct rectangle r) {
    struct point p;

    p.x = (r.lower_right.x - r.upper_left.x) / 2;
    p.y = (r.lower_right.y - r.upper_left.y) / 2;

    return p;
}

(c)

struct rectangle move_rect(struct rectangle r, int x, int y) {
    r.upper_left.x += x;
    r.upper_left.y += y;
    r.lower_right.x += x;
    r.lower_right.y += y;

    return r;
}

(d)

bool is_within_rect(struct rectangle r, struct point p) {
    if (p.x > r.upper_left.x && p.x < r.lower_right.x && p.y > r.upper_left.y && p.y < r.lower_right.y)
        return true;
    else
        return false;
}

11. double 8 byte + union 8 byte (for double) + char 4 byte 총 20byte가 할당된다.

12. struct가 4+8+4로 16byte를 할당받으므로 union에는 16byte가 할당된다.

13. (a), (b), (d) 가 옳은 표현이다.

(c) s.u.rectangle.height = 25; (e) s.u.circle.radius = 5; (f) s.u.circle.radius = 5;

14. (a)

double shape_area(struct shape s) {
    if (s.shape_kind == RECTANGLE)
        return s.u.rectangle.height * s.u.rectangle.width;
    else
        return 3.1415 * s.u.circle.radius * s.u.circle.radius;
}

(b)

struct shape shape_move(struct shape s, int x, int y) {
    s.center.x += x;
    s.center.y += y;

    return s;
}

(c)

struct shape shape_scale(struct shape s, double c) {
    if (s.shape_kind == RECTANGLE) {
        s.u.rectangle.height *= c;
        s.u.rectangle.width *= c;
    } 
    else
        s.u.circle.radius *= c;
    return s;
}

15. (a)

enum days = { MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY };

(b)

typedef enum { MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY } days;

16. (a), (c), (e) 가 옳은 표현이다.

17. (b), (c)는 범위 밖의 정수를 가리키게 될 위험이 있다.

18. (a)

    typedef enum {EMPTY, PAWN, KNIGHT, BISHOP, ROOK, QUEEN, KING} Piece;
    typedef enum {BLACK, WHITE} Color;

(b)

typedef struct { Piece; Color; } Square;

(c) Square board[8][8];

19. struct pinball_machine {
    char[40] name;
    int year;
    enum { EM, SS } type;
    int players;
    };

20. switch (direction) {
    case NORTH: y--;
    break;
    case SOUTH: y++;
    break;
    case EAST:  x++;
    break;
    case WEST:  x--;
    break;
    default:    
    break;
    }

21. (a) 0, 1, 2, 3 (b) 11, 12, 13 (c) 14, 15, 16, 24, 25 (d) 45, 46, 47, 37, 38, 39

22. (a)

    enum chess_pieces {KING = 200, QUEEN = 9, ROOK = 5, BISHOP = 3, KNIGHT = 3, PAWN = 1};

(b)

const int piece_value[] = {
    [KING] = 200, 
    [QUEEN] = 9,
    [ROOK] = 5, 
    [BISHOP] = 3,
    [KNIGHT] = 3,
    [PAWN] = 1
};

📍 Structures, Unions, and Enumerations

구조체 : 서로 다른 형을 가질 수도 있는 값(구성원)의 집합 공용체 : 구조체와 유사하나 각 구성원이 같은 저장 공간을 공유, 그렇기에 공용체는 한 번에 동시에 모든 구성원을 저장할 수 없고, 한 구성원만을 저장 열거형 : 프로그래머가 명명한 값으로 된 정수형

📍 Structure Variables

구조체의 원소(member)는 같은 형일 필요가 없다. 구조체의 구성원들에겐 이름이 존재하여 특정 구성원을 선택하려면 위치가 아닌 이름을 특정해주어야 한다.

📍 Declaring Structure Variables

🔎 부품 번호, 부품 이름, 부품 개수 저장하기

struct {
    int number;
    char name[NAME_LEN + 1];
    int on_hand;
} part1, part2;

구조체의 구성원(member) : number, name, on_hand 형 : struct 변수 : part1, part2

NAME_LEN의 값이 25라고 하면, 변수 part1은 다음과 같이 메모리에 저장된다.

각 구조체는 새로운 스코프를 갖는다. C 용어로 말하면 각 구조체는 구성원들에 대해 서로 다른 이름 공간 (namespace)를 갖는다고 한다.

예를 들어 아래와 같이 선언할 수 있다.

struct {
    int number;
    char name[NAME_LEN + 1];
    int on_hand;
} part1, part2;

struct {
    char name[NAME_LEN + 1];
    int number;
    char sex;
} employee1, employee2;

📍 Initializing Structure Variables

🔎 구조체 선언 시에 초기화하기

struct {
    int number;
    char name[NAME_LEN + 1];
    int on_hand;
} part1 = { 528, "Disk drive", 10 }, 
part2 = { 914, "Printer cable", 5 };

초기화할 구조체의 구성원 수보다 적은 수의 초기자가 주어질 경우 나머지 초깃값은 0이 된다. 특히 문자형 배열의 나머지 바이트들은 0이 되어 비어있는 문자열이 된다.

📍 [C99] Designated Initializers

🔎 지정 초기자

{.number = 528, .name = "Disk drive", .on_hand = 10}

지정자(designator) : 구두점(.) + 구성원 이름

🔎 지정 초기자의 장점

1) 구조체의 구성원과 초기자 값의 대응을 볼 수 있어 코드가 읽기 쉽다.

2) 초기자의 값들이 구조체의 구성원과 같은 순서일 필요가 없다. 즉, 순서가 중요하지 않다.

지정 초기자에 있는 모든 값이 반드시 지정자를 적어주어야 하는 것은 아니다.

{.number = 528, "Disk drive", .on_hand = 10}

📍 Operations on Structures

구조체 내의 구성원에 접근하려면, (구조체의 이름).(구성원의 이름)으로 접근할 수 있다.

🔎 part1의 구성원 값들 출력

printf("Part number: %d\n", part1.number);
printf("Part name: %s\n", part1.name);
printf("Quantity on hand: %d\n", part1.on_hand);

구조체의 구성원은 lvalue이다.

구두점(.)은 연산자로, ++, -- 등과 같은 연산 순서를 가진다.

또한 구조체는 = 연산자를 이용하여 복사가 가능하다.

part2 = part1;

위 구문은 part1.number을 part2.number2에 복사, part1.name은 part2.name에 복사한다.

배열은 = 연산자로 복사가 불가능하지만 구조체 안에 존재하는 배열은 해당 구조체가 복사될 때 같이 복사된다.

🔎 구조체 내 배열 복사

struct { int a[10]; } a1, a2;

a1 = a2; 

= 연산자는 호환 가능한 구조체 간에만 사용할 수 있다. 동시에 선언된 두 구조체나, 같은 구조체 태그를 갖고 선언된 구조체, 같은 형명을 갖는 구조체들이 서로 호환될 수 있다.

할당 이외에는 추가적인 연산이 제공되지 않는다.

📍 Structure Types

변수를 한 번만 선언하는 경우는 괜찮지만, 다른 곳에서 또 선언해야 하는 경우에는 복잡해진다.

🔎 여러 번 선언

struct {
    int number;
    char name[NAME_LEN + 1];
    int on_hand;
} part1;

struct {
    int number;
    char name[NAME_LEN + 1];
    int on_hand;
} part2;

이렇게 했을 때의 문제점은 part1과 part2가 호환이 되지 않는다는 점이다. part1은 part2에 할당될 수 없고, part2는 part1에 할당될 수 없다. 또한 part1, part2의 형 이름이 무엇인지 알 수 없어 함수 호출에서 인수로 사용할 수 없다.

이런 어려움들을 피하기 위해 구조체의 이름을 정의한다.

🔎 structure의 이름 짓기

1) 구조체 태그(structure tag)를 선언하기 2) typedef를 사용하여 형 이름 정의하기

📍 Declaring a Structure Tag

구조체 태그(structure tag) : structure의 종류를 식별하는데 사용되는 이름

🔎 구조체 태그(part) 선언하기

struct part {
    int number;
    char name[NAME_LEN + 1];
    int on_hand;
};

이제 part를 변수 선언에 이용할 수 있다.

struct part part1, part2;

이 때 struct를 빼먹으면 안 된다. part는 형 이름은 아니다.

structure tag를 선언함과 동시에 변수 선언도 가능하다.

struct part {
    int number;
    char name[NAME_LEN + 1];
    int on_hand;
} part1, part2;

📍 Defining a Structure Type

typedef를 이용하여 실제 형 이름(type name)을 정의할 수 있다.

🔎 typedef를 이용하여 형 이름을 Part로 선언하기

typedef struct {
    int number;
    char name[NAME_LEN + 1];
    int on_hand;
} Part;

Part는 형 이름이므로 structure tag에서와는 다르게 Part만을 이용하여 변수를 선언해줄 수 있다.

Part part1, part2;

🔎 Structure tag vs Typedef

구조체가 linked list로 사용될 때는 Structure tag가 필수적이다. 따라서 이 책의 대부분의 예에서는 typedef 대신 structure tag를 사용하였다.

📍 Structures as Arguments and Return Values

함수는 인자(argument)와 반환 값(return value)로 구조체를 가질 수 있다.

🔎 구조체가 인자

void print_part(struct part p)
{
    printf("Part number : %d\n", p.number);
    printf("Part name : %s\n", p.name);
    printf("Quantity on hand : %d\n", p.on_hand);
}


print_part(part1); 

🔎 구조체가 반환값

struct part build_part(int number, const char* name, int on_hand)
{
    struct part p;

    p.number = number;
    strcpy(p.name, name);
    p.on_hand = on_hand;
    return p;
}

이 때 구조체를 함수에 전달하는 것과, 구조체를 반환할 때 모두 구조체 내 모든 구성원의 복사가 일어난다.

따라서 구조체 자체를 전달하기보다 포인터를 전달하는 것이 권장될 때가 있다. 반환 값에서도 포인터를 반환할 수 있다.

또한 열린 파일의 상태에서 작업을 수행하는 경우에도 포인터를 사용하는 것이 효과적이다. 예를 들어 <stdio.h>는 FILE이라는 형식의 type 이름을 가지고 있는데, 각 FILE 구조는 열린 파일의 상태에 대한 정보를 저장하므로 프로그램에서 고유해야 한다. 따라서 이 경우도 포인터를 이용한다.

경우에 따라 함수 내부의 구조체를 다른 구조체로 초기화시킬 수 있다.

🔎 part2를 part1와 동일한 값으로 초기화

void f(struct part part1)
{
    struct part part2 = part1;
    ...
}

📍 [C99] Compound Literals (복합리터럴)

구조체에서 복합 리터럴은 먼저 변수를 저장하지 않고 "즉시" 구조를 만드는데 사용될 수 있다. 그 결과물(구조체)는 파라미터로 전달될 수 있고, 함수에 의해 반환될 수 있고, 변수에 할당될 수 있다.

일반적으로 복합리터럴은 괄호 안의 형식 이름과, 중괄호로 둘러싸인 값의 집합으로 구성된다.

🔎 복합리터럴을 이용하여 함수에 전달

print_part((struct part) {528, "Disk drive", 10});

복합리터럴은 part라는 구조체를 만든다.

🔎 복합리터럴을 이용하여 변수에 할당

part1 = (struct part) {528, "Disk drive", 10};

복합리터럴은 지정자(designators)를 포함할 수 있다.

🔎 지정자가 포함된 복합 리터럴

print_part((struct part) {
        .on_hand = 10,
        .name = "Disk drive",
        .number = 528
});

📍 Nested Arrays and Structures

구조체는 어레이의 구성요소로 들어갈 수 있고 어레이는 구조체의 구성요소가 될 수 있다.

📍 Nested Structures

아래와 같은 구조체가 있을 때,

struct person_name {
    char first[FIRST_NAME_LEN + 1];
    char middle_initial;
    char last[LAST_NAME_LEN + 1];
};

구조체 안에 구조체를 넣을 수 있다.

struct student {
    struct person_name name;
    int id, age;
    char sex;
} student1, student2;

이 때 student1의 name 중에서도 first에 접근하고자 한다면 아래와 같이 구두점(.)을 이용하면 된다

strcpy(student1.name.first, "Fred"); 

🔎 name을 구조체로 만든 것의 장점

name을 데이터의 단위로써 다룰 수 있다. name을 출력하는 함수를 만들고자 할 때, 인수로 하나만 전달하면 된다.

🔎 name을 출력하는 함수

display_name(student1.name);

🔎 person_name 구조체에서 name을 student 구조체의 member로 복사하기

struct person_name new_name;
...
student1.name = new_name;

📍 Arrays of Structures

어레이와 구조체의 결합에서 자주 쓰이는 것 중 하나는 구조체가 어레이를 이루는 것이다.

아래 예시 구조체 part의 어레이는 part 100개의 정보를 저장할 수 있다

struct part inventory[100];

이 어레이의 요소에 접근하려면 배열첨자[ ]를 이용하면 된다.

print_part(inventory[i]);

구조체 part의 구성원(member)에 접근하려면 배열첨자와 구두점을 이용하여 멤버를 선택하면 된다.

🔎 inventory[i]의 구성원 number에 883 할당하기

inventory[i].number = 883;

name의 문자 하나에 접근하려면 마찬가지로 배열 첨자를 이용하면 된다.

🔎 inventory[i]에 저장된 name을 빈 문자열로 만들기

inventory[i].name[0] = '\0';

📍 Initializing an Array of Structures

구조체 어레이를 초기화 하는 것은 다차원 어레이를 초기화하는 것과 거의 동일하다. 구조체 어레이를 초기화하는 이유 중 하나는 이를 실행 중 값이 변하지 않는 데이터베이스 취급하기 위해서 이다.

🔎 구조체를 이용하여 국가번호 저장하기

struct dialing_code {
    char* country;
    int code;
};

🔎 위 구조체를 담고 있는 어레이 초기화 하기

const struct dialing_code country_codes[] = {
    {"Argentina",        54}, {"Bangladesh",        880},
    {"Brazil",        55}, {"Burma (Myanmar)",     95}
    ...
};

struct part inventory[100] =
{ [0] .number = 528, [0].on_hand = 10, [0].name[0] = '\0' };

📍 [PROGRAM] Maintaining a Parts Database

창고에 남아있는 부품들을 표시하는 프로그램을 작성해보자 들어갈 정보는 부품 번호, 이름, 수량이다.

• 새로운 부품 번호, 이름, 남은 수량을 추가할 수 있도록 한다. 만약 이미 해당 부품이 있거나 가득찬 경우 에러 메세지를 출력한다.

• 부품 번호가 주어지면 이름, 남은 수량을 출력할 수 있도록 한다. 만약 해당 부품이 데이터베이스에 없다면 에러 메세지를 출력한다.

• 부품 번호가 주어지면 남은 수량을 변경할 수 있도록 한다. 만약 해당 부품이 데이터베이스에 없다면 에러 메세지를 출력한다.

• 데이터베이스에 담긴 정보 전체를 출력할 수 있도록 한다. 입력한 순서대로 출력되도록 한다.

• 프로그램 실행 종료

이 행동들을 하기 위해 i(insert), s(search), u(update), p(print), q(quit)을 이용한다.

🔎 inventory.c

#include <stdio.h>
#include "readline.h"

#define NAME_LEN 25
#define MAX_PARTS 100

struct part {
    int number;
    char name[NAME_LEN + 1];
    int on_hand;
} inventory[MAX_PARTS];

int num_parts = 0;

int find_part(int number);
void insert(void);
void search(void);
void update(void);
void print(void);

int main(void)
{
    char code;
    for (;;) {
        printf("Enter operation code : ");
        scanf(" %c", &code);
        while (getchar() != '\n');
        switch (code) {
        case 'i': insert();
            break;
        case 's': search();
            break;
        case 'u': update();
            break;
        case 'p': print();
            break;
        case 'q': return 0;
        default: printf("Illegal code\n");
        }
        printf("\n");
    }
}

int find_part(int number)
{
    int i;

    for (i = 0; i < num_parts; i++)
        if (inventory[i].number == number)
            return i;
    return -1;
}

void insert(void)
{
    int part_number;

    if (num_parts == MAX_PARTS) {
        printf("Database is full; can't add more parts.\n");
        return;
    }

    printf("Enter part number : ");
    scanf("%d", &part_number);

    if (find_part(part_number) >= 0) {
        printf("Part already exists.\n");
        return;
    }

    inventory[num_parts].number = part_number;
    printf("Enter part name : ");
    read_line(inventory[num_parts].name, NAME_LEN);
    printf("Enter quantity on hand : ");
    scanf("%d", &inventory[num_parts].on_hand);
    num_parts++;
}

void search(void)
{
    int i, number;

    printf("Enter part number : ");
    scanf("%d", &number);
    i = find_part(number);
    if (i >= 0) {
        printf("Part name : %s\n", inventory[i].name);
        printf("Quantity on hand : %d\n", inventory[i].on_hand);
    }
    else
        printf("Part not found.\n");
}

void update(void)
{
    int i, number, change;

    printf("Enter part number : ");
    scanf("%d", &number);
    i = find_part(number);
    if (i >= 0) {
        printf("Enter change in quantity on hand : ");
        scanf("%d", &change);
        inventory[i].on_hand += change;
    }
    else
        printf("Part not found.\n");
}

void print(void)
{
    int i;

    printf("Part Number        Part Name            "
        "Quantity on Hand\n");
    for (i = 0; i < num_parts; i++)
        printf("%7d            %-25s%11d\n", inventory[i].number,
            inventory[i].name, inventory[i].on_hand);
}

🔎 readline.h

#ifndef READLINE_H
#define READLINE_H

int read_line(char str[], int n);

#endif

🔎 readline.c

#include <ctype.h>
#include <stdio.h>
#include "readline.h"

int read_line(char str[], int n)
{
    int ch, i = 0;

    while (isspace(ch = getchar()));
    while (ch != '\n' && ch != EOF) {
        if (i < n)
            str[i++] = ch;
        ch = getchar();
    }
    str[i] = '\0';
    return i;
}

📍 Unions

공용체(union)는 구조체 처럼 하나 이상의 서로 다른 유형의 구성원(member)을 가질 수 있다. 그러나 컴파일러는 가장 큰 구성원을 위한 공간만을 할당하고, 서로 이 공간을 공유한다.

🔎 공용체 선언

union {
    int i;
    double d;
} u;

🔎 공용체 vs 구조체

struct {
    int i;
    double d;
} u;

가 있다고 가정할 때 둘의 차이는 메모리의 주소에 있다.

🔎 공용체 선언 - u의 구성원 i에 82 할당하기

u.i = 82;

공용체의 경우 한 멤버를 변경하면 다른 멤버에 저장되어 있던 값들이 변화한다. 따라서 이 경우 u.d의 값을 변화시켜주면 u.i에 저장된 값은 사라진다.

따라서 공용체 u는 i, d 둘다가 아닌 i나 d 중 하나를 저장시키는 공간이다.

공용체의 특성은 구조체와 거의 동일하다. tag와 type을 동일한 방법으로 선언할 수 있으며 = 연산자를 이용하여 할당할 수 있다.

다만 공용체에서는 첫번째 구성원만 초기화가 가능하다.

union {
    int i;
    double d;
} u = { 0 };

C99에서는 어떤 구성원을 초기화할지 지정할 수 있다. 구성원 하나만 초기화가 가능하나, 꼭 첫번째일 필요는 없다.

union {
    int i;
    double d;
} u = { .d = 10.0 };

📍 Using Unions to Save Space

아래의 선물 목록을 저장하고자 할 때,

Books : Title, author, number of pages Mugs : Design Shirts : Design, colors avialable, sizes available

구조체를 만들면 다음과 같다.

struct catalog_item {
    int stock_number;
    double price;
    int item_type;
    char title[TITLE_LEN + 1];
    char author[AUTHOR_LEN + 1];
    int num_pages;
    char design[DESIGN_LEN + 1];
    int colors;
    int sizes;
};

BOOK, MUG, SHIRT 모두 item_type을 가지고 있지만, colors, size 등은 shirts만 가지고 있는 것이기 때문에 공간 낭비가 일어나게 된다. 즉 책의 경우 design, colors, sizes를 저장할 필요가 없다.

이 경우 구조체에 공용체를 넣으면 공간낭비를 줄일 수 있다. 공용체의 구성원은 각각의 특수한 목록을 담은 구조체이어야 한다. 즉 겹치지 않는 것들은 구조체 내 공용체에 담으면 된다.

🔎 공용체를 이용한 catalog_item

struct catalog_item {
    int stock_number;
    double price;
    int item_type;
    union {
        struct {
            char title[TITLE_LEN + 1];
            char author[AUTHOR_LEN + 1];
            int num_pages
        } book;
        struct {
            char design[DESIGN_LEN + 1];
        } mug;
        struct {
            char design[DESIGN_LEN + 1];
            int colors;
            int sizes;
        } shirt;
    } item;
};

만약 c가 책을 가리키는 catalog_item 구조체라면, 다음과 같이 책의 title을 출력할 수 있다.

printf("%s", c.item.book.title);

만약 mug의 design에 "Cats"를 할당한다면, 공용체 내 다른 구조체의 design에도 똑같이 "Cats"가 할당된다.

strcpy(c.item.mug.design, "Cats");

printf("%s", c.item.shirt.design); /* prints "Cats" */

📍 Using Unions to Build Mixed Data Structures

union을 활용하여 다양한 유형의 데이터가 혼합된 데이터 구조를 생성할 수 있다.

만약 int와 double이 혼합된 어레이를 만든다고 가정하자. 어레이는 한 가지의 유형만 가질 수 있으므로 불가능한 것처럼 보이지만 공용체를 사용하면 가능하다.

먼저 서로 다른 종류의 데이터를 담는 공용체를 만든다.

typedef union {
    int i;
    double d;
} Number;

그 후, 요소가 Number인 어레이를 제작하면 된다.

Number number_array[1000];

그럼 number_array에는 int 와 double 모두를 저장할 수 있다.

number_array[0].i = 5;
number_array[1].d = 8.395;

📍 Adding a "Tag Field" to a Union

Union에는 치명적인 단점이 있다. 최근에 어떤 구성원이 변경되었는지 알 수 없어 의미없는 값이 담겨있어도 알 수가 없다.

우리는 조합에 현재 저장되어 있는 것을 상기시키는 것을 목적으로 태그 필드(tag field) 또는 차별자(discriminant)를 구조체 안에 공용체를 포함시킬 수 있다.

앞서 catalog_item 구조체에서는 item_type이 이러한 역할을 수행한다.

🔎 tag field를 이용하여 구조체 선언

#define INT_KIND 0
#define DOUBLE_KIND 1

typedef struct {
    int kind; /* tag field */
    union {
        int i;
        double d;
    } u;
} Number; 

kind는 INT_KIND거나 DOUBLE_KIND이다.

u의 구성원에 값을 할당할 때 마다 수정사항을 상기키시기 위해 kind도 함께 변경시키면 된다.

🔎 n이 Number의 변수인 경우 u의 i 멤버를 할당하기

n.kind = INT_KIND;
n.u.i = 82;

이렇게 하면 Number 변수에 지정된 숫자를 검색해야 할 때, kind는 어떤 공용체가 마지막으로 값을 할당받았는지 알려준다.

void print_number(Number n) { if (n.kind == INT_KIND) printf("%d", n.u.i); else printf("%g", n.u.d); }

📍 Enumerations

많은 프로그램에서, 단지 작은 의미 있는 값들의 집합만을 가진 변수들이 필요할 것이다. 예를 들어 카드 게임에서 카드명을 저장하는 변수는 "클로버" "다이아몬드" "하트" "스페이드" 4가지의 값이 필요하다.

이러한 변수를 처리하는 확실한 방법은 가능한 변수의 값과 정수를 매치시키는 것이다.

int s; /* s will store a suit */
...
s = 2; /* 2 represents "hearts" */

이러한 경우 총 4가지의 변수를 가지고 있다는 점이나, 2가 의미하는 바 등이 직관적이지 않다.

매크로를 이용하여 suit의 유형과 이름을 정의할 수 있다.

#define SUIT int 
#define CLUBS 0
#define DIAMONDS 0
#define HEARTS 0
#define SPADES 0

이 경우 좀 더 읽기 쉽도록 만들어진다

SUIT s;
...
s = HEARTS;

그러나 완벽한 해결책은 아니다. 프로그램을 읽는 사람에게는 매크로가 동일한 "유형"의 값을 나타낸다는 표시가 없다. 또한 정의한 이름은 전처리에 의해 제거되므로 디버깅 중에 사용할 수 없다.

C는 가능한 값의 수가 적은 변수를 위해 특별히 설계된 특수한 유형을 제공한다. 열거형(enumerated type)은 프로그래머에 의해 값이 나열되는 유형이며, 프로그래머는 각 값에 대한 이름(enumeration constant)을 생성해야 한다.

🔎 변수 s1과 s2에 할당할 수 있는 값을 열거

enum {CLUBS, DIAMONDS, HEARTS, SPADES} s1, s2; 

열거형이 함수 내부에서 선언되면 해당 상수는 함수 외부에서 사용할 수 없다.

📍 Enumeration Tags and Type Names

구조체, 공용체와 함께 열거형의 이름을 지을 두가지 방법이 있다. tag를 선언하거나 typedef를 사용하여 실제 형 이름을 만드는 것이다.

열거형 태그는 구조체, 공용체 태그와 유사하다.

🔎 suit 태그 정의

enum suit {CLUBS, DIAMONDS, HEARTS, SPADES};

🔎 suit의 변수 정의

enum suit s1, s2;

대안으로 Suit를 형 이름으로 만들기 위해 typedef를 이용할 수 있다

typedef enum {CLUBS, DIAMONDS, HEARTS, SPADES} Suit; 
Suit s1, s2;

📍 Enumerations as Integers

C는 열거형 변수들을 정수처럼 다룬다. 컴파일러는 각각의 열겨형들에 0, 1, 2.. 를 할당한다. 앞서 suit 열거형을 예시로 들면, CLUBS, DIAMONDS, HEARTS, SPADES는 각각 0, 1, 2, 3에 대응된다.

다른 상수를 넣고 싶다면 원하는 값을 할당해줄 수도 있다.

enum suit {CLUBS = 1, DIAMONDS = 2, HEARTS = 3, SPADES = 4};

같은 상수를 갖는 것도 가능하다. 열거형은 결국 정수이므로 다른 정수와 섞는 것도 가능하다.

int i;
enum {CLUBS, DIAMONDS, HEARTS, SPADES} s;

i = DIAMONDS;
s = 0;
s++;
i = s + 2; 

컴파일러는 s를 정수처럼 다룬다.

📍 Using Enumerations to Declare "Tag Fields"

앞서 16.4 절에서 다루었던, 최근에 수정된 값들을 파악하는데 열거형은 효과적이다. 예를 들어 kind 변수를 int 대신 열거형으로 만들면 다음과 같다.

🔎 열거형을 이용해 kind 만들기

typedef struct {
    enum {INT_KIND, DOUBLE_KIND} kind;
    union {
        int i;
        double d;
    } u;
} Number;

📍 Exercises

1. (a) 1) 프로그램의 구조가 명확해진다. 2) 각 소스 파일들을 따로 컴파일 시킬 수 있어 프로그램의 규모가 크거나 자주 수정되는 경우 시간이 절약된다. 3) main함수와 다른 함수들을 분리함으로써 다른 프로그램에서 함수 재사용이 가능하다.

   (b) 1) 오류가 발생할 가능성이 있다. (형정의를 서로 다르게 하는 등)

2. (b) 같은 함수가 여러번 컴파일 된다.

3. 문제가 발생한다. 우리가 직접 만든 파일의 이름이 해당 경로에 있는 헤더의 이름과 일치하지 않아 찾을 수가 없다.

4. Output if DEBUG is defined:
   Value of i : 1
   Value of j : 2
   Value of k : 3
   Value of i + j : 3
   Value of 2 * i + j - k : 1

   (b)

   Output if DEBUG is not defined:

   (c)

i. #define DEBUG를 한 경우 testdebug.c에서 DEBUG를 정의해준 경우 debug.h에서 PRINT_DEBUG(n)는 printf("Value of " #n " : %d\n", n)로 대체되어 값을 출력해준다. testdebug.c에서는 #ifdef 문을 만족하여 Output if DEBUG is defined: 가 출력한다. 그 후 PRINT_DEBUG로 가는데, 여기서 헤더파일에 의해 값들을 출력해준다.

*ii. #define DEBUG를 하지 않은 경우 * testdebug.c에서 DEBUG를 정의해주지 않은 경우 debug.h 에서 PRINT_DEBUG(n)가 정의되지 않는다. testdebug.c에서는 #else 문으로 가게 되어 Output if DEBUG is not defined: 가 출력된다. 그 후 PRINT_DEBUG로 가는데, 여기서 아무 행동도 하지 않으므로 아무것도 출력하지 않고 끝난다.

demo: main.o f1.o f2.o
    gcc -o demo main.o f1.o f2.o

main.o: main.c f1.h
    gcc -c main.c

f1.o: f1.h f2.h
    gcc -c f1.c

f2.o: f1.h f2.h
    gcc -c f2.c

6. (a) main.c, f1.c, f2.c (b) f1.c (c) main.c, f1.c, f2.c (d) f1.c, f2.c

📍 Writing Large Programs

소스 파일은 함수와 외부 변수의 정의부를 갖고 있고, 헤더 파일은 소스 파일간 공유할 정보를 갖고 있다.

📍 Source Files

C 프로그램은 여러개의 소스 파일로 나뉠 수 있다. 각 소스파일은 주로 함수와 변수들의 정의가 담겨 있으며 소스 파일들 중 하나는 반드시 프로그램의 시작점을 의미하는 main 함수를 가지고 있어야 한다.

🔎 프로그램을 여러 소스 파일로 나눌 때의 장점

1) 관련이 있는 함수, 변수들을 한 파일로 모으면 프로그램의 구조가 명확해진다.

2) 각 소스 파일들은 따로 컴파일 시킬 수 있어 프로그램의 규모가 크거나 자주 수정되는 경우 시간이 절약된다

3) 함수들을 따로 소스 파일로 정리해주면 다른 프로그램에서도 재사용할 수 있다. main 함수와 다른 함수들을 분리함으로써 다른 프로그램에서 해당 함수 사용이 가능해진다.

📍 Header Files

#include 지시자를 통해 여러 소스 파일 간 함수 원형, 매크로 정의, 형 정의 등과 같은 정보들을 공유할 수 있다.

#include 지시자는 전처리기에게 주어진 파일을 열어 그 내용을 현재 파일에 전부 붙여넣기 만든다. 이런 식으로 추가되는 파일들을 헤더 파일(header file)이라고 부른다.

📍 The #include Directive

🔎 #include 사용

1) C 자체 라이브러리에 존재하는 헤더 파일을 추가할 때

#include <filename>

시스템 헤더 파일들이 있는 폴더에서 파일을 찾는다.

2) 직접 작성해준 헤더 파일 등

#include "filename"

이 경우 현재 폴더에서 파일을 찾는다.

📍 Sharing Macro Definitions and Type Definitions

매크로 정의, 행 정의들을 소스 파일들 간에 공유해야 할 때는 헤더파일에 넣어주는 것이 좋다.

그러면 소스 파일마다 일일이 정의를 넣어줄 필요가 없으며 프로그램을 수정하기가 쉬워진다. 또한 소스 파일들이 서로 같은 매크로와 형을 다르게 정의하는 일을 막을 수 있다.

📍 Sharing Function Prototypes

함수의 원형이 정의되기 전에 호출되는 것을 막기 위해 헤더 파일에 함수의 원형을 넣어주면 된다.

예를 들어 foo.c에 f라는 함수가 선언되어 있다면 foo.h라는 헤더파일을 만들어 f의 함수 원형을 넣고, foo.h를 foo.c와 f를 호출하는 소스 파일에 추가해준다.

🔎 예시 (stack)

📍 Sharing Variable Declarations

외부변수는 함수와 같은 방법으로 파일끼리 공유할 수 있다.

아래의 경우 i를 선언하고 정의도 해준다.

int i

만약 변수를 정의하지 않고 선언만 해주려면 extern 키워드를 이용하면 된다.

extern int i;

이 경우 컴파일러는 이러한 파일들에 대해 각각 i의 공간을 전부 할당해주지는 않는다.

변수를 파일 간 공유를 할 땐 동일한 변수가 서로 다른 파일에서 다르게 선언되지 않도록 주의해야 한다.

파일 간 변수를 공유하는 것은 몇 가지 단점들이 있다.

📍 Nested Includes (내부 인클루드)

헤더 파일에서도 #include 지시자를 이용할 수 있다. 예를 들어 stack.h에 boolean.h 파일을 추가해줄 수 있다.

📍 Protecting Header Files

같은 헤더 파일이 두 번 추가되는 것을 막아주어야 한다. 헤더 파일을 보호하기 위해서는 파일의 내용물을 #ifndef-#endif로 감싸주면 된다.

#ifndef BOOLEAN_H
#define BOOLEAN_H

#define TRUE 1
#define FALSE 0
typedef int Bool;

#endif

이 파일을 처음 추가할 땐 BOOLEAN_H 매크로가 정의되어있지 않으므로 전처리는 #ifndef와 #endif 사이의 줄들을 그대로 내버려 둘 것이다. 그러나 다음에는 그 사이 줄들을 없앤다.

📍 #error Directives in Header Files

#error 지시자는 주로 헤더 파일 안에서 헤더 파일이 추가되지 말아야 할 조건들을 확인할 때 사용되곤 한다.

🔎 옛날 비표준 컴파일러 사용 방지

#ifndef __STDC__
#error This header requires a Standard C compiler
#endif

📍 Dividing a Program into Files

🔎 justify(텍스트 서식 프로그램)에 quote 파일 넣기

justify

   C     is quirky,  flawed,    and  an
enormous   success.      Although accidents of   history
 surely  helped,   it evidently    satisfied   a   need

    for  a   system  implementation    language    efficient
 enough   to  displace         assembly   language,
   yet sufficiently   abstract   and fluent    to describe
  algorithms   and     interactions    in a   wide   variety
of   environments.
                     --      Dennis     M.        Ritchie

이 프로그램을 UNIX 혹은 Windows 프롬프트에서 실행하기 위해서는 아래 명령어를 실행해야 한다.

justify <quote

< (input redirection) : justify가 입력을 키보드에서 받는 대신 OS로 하여금 quote 라는 파일에서부터 받도록 한다.

위 명령어를 실행하고 나면 다음과 같이 출력된다.

C is quirky,  flawed,  and  an  enormous  success.  Although
accidents of history surely helped, it evidently satisfied a
need for a system implementation language  efficient  enough
to displace assembly language, yet sufficiently abstract and
fluent to describe algorithms and  interactions  in  a  wide
variety of environments. -- Dennis M. Ritchie

output redirection을 이용하면 저장해 줄 수 있다. 아래 명령어를 통해 newquote에 출력된 내용을 저장할 수 있다.

justify <quote >newquote

justify에 대해 추가적으로 알아보면 불필요한 띄어쓰기나 빈 줄이 제거되어 정렬된다. 또한 20개의 문자보다 더 긴 단어를 읽게 되면 20개 이후의 문자들을 무시하고 별표로 대체한다.

예를 들어 antidisestablishmentarianism는 antidisestablishment* 로 출력된다.

이제 프로그램을 설계해보자. 먼저 단어들을 담고 있을 버퍼가 필요하다. 단어와 관련된 함수들을 한 파일(word.c)에 넣고, 줄 버퍼와 관련된 함수들은 다른 파일(line.c)에 넣을 수 있다. 또 justify.c에 main함수를 넣어준다.

🔎 word.c

#include <stdio.h>

#include "word.h"

int read_char(void)
{
    int ch = getchar();

    if (ch == '\n' || ch == '\t') {
         return ' ';
    }
    return ch;
}

void read_word(char* out_word, int len) {
    int ch = 0;
    int pos = 0;

    while ((ch = read_char()) == ' ') {
    }

    while (ch != ' ' && ch != EOF) {
        if (pos < len) {
            word[pos++] = ch;
        }
        ch = read_char();
    }
    word[pos] = '\0';
}

🔎 line.c

#include <stdio.h>
#include <string.h>

#include "line.h"

#define MAX_LINE_LEN 60

char g_line[MAX_LINE_LEN + 1];
int g_line_len = 0;
int g_num_words = 0;

void clear_line(void)
{
    g_line[0] = '\0';
    g_line_len = 0;
    g_num_words = 0;
}

void add_word(const char *word)
{
    if (g_num_words > 0) {
        g_line[g_line_len] = ' ';
        g_line[g_line_len+1] = '\0';
        g_line_len++;
    }
    strcat(g_line, word);
    g_line_len += strlen(word);
    g_num_words++;
}

int get_space_remaining(void)
{
    return MAX_LINE_LEN - g_line_len;
}

void write_line(void)
{
    int extra_spaces = MAX_LINE_LEN - g_line_len;
    int space_to_insert = 0;

    for (int i = 0; i < g_line_len; i++) {
        if (g_line[i] != ' ') {
            putchar(g_line[i]);
        } else {
            space_to_insert = extra_spaces / (g_num_words - 1);
            for (int j = 1; j <= space_to_insert + 1; j++) {
                putchar(' ');
            }
            extra_spaces -= space_to_insert;
            g_num_words--;
        }
    }
    putchar('\n');
}

void flush_line(void)
{
    if (g_line_len > 0)
        puts(g_line);
}

🔎 justify.c

/* 글자로 이루어진 파일을 정렬해준다. */

#include <string.h>

#include "line.h"
#include "word.h"

#define MAX_WORD_LEN 20

int main(void)
{
    char word[MAX_WORD_LEN + 2];
    int word_len;

    clear_line();
    for (;;) {
        read_word(word, MAX_WORD_LEN+1);
        word_len = strlen(word);
        if (word_len == 0) {
            flush_line();
            return 0;
        }
        if (word_len > MAX_WORD_LEN) {
            word[MAX_WORD_LEN] = '*';
        }
        if (word_len + 1 > space_remaining()) {
            write_line();
            clear_line();
        }
        add_word(word);
    }
}

📍 Building a Multiple-File Program

1) 컴파일 : 프로그램의 각 소스 파일들은 독립적으로 컴파일되어야 한다. (헤더파일은 컴파일할 필요X) 각 소스 파일마다 컴파일러는 목적 코드를 포함하는 파일인 목적 파일(object file)을 생성한다. windows에서는 .obj 확장자를 가진다.

2) 링크 : 링커는 전 단계에서 생성한 목적 파일을 라이브러리 함수를 위한 코드와 연결해주어 실행 가능한 파일을 생성한다.

📍 Makefiles

명령 줄에 모든 소스 파일을 적는 것은 시간 낭비 이므로 UNIX는 메이크파일(makefile)이라는 개념을 만들었다. 메이크파일은 파일들을 수록하며, 파일 간의 종속성(dependencies)또한 명시한다.

🔎 justify 프로그램을 위한 UNIX 메이크파일

justify: justify.o word.o line.o
    gcc -o justify justify.o word.o line.o

justify.o: justify.c word.h line.h
    gcc -c justify.c

word.o: word.c word.h
    gcc -c word.c

line.o: line.c line.h
    gcc -c line.c

1) 규칙(rule) : 각 부분 2) 목표(target) : 각 규칙의 첫 번째 줄, 그 뒤로 종속성이 있는 파일들 3) 명령(command) : 두번째 줄, 목표가 종속되어 있는 파일이 수정되어 목표를 재구축해야 할 경우 실행

예를 들어 첫번째 규칙에서는 justify가 목표이며 justify가 justify.o, word.o, line.o에 종속되어 있다. 프로그램이 가장 최근에 구축되었을 때 이 3가지 중 하나라도 변경사항이 있다면 justify는 재구축을 해야 한다.

추가적으로 gcc -c justify.c에서 -c는 justify.c를 목적 파일로 컴파일하되 링크는 하지 말라는 의미이다.

이런식으로 프로그램을 위한 메이크파일을 형성한 이후 make 기능을 이용하여 프로그램을 구축할 수 있다. 각 파일의 시간, 날짜를 확인하여 최신 여부를 판단할 수 있고 재구축이 가능하다.

🔎 make와 관련하여 알아야 하는 사항

1) 메이크 파일의 각 명령은 스페이스가 아닌 탭 문자로 띄어 쓴다.

2) 메이크파일은 보통 Makefile(또는 makefile)이라는 이름으로 저장한다.

3) make를 실행하려면 아래 명령어를 실행하면 된다.

make target 

여기서 target(목표)은 makefile에 수록된 목표중 하나이며 특정 목표를 명시하지 않을 경우 첫 번째 규칙의 목표를 구축한다.

📍 Errors During Linking

컴파일 때 검출하지 못한 몇몇 오류들은 링크할 때 검출되기도 한다. 특히 프로그램 내에 어떤 함수나 변수의 정의가 생략되어 있을 경우 미정의된 기호(undefined symbol) 또는 미정의도니 참조(undefined reference)와 같은 메시지를 출력한다.

🔎 링커 오류의 흔한 원인

1) 오타 2) 누락된 파일 3) 누락된 라이브러리

📍 Rebuiling a Program

프로그램을 다시 컴파일 하는 경우 시간을 절약하기 위해 오로지 최근 변경 사항에 해당하는 파일들만 재컴파일 해야 한다.

재컴파일해야 하는 파일(변화가 있는 파일)이 몇 개인지 보기 위해서는 두 가지 경우를 고려해야 한다.

1) 변화가 오로지 한 소스 파일에만 영향을 주는 경우 이 경우 해당 파일만 재컴파일 되어야 한다.

2) 한 헤더 파일에 수정사항이 있을 경우 이 경우 해당 헤더 파일을 추가한 모든 파일이 영향을 받을 수 있으므로 모두 재컴파일해야 한다.

justify.c word.c는 재컴파일 하고, line.c는 재컴파일 하지 않아도 되는 경우 아래의 명령을 사용하면 된다. (gcc 컴파일러 기준)

gcc -o justify justify.c word.c line.o

line.c는 재컴파일 하지 않아도 되므로 line.o 를 사용하였다.

makefile을 사용하는 장점 중 하나는 재구축이 자동으로 처리가 된다는 것이다. 각 파일의 날짜와 시간을 파악한 후 수정된 파일과 종속된 파일들을 모두 재컴파일 한다.

🔎 justify 프로그램을 재구축할 경우 make가 하는 행동

1) justify.c를 컴파일하여 justify.o 구축 2) word.c 컴파일 하여 word.o 구축 3) justify.o, word.o, line.o를 링크하여 justify 구축

📍 Defining Macros Outside a Program

프로그램 파일을 수정하지 않고도 매크로의 값을 수정할 수 있다.

대부분의 컴파일러는 명령 줄에서 매크로의 값을 정할 수 있는 -D 옵션을 지원한다.

gcc -DDEBUG=1 foo.c

이 경우 foo.c에서 DUBUG 매크로의 값이 1로 정의도니다.

또한 매크로를 미정의 시켜주는 -U 옵션도 존재한다.

📍 The Preproccessor

전처리기는 컴파일 이전에 C 프로그램을 수정해주는 소프트웨어이다.

📍 How the Preprocessor Works

전처리기의 행동은 전처리 지시자(preprocessing directives)에 의해 제어된다. (전처리 지시자 : # 문자로 시작되는 명령어 ex. #define, #include)

#define 지시자는 매크로(macro)를 정의한다. (매크로 : 상수, 자주 사용하는 표현식 등을 의미하는 이름)

#include : 특정 파일을 열고, 그 내용물을 컴파일할 파일에 추가한다.

아래 그림은 컴파일 과정에서 전처리기의 역할을 보여준다.

전처리기는 주석은 띄어쓰기 문자 하나로 대체한다.

대부분의 C 컴파일러는 전처리기의 출력물을 볼 수 있기 때문에 오류를 찾을 때 유용하다.

📍 Preprocessing Directives

🔎 전처리 지시자들

1) 매크로 정의(macro definition) : ex. #define으로 매크로 정의 2) 파일 추가(file inclusion) : ex. #include로 파일 추가 3) 조건적 컴파일(conditional compilation) : ex. #if, #ifdef, ifndef, #elif, #else, #endif로 코드의 특정 부분을 추가하거나 제외

🔎 지시자들의 규칙

1) #으로 시작한다. 2) 지시자와 토큰 사이에는 띄어쓰기가 임의의 개수만큼 들어갈 수 있다.

#    define         N     (100) (o)

3) 하나의 지시자에서 다음줄로 넘기려면 \로 끝나야 한다.

#define DISK_CAPACITY (SIDES *    \
               TRACKS_PER_SIDE)

4) 프로그램 어디서든 등장할 수 있다

📍 Macro Definitions

매크로에는 단순(simple)매크로 뿐 아니라 매개변수(parameterized)매크로도 존재한다.

📍 Simple Macros

🔎** simple macro (또는 object-like macro)**

#define identifier replacement-list

전처리기는 식별자가 대체목록을 의미하게 됨을 표시, 파일에 식별자가 등장하면 전처리기는 대체목록으로 대체한다.

단순 매크로는 고유상수를 정의하기 위해 주로 사용된다.

#define TRUE (1)
#define FALSE (0)
#define PI (3.14159)
#define MEM_ERR ("Error: not enough memory")

🔎 #define의 장점

1) 프로그램의 가독성, 수정성을 높여준다. 2) 일관성 없는 코드나 오타를 방지할 수 있다.

• #define의 추가적인 사용 조건적 컴파일 제어하기. 아래와 같은 코드로 디버깅 관련 출력을 담당하는 코드도 추가적으로 컴파일 할 수 있게 만들 수 있다.

  #define DEBUG 

C에서 매크로를 상수처럼 사용할 땐 이름을 전부 대문자로 작성하는 것이 관습이다.

📍 Parameterized Macros

🔎** parameterized macro (또는 function-like macro) **

#define identifier( X1, X2, ..., Xn ) replacement-list

🔎** 매개변수 매크로(parameterized macro)의 이용 **

#define MAX(x,y) ((x) > (y) ? (x) : (y))
#define IS_EVEN(n) ((n) % 2 == 0)

i = MAX(j+k, m-n);
if (IS_EVEN(i)) {
    ++i;
}

위의 예시처럼 매개변수 매크로는 간단한 함수처럼 작동하기도 한다.

좀 더 예시를 살펴보면,

#define TOUPPER(c) ('a' <= (c) && (c) <= 'Z' ? (c) - 'a' + 'A' : (c)) 

#define getchar() getc(stdin)

🔎** 매개변수 매크로(parameterized macro)의 장점 **

1) 프로그램이 조금 더 빨라진다. 함수 호출은 overhead를 필요로 할 수 있는데, 매크로는 그렇지 않다. 2) 매크로는 일반적(generic)이다. 함수 매개변수와 달리 특정한 형을 가지고 있지 않다.

🔎** 매개변수 매크로(parameterized macro)의 단점 **

1) 컴파일된 코드가 길어진다. 2) 입력변수의 형을 확인해주지 않는다. 3) 매크로를 가리키는 포인터를 가질 수 없다. (함수는 함수 포인터가 존재) 4) 매크로가 입력변수를 한 번 이상 평가할 수 있다. (함수는 한 번만 평가)

📍 The # Operator

#연산자는 매크로 입력변수를 문자열 리터럴로 치환한다.

🔎** # 연산자 사용 **

#define PRINT_INT(n) printf(#n " = %d\n", n)

에서 n 대신 문자열 리터럴을 넣어준다.

PRINT_INT(i/j);

따라서 위 코드는 아래와 같다.

printf("i/j=%d\n", i/j);

📍 The ## Operator

##연산자는 두 토큰을 하나의 토큰으로 붙여 준다.

🔎** ## 연산자 사용 **

#define MK_ID(n) i##n
int MK_ID(1);
int MK_ID(2);

와 같이 작성해주면 전처리 이후에는

int i1; 
int i2;

가 된다.

max 함수의 정의를 갖는 매크로를 작성하면, 일일이 만들지 않고 여러 형을 받도록 할 수 있다.

매크로로 두 개 이상의 max함수를 만들 수 없는데, ##연산자로 각 max마다 서로 다른 이름을 만들어 해결해줄 수 있다.

#define GENERIC_MAX(type) type type##_max(type x, type y) { return x > y ? x : y; }

만약 float형 변수를 사용한 max함수가 필요하면 아래와 같이 정의할 수 있다.

GENERIC_MAX(float)

그럼 전처리기에 의해 아래와 같이 바뀐다

float float_max(float x, float y)
{
    return x > y ? x : y;
}

📍 Generic Properties of Macro

🔎 ** 매크로에 적용되는 규칙 **

1) 매크로 대체 목록이 다른 매크로의 발동을 갖고 있을 수 있다.

#define PI (3.14159)
#define TWO_PI (2 * PI)

2) 전처리기는 식별자, 문자형 상수, 문자열 리터럴의 일부인 매크로 이름을 무시한다.

#define SIZE (256)
int BUFFER_SIZE;

위 코드의 경우 BUFFER_SIZE는 전처리의 영향을 받지 않는다.

3) 매크로의 정의는 보통 정의된 해당 파일 전체에 적용된다.

4) 똑같게 재정의를 하지 않는 이상 재정의는 불가능하다.

5) #undef 지시자에 의해 미정의 될 수도 있다. 아래코드는 현재 정의된 매크로 N을 삭제한다.

#undef N

📍 Parentheses in Macro Definitions

매크로에는 소괄호를 많이 써주는것이 좋다.

1) 대체목록에 연산자가 포함되어 있으면 반드시 대체목록을 소괄호로 감싸주어야 한다.

#define TWO_PI (2 * 3.14159)

2) 매크로가 매개변수가 있을 경우 매개변수를 모두 괄호로 감싸주어야 한다.

#define SCALE(x) ((x)) * 10)

📍 Creating Longer Macros

쉼표를 이용해 대체목록을 표현식의 연속체로 만들 수 있다.

🔎 ** 문자열을 읽은 다음 출력을 해주는 매크로 - (1) **

#define ECHO(s) (gets(s), puts(s))

이렇게 해서 ECHO를 마치 함수인 것처럼 사용할 수 있다.

ECHO(str); /* (gets(str), puts(str)); 이 된다 */

그러나 쉼표로는 표현식이 아니라 구문을 연결시킬 수는 없다. 구문을 연결시키려면 do 루프를 이용해야 한다.

🔎 ** 문자열을 읽은 다음 출력을 해주는 매크로 - (2) **

#define ECHO(s)                \
            do{        \
            gets(s);    \
            puts(s);    \
            } while (0)

세미콜론이 없다는 점을 눈여겨 보자.

ECHO를 사용할 땐 반드시 세미콜론을 이용해 do문을 완성시켜주어야 한다.

ECHO(str); /* do { gets(str); puts(str); } while (0); 이 된다*/

📍 Predefined Macros

🔎 ** C에서 사전정의된 매크로들 **

📍 Additional Predefined Macros in C99

🔎 ** C에서 사전정의된 매크로들 **

📍 Empty Macro Arguments

C99에서는 매크로의 모든 입력변수가 비어있을 수 있다. 이 경우 쉼표를 이용하여 어떤 입력변수가 생략되었는지 표시한다.

#define ADD(x,y) (x+y)

위와 같이 선언한 경우

i = ADD(, k); 

위의 구문은 다음과 같다

i = ( + k); 

빈 입력변수가 #의 피연산자의 경우에는 ""(빈 문자열)이 된다.

#define MK_STR(x) #x
...
char empty_string[] = MK_STR();

위의 구문은 전처리기에 의해 아래와 같이 바뀐다.

char empty_string[] = "";

빈 입력변수가 ##의 피연산자의 경우에는 위치 표시자 토큰으로 대체되어 존재하는 입력변수와 만나면 사라진다.

#define JOIN(x, y, z) x##y##z
...
int JOIN(a, b, c);
int JOIN(a, b, );
int JOIN(a, , c);
int JOIN(, , c);

위의 구문은 전처리기에 의해 아래와 같이 바뀐다.

int abc;
int ab;
int ac;
int c;

📍 Macris with a Variable Number of Arguments (가변 길이 입력변수 매크로)

C99에서는 무제한의 입력변수를 받을 수 있다. 이 기능의 주된 목적은 printf나 scanf와 같이 가변 길이 입력변수들을 받는 함수에 사용해주기 위해서 이다.

#define TEST(condition, ...) ((condition) ? \
    printf("Passed test: %s\n", #condition) : \
    printf(__VA_ARGS__))

... (생략부호(ellipsis)) : 매크로의 매개변수 목록에서 마지막에 위치하며, 일반적인 매개변수가 존재할 시 생략 부호 이전에 나온다

_VA_ARGS_ : 가변 길이 입력변수를 갖는 매크로의 대체목록에서만 나올 수 있는 특수한 식별자이다. 생략부호에 해당하는 모든 입력변수를 의미한다

TEST : 최소한 두 개의 입력변수를 필요로 한다. 첫번재 입력변수는 condition 매개변수에 대응하고, 나머지 입력변수들은 생략 부호에 대응한다.

🔎 ** TEST 매크로의 실제 용법 **

TEST(voltage <= max_voltage, "Voltage %d exceeds %d\n", voltage, max_voltage);

만약 voltage <= max_voltage라면 Passed test : voltage <= max_voltage를 출력, voltage > max_voltage 라면 *Voltage 125 exceeds 120 *을 출력할 것이다.

📍 The _func_ Identifier

_func_ 식별자는 현재 실행되는 함수의 이름을 저장하고 있는 문자열 변수처럼 행동한다.

static const char \__func__[] = "function-name";

이러한 식별자가 존재하기 때문에 다음과 같은 디버깅 매크로를 작성해줄 수 있다.

#define FUNCTION_CALLED() printf("%s가 호출됨\n", __func__);
#define FUNCTION_RETURNS() printf("%s가 반환함\n", __func__);

void f(void)
{
    FUNCTION_CALLED(); /* "f가 호출됨"을 출력함 */
    FUNCTION_RETURNS(); /* "f가 반환함"을 출력함 */
}

📍 Conditional Compilation

📍 The #if and #endif Directives

#if - #endif 짝을 이용하면 코드상에서는 남아있더라도 상황에 따라 컴파일 하지 않을 수 있다.

아래 코드의 경우 DEBUG 값이 1이므로 실행되며, DEBUG값을 0으로 바꾸면 컴파일되지 않는다.

#define DEBUG 1

#if DEBUG
printf("i의 값 : %d\n", i);
printf("j의 값 : %d\n", j);
#endif 

해당 식별자가 정의된 매크로일 경우 defined는 값 1을 내보내고, 아니라면 0을 내보낸다. 즉 해당 식별자가 매크로로서 정의되었는지를 판단하는 연산자이다.

#if define(DEBUG)
…
#endif

만약 DEBUG가 매크로로서 정의가 되어있다면 #if ~ #endif 사이 문이 실행된다.

📍 The #ifdef and #ifndef Directives

#ifdef 지시자는 식별자가 현재 매크로로 정의되어있는지 여부를 확인한다.

#ifdef identifier
...
#endif

식별자가 정의되어 있다면 #ifdef ~ #endif 사이 문이 실행된다. 이는 앞서 본 #if와 defined 연산자를 이용해서도 할 수 있다.

#ifndef는 #ifdef와는 반대로 식별자가 현재 매크로에 정의되어있지 않았는지의 여부를 확인한다.

📍 The #elif and #else Directives

#if, #ifdef, #ifndef 등과 더불어 #elif, #else를 사용하여 여러 조건들을 판별해줄 수 있다.

📍 Use of Conditional Compilation

🔎 여러 기계나 운영체제와 호환이 되는 프로그램을 작성할 때

#if defined(WIN32)
…
#elif defined(MAC_OS)
…
#elif defined(LINUX)
…
#endif

이를 이용해서 어느 운영체제에서 돌아가는지 표시를 해줄 수 있다.

🔎 다양한 컴파일러에서 컴파일할 수 있는 프로그램을 작성할 때

서로 다른 컴파일러들은 서로 다른 C버전을 인식할수 있기 때문에 오래된 컴파일을 사용해야 할 때는 _STDC_ 매크로 등을 이용해야 한다.

#if __STDC__
Function prototypes
#else
Old-style function declarations
#endif

🔎 매크로에 기본 정의를 내려줄 때

조건부 컴파일은 매크로가 현재 정의되었는지를 판단하고 그에 따른 행동을 해줄 수 있다. 아래 코드는 BUFFER_SIZE가 정의되지 않았다면 정의를 한다.

#ifndef BUFFER_SIZE
#define BUFFER_SIZE 256
#endif

🔎 일시적으로 주석을 포함한 코드를 없앨 때

#if 0
Lines containing comments 
#endif

📍 Miscellaneous Directives

#error, #line, #pragma 지시자

📍 The #error Directive

#error message

전처리기는 #error 지시자를 만나면 message를 반드시 포함하는 오류 문구를 출력한다. 오류 문구의 정확한 서식은 컴파일러마다 다르다.

🔎 #error 사용 예시

#if defined(WIN32)
…
#elif defined(MAC_OS)
…
#elif defined(LINUX)
…
#else
#error 특정된 운영체제가 없습니다
#endif

📍 The #line Directive

#line 지시자는 프로그램의 줄에 번호를 부여하는 법을 바꿀 때 사용한다. 또한 컴파일러가 다른 이름의 파일을 읽고 있도록 착각하게 만들 수 있다.

#line은 두 가지 서식을 갖는다.

1) #line 지시자 (1번 서식) #line n

이 지시자는 프로그램에서 다음 줄들이 n, n+1, n+2 순으로 번호가 변하게 만든다.

2) #line 지시자 (2번 서식) #line n "file"

지시자 이후에 나온 줄들은 "file"(파일명)을 갖는 파일에서 온 것으로 취급한다.

🔎 #line 사용 예시

#line 10 "bar.c"

컴파일러가 foo.c의 5번 줄에서 오류를 탐지한 경우 오류 문구는 foo.c파일의 5번째 줄이 아닌 bar.c 파일의 13번째 줄에서 오류가 났다고 인식한다.

13번째 줄인 이유는 지시자가 foo.c의 1번 줄을 차지하여 foo.c가 2번 줄부터 시작하기 때문이다.

#line 지시자는 주로 C 코드를 출력해주는 프로그램에서 사용한다. 제일 대표적인 예시로는 yacc(컴파일러의 컴파일러)가 있다.

📍 The #pragma Directive

#pragma 지시자는 컴파일러가 특정 행동을 하도록 부탁하게 만드는 방법이다.

📍 The _Pragma Directive

C99는 #pragma 지시자와 섞어 쓸 수 있는 _Pragma 연산자를 제공한다.

📍 Exercises

1. (b) %c는 char을 받는다. "\n"은 문자열로 취급됨 (c) %s는 문자열을 받는다. '\n'은 문자(char) 취급됨 (e) printf 함수는 문자열을 받는다. (h) putchar함수는 문자(char)을 받는다. (i) puts함수는 문자열을 받는다. (j) puts는 문자열을 쓴 후 개행문자도 추가로 출력해준다 따라서 개행이 2번 된다.
   
2. (a) putchar은 char값을 받는다. (d) puts는 포인터(여기서는 char*)을 받는다.
   
3. (i) 12 (s) abc34 (j) 56
   

4. #include <stdio.h>
   #include <ctype.h> // isspace 사용
   

int read_line(char str[], int n) { int ch; int i = 0;

while (isspace(getchar()));

while ((ch = getchar()) != '\n' && !isspace(ch)) {
    if (i < n) {
        str[i++] = ch;
    }
}
str[i] = '\0';
return i;

}

5. 
~~~ c
(a) 
void capitalize(char s[])
{
    for (int i = 0; s[i] == '\n'; i++) {
        toupper(s[i]);
    }
}

(b) 
void capitalize(char *s)
{
    for (; *s == '\n'; s++) {
        isupper(*s);
    }
}

6.

void censor(char *s)
{
    for (; *s == '\n'; s++) {
        if (*s == 'f' && *(s + 1) == 'o' && *(s + 2) == 'o') {
            *s = *(s+1) = *(s+2) = 'x';
        }
    }
}

7. (d)

8. tired-or-wired?\0

9. computers\0

10. q가 가리키는 문자열은 함수 범위 밖에서는 접근할 수 없다.

11.

int strcmp(char* str1, char* str2)
{
    while (*str1 == *str2) {
        if (*str1 == '\0') {
            return 0;
        }
        str1++; 
        str2++;
    }
    return *str1 - *str2;
}

12.

void get_extension(const char* file_name, char* extension)
{
    while (*file_name) {
        if (*file_name++ == '.') {
            strcpy(extension, file_name);
        }
    }
}

13. void build_index_url(const char* domain, char* index_url)
    {
    strcpy(index_url, "http://www");
    strcat(index_url, domain);
    strcat(index_url, "/index.html");
    }

14. Grinch

15. (a) 3 (b) 2 (c)

16.

int count_space(const char* s)
{
    int count = 0;

    while (*s) {
        if (*s == ' ') {
            count++; 
            s++;
        }
    }

    return count; 
}

17.

bool text_extension(const char* file_name, const char* extension)
{
    while (*file_name != '.') {
        file_name++;
    }
    file_name++;

    while (*file_name != '\0' && *extension != '\0')
    {
        if (toupper(*extension++) != toupper(*file_name++)) {
            return false;
        }
    }
    return true;
}

18.

void remove_filename(char* url)
{
    while(*url++);
    while (*url-- != '/');
    url++;
    *url = '\0';
}