안드로메다

김정선의 SQL Server 이야기
차집합 구하기, 어떤 쿼리가 좋을까?

김정선(jskim@feelanet.com) 필라넷 DB사업부 수석컨설턴트 SQLServer 아카데미/트라이콤 교육센터 강사   Microsoft SQL Server MVP MCT/MCITP/MCDBA

 

 

 

이번에 좀 쉬운 내용으로 정했습니다 ^^

차집합을 구하라

“주문이 없는 제품을 구하라!”,

“거래가 없는 고객을 구하라!”,

“미발송된 주문 상세 내역을 구하라!”

차집합과 유사한 성격의 결과 집합을 도출하는 쿼리를 가끔 작성하게 됩니다. 이 때, 가장 큰 문제 중의 하나는 바로 쿼리 성능 문제입니다. 수행되는 집합 연산의 성격 상 모델 변경 없이 쿼리 만으로 좋은 성능을 만들기란 쉽지가 않습니다. 대량 범위의 데이터에서는 더 큰 문제를 내포하게 됩니다. 그런데, 현장에서 만들어진 쿼리를 보면 LEFT OUTER 조인과 같은 가장 나쁜 쿼리 유형을 선택해서 사용하고 있는 것을 자주 보게 됩니다. SQL Server 관련 Q/A에서도 많이 볼 수 있는 질문 유형 중의 하나였습니다.

언젠가는 한 번 비교를 해 보고 그 결과를 많은 개발자 혹은 DBA들과 공유하자 마음 먹고 있었습니다. 또한 다른 분들의 좋은 솔루션이나 의견도 듣고 싶었습니다. 얼마 전 SQL 전문 Blog에 관련된 글이 올라온 것을 보고 그 기억을 되살리게 되었고, 이제서야 잠깐 짬을 내 기본적인 쿼리 유형들을 샘플로 간단히 만들고 이를 비교한 내용들을 기록합니다. 특히, SQL Server 2005의 Query Optimizer에서 이전 버전과 두드러진 한 가지 차이점을 공통적으로 보이고 있어서 재미 있는 이슈가 될 듯 합니다. 이 또한 예제에 포함시켜 두었습니다.

간단한 예제들이지만, 차집합 성격의 결과 집합 도출 시 어떤 쿼리 유형들이 가능할지 그 선택 범위를 살펴보고 다양한 상황에 따라 적절한 접근 방법으로 활용하면 도움이 될 것이라 판단됩니다. 특히, 막연히 LEFT OUTER 조인만을 사용했던 경험이 있다면 이를 개선할 수 있는 다른 접근 방법들을 살펴볼 수 있을 겁니다.

쿼리 유형별 예제

LEFT OUTER JOIN 방식을 포함해서 쉽게 사용할 수 있는 몇 가지 예제 쿼리들을 다루고자 합니다. 각 유형별로 실행 계획과 I/O(실행 계획 이미지 하단에 포함)를 함께 표시하고 그 특징을 간단히 소개합니다. 설명을 통해 특징과 차이점을 알 수 있습니다. 특히, 몇 가지 쿼리에 대해서는 SQL Server 2000버전과의 큰 차이점을 하나 보여줍니다. 이 또한 정리해 두었습니다. 아래에서 살펴보시기 바랍니다.

1. NOT IN

2. NOT IN + 상관서브쿼리

3. NOT IN + 상관서브쿼리+ TOP 1

4. NOT EXISTS + 상관서브쿼리+ TOP 1

5. 상관 서브쿼리+ TOP 1 + IS NULL

6. OUTER JOIN + IS NULL

7. OUTER APPLY + IS NULL (SQL Server 2005 해당)

8. EXCEPT + (생략됨) 서브쿼리(혹은JOIN) (SQL Server 2005 해당)

참고. A, B 두 집합은 각각 Northwind의 Customers(91건), Orders(830건) 테이블로, 결과 집합은 주문(거래)이 없는 고객 집합을 도출하는 것을 예제로 합니다.

1. NOT IN

가장 간단하고 기본적인 유형입니다. 서브 쿼리의 결과 집합이 중복 값을 허용하지만 SQL Server Query Optimizer가 제공하는 최적화 전략 중 하나인 Constant Folding으로 인해 DISTINCT를 해 주지 않아도 됩니다. 아래 실행 계획은 오른쪽이 잘려 있는 상태입니다. 쿼리와는 달리 계획은 꽤 복잡한 형태를 띠고 있습니다. 부가적인Sort와 Merge 연산자를 동반하며, 내부 Nested Loop 조인으로 인해 실제 I/O는 매우 많은 검색 수(182)와 읽기 수(364)를 보여주고 있으므로, 성능이 좋지 않습니다. Bad!

SQL Server 2000 vs. 2005, 누가 누가 잘하나?

지금까지 살펴본 예제 쿼리들에 대해서 SQL Server 2000과 비교했을 때 2005버전이 크게 달라진 부분이 하나 있습니다. 위 쿼리를 SQL Server 2000(SP3기반)에서 수행 시 가장 큰 차이는 바로 Mere 조인을 사용하지 않는다는 점입니다. 위 Merge조인 예제들이 모두 Nested Loop조인으로 처리됩니다. 그 중 2번) NOT IN + 상관서브쿼리 예제를 아래와 같이 비교해 보겠습니다.

그럼, 이 두 가지를 비교했을 때 과연 어떤 실행 계획이 더 적합한 것일까? 물론 830건 밖에 되지 않는 성능을 논하기엔 매우 작은 테이블과 환경임을 감안하더라도 말입니다. 정답은 없겠지만 적어도 SQL Server 2005의 큰 변화 몇 가지는 확인할 수 있다는 점과 향후 쿼리 튜닝에 있어서 어떤 접근 방법을 우선 시 해야 할지에 대한 중요한 기준을 보여줍니다. 동일한 쿼리에 대해서 2000과 2005는 극명한 성능 차이를 보여줄 수 있다는 또 하나의 사례인 셈입니다.

철저한 I/O 이득을 우선으로 처리하고 있다는 느낌을 주는 2005의 Query Optimizer가 주는 느낌은 왠지 낯설기까지 합니다. 그 변화와 이득은 최대한 활용하되, 파생되는 문제점 또한 해결할 수 있는 다양한 접근 능력이 필요합니다.

결론

최종 판단은 여러분께 맡기겠습니다. 어떤 경우에 어떤 실행 계획이 적합하지 판단하실 수 있다면 그 유형에 맞게 선택해서 사용하시면 됩니다. 더불어 여기에 소개된 것은 기초적인 내용들입니다. 좀 더 복잡한 유형들이 존재합니다. 실제로 여러분들은 어떤 방법, 어떤 유형의 쿼리들을 사용하고 있는지요? 좋은 쿼리가 있으면 소개해 주세요. 많은 분들께 도움이 되실 것이라 믿습니다!

또한 위 쿼리 예제들에 대한 여러분들의 의견도 궁금합니다.

편하게 의견 주세요~~~

 이번 장은 C언어의 마지막 장으로 대표적인 함수들과 파일 분할 방법에 데하여 살펴보고 마치도록 하겠습니다.

 [수학 관련 함수]

: 다음과 같은 함수를 사용하기 위해서는 math.h에 선언되어 있으므로 이를 포함해야 합니다.(#include<math.h>)

 double  fabs(double x);  x의 절대값 반환
 double  ceil(double x);  x보다 작지 않은 최소 크기의 정수 반환
 double  floor(double x);  x보다 크지 않은 최대 크기의 정수 반환
 double  exp(double x);  e^x 값 반환
 double  pow(double x, double y);  x^y 값 반환
 double log(double x);  logx값 반환 (밑은 e)
 double log10(double x);  logx값 반환 (밑은 10)
 double sqrt(double x);  루트x 값 반환

 : 다음과 같은 함수를 사용하기 위해서는 stdlib.h에 선언되어 있으므로 이를 포함해야 합니다.(#include<stdlib.h>)

 int  abs(int x);  x의 절대값 반환
 int  labs(long x);  x의 절대값 반환

cf) 실수형 연산을 하는 수학 함수들은 math.h에 선언
     정수형 연산을 하는 수학 함수들은 stdlib.h에 선언

 int rand(void);
->의사 난수를 반환한다. 그러나 rand함수는 난수를 발생시키지만, 그 생성되는 패턴이 항상 동일하기 때문에 진정한 난수는 아니기 때문에 '의사(가짜)' 난수라고 하는 것 입니다.

 rand함수가 동일한 패턴의 난수를 발생시키는 이유는 난수를 생성하는 기초 정보인 시드(seed) 값이 한상 동일하기 때문입니다. 그래서 난수의 생성 패턴을 유동적으로 바꾸기 위해서는 시드값도 바꿔주어야 합니다. 콩심은데 콩나고 팥심은데 팥나죠. 시앗을 바꿔주어야 나오는 결과물도 달라진다고 생각해보세요~

 void srand(unsigned seed);
->함수를 호출하면서 정수를 전달하면, 전달된 정수로 시드 값이 변경됩니다. 때문에 rand함수의 난수 생성 패턴은 달라집니다.

 [시간과 날짜 관련 함수]

시간 관련 함수를 사용하기 위해서는 헤더파일 time.h를 꼭 포함해야 합니다~

clock_t  clock(void);
성공 시 프로세스 타임 반환, 실패 시 형 반환하여 -1 반환
->프로그램이 실행된 이후로 지나간 시간을 의미하는 '프로세스 타임'을 반환합니다. clock_t 형은 좀 더 알아보면 typedef long clock_t로 정의되어 있습니다. 즉, long형으로 새로 정의된 자료형의 이름입니다. 프로스세 타임은 0부터 시작해서 그 값이 증가하는 형태를 띠고 있습니다. 이 값이 1씩 증가하는 시간의 간격(클럭 틱 clock tic)은 매크로 CLOCKS_PER_SEC를 통해서 확인할 수 있습니다. 1초당 클럭 틱이 발생하는 횟수를 의미합니다! 즉 이 값이 1000이라면 클럭 틱은 0.001초에 한번 씩, 1초에 총 1000회의 클럭틱이 발생 했다는 의미입니다.

ex)
   clock_t start, finish;
   start = clock();
      .......
    finish = clock();
    printf(" 소요된 시간 : %f 초", (double) (finish-start)/CLOCKS_PER_SEC);

 time_t  time(time_t*  tptr);
성공 시 1970년 1월 1일 자정 이후로 경과한 시간을 초 단위로 반환, 실패 시 -1
->time 함수는 우리가 일상적으로 사용하는 형태의 날짜와 시간정보를 출력합니다. '1970년 1월 1일 00시 00분 00초' 이후로 경과한 시간을 표현합니다.

ex)
 time_t current;
 current = time(NULL);

 사실 time 함수는 날짜와 시간 정보를 초 단위로 계산하여 (1970년 1월 1일을 기준으로) 반환하기 때문에 현재의 시간과 날짜를 계산하려면 별도의 연산관정을 거쳐야 합니다. 따라서 time 함수가 반환한 값을 가지고 현재의 날짜와 시간을 계산하기 위한 편리한 함수가 ctime 함수입니다.

 char*  ctime(const time_t* tptr);
성공 시 현재 지역의 시간과 날짜를 문자열의 형태로, 실패 시 NULL 반환

ex)
 time_t current;
 current = time(NULL);
 printf("현재 시간 : %s",ctime(&current));

 ctime 함수의 장점은 현재 사긴을 보기 좋게 출력할 수있지만 시간 정보를 가지고 연산하기에는 부족합니다. 이러한 경우 정수의 형태로 년, 월, 일, 시, 분, 초 정보를 추출하기위한 함수가 localtime 입니다.

 struct  tm*  localtime(const time_t* t);
현재 지역의 시간과 날짜 정보를 담은 tm구조체 변수의 포인터 반환

struct tm
{
    int tm_sec;  //0~59
    int tm_min;  //0~59
    int tm_hour;  //0~23
    int tm_mday;  //1~31
    int tm_mon;  //0~11
    int tm_year;  //1900을 기준
    int tm_wday; //요일은 일~토 까지 0 ~ 6으로 표현
    int tm_yday;  //0~365
    int tm_isdst; //써머 타임
 }

위 와 같이 구조체 tm은 정의되어 있다는거 참고해두세요~

ex)
 time_t  current;
 struct  tm*  sptime;

 current = time(NULL);
 sptime = localtime(&current);
 
 printf("년 :  %d \n", sptime->tm_year + 1900);
 printf("월 :  %d \n", sptime->tm_mon + 1);
 printf("일 :  %d \n", sptime->tm_mday);
 printf("시 :  %d \n", sptime->tm_hour);
 printf("분 :  %d \n", sptime->tm_min);
 printf("초 :  %d \n", sptime->tm_sec);

 자 그럼이제 time 함수를 활용하여 난수 생성을 다시한번 시도해봅시다. srand함수의 호출을 통해서 시드 값을 매번 바꿔줘야 한다고 했죠? 역시나 시드 값도 매번 바꿔줘야 한다는 이야기 입니다. 이때!!! time함수를 이용하면 매우 유용합니다.

 srand( (unsigned) time (NULL));
 printf("%d", rand());

 time 함수는 현재의 시간 정보를 반환합니다. 현재 시간이라는 것은 매번 달라지는 값이기 때문에 strand 함수의 전달 인자로 설정해 놓으면, 프로그램이 실행될 때마다 다른 시드 값을 성정하는 효과를 볼 수 있습니다.



 이번에는 파일의 분할에 대하여 알아보도록 하겠습니다. C언어로 구현된 프로그램의 소스코드는 사실 여러 개의 파일로 구성이 됩니다. 몇 천줄, 몇 만줄이나 되는 실제 프로그램의 소스코드는 한 파일에 구성할 수는 없겠죠? 때문에 여러 개의 파일로 소스코드를 나눕니다. 그렇게되면 프로그램의 코드 분석도 용이해지고 관리 또한 쉬워집니다.

 단순히 코드를 나눠버리면 문제가 발생합니다. 컴파일러는 파일 단위로 컴파일을 진행하기 때문에 만약 변수의 선언 부분과 실제 구현 부분이 서로 다른 파일에 존재 한다면 이는 컴파일 오류를 발생시킵니다.

 extern 이라는 키워드는 외부에 선언 및 정의되었다고 컴파일러에게 알려줍니다. 반대로 static 키워드는 외부 파일에서의 접근을 허용하지 않습니다. 중요한건 static은 전역변수와 지역변수의 쓰임새가 조금 다릅니다. 전역 변수로 사용 되었을때 외부 파일에서의 접근을 허용하지 않는다는 의미를 나타냅니다.

 일반적으로 변수의 선언 및 정의 / 함수의 선언 및 정의 / 실제 구현되는 main 코드로 프로그램을 구성하게됩니다. 이들 파일을 생성하고 프로젝트에 추가하는 방법은 글로만 설명하기는 어려우므로 생략하도록 하겠습니다. 아마 C언어 기본서가 있다면 나와있을거라 생각도 되구요. 혹시라도 나중에 기회가 된다면 추가적으로 설명하도록 하겠습니다~ 어찌하다보니까 급 마무리하게 되네요...;;;ㅎㅎㅎㅎㅎ 

 이상으로 C언어에 대한 내용을 모두 마치도록 하겠습니다~ 다음 부터는 C++, My-Sql, 네트워킹등 다양한 주제를 가지고 포스팅을 해 볼 생각입니다~

 프로그램이라면 기본적으로 갖춰야 할 요소중에 하나가 데이터의 저장입니다. 우리가 일반적으로 접하는 거의 대부분의 프로그램에서는 데이터의 저장이라는 기능이 다양한 형태로 존재하고 있습니다. 때문에 이번 장에서는 파일에 데이터를 저장하고, 저장한 데이터를 참조하는 방법을 알아보도록 하겠습니다.

 우리가 구현한 프로그램과 참조할 데이터가 저장되어 있는 파일 사이에 데이터가 이동할 수 있는 다리를 놓아야 합니다. 컴퓨터 공학에서는 이다리를 '스트림'이라고 하지요

                                             Stream
                 [Program] <-------------------> [Hard Disk]

 파일과의 스트림을 형성하는 방법의 fopen 함수

 FILE*  fopen(const char* filename, const char* mode);
성공 시 해당 파일의 FILE 구조체 포인터, 실패 시 NULL 포인터 반환
-> 스트림을 형성할 때 호출하는 함수입니다.

ex) FILE*  fp = fopen("C:\\prog\\file.txt", "wt");
-> 위 함수의 첫 번째 전달인자는 스트림을 형성할 파일의 경로와 파일의 이름을 알려주고 두 번째 전달인자는 스트림의 종류가 텍스트 데이터를 쓰기 위한 스트림이다라고 알려주는 역할을 합니다. 쓰기모드 즉, 출력스트림이기 때문에 파일에 데이터를 쓸 수 만 있고 읽지는 못합니다. 읽기를 원한다면 "rt"를 사용하면 읽어올 수 있습니다.

 rt : 텍스트 입력용 스트림
 wt : 텍스트 출력용 스트림

 fp라는 파일 구조체 포인터에 스트림을 개방해주었다면 이 포인터 변수를 가지고 활용을 해야겠죠? 실제로 스트림을 형성해서 파일에 데이터를 전송해보고자 한다면 다음과 같은 문장을 사용할 수 있습니다.

 fputc('A', fp);
->fputc 함수를 통해 'A'라는 텍스트를 fp가 가리키는 파일에 저장시킵니다.

cf)참고로 스트림을 형성하는 경우에는 스트림을 형성할 파일이 존재하지 않으면 자동으로 파일이 생성됩니다.

 그렇다면 형성된 스트림의 소멸은 어떻게 해야할까요? fclose 라는 함수가 담당합니다. fopen함수의 반대 기능을 제공합니다.

 int  fclose(FILE* stream);
성공 시 0, 실패시 EOF를 반환
->파일을 닫는다.

 이렇게 fclose 함수의 호출을 통해서 개방되었던 파일을 닫아줘야 하는 이유는 운영체제가  할당한 자원의 반환, 버퍼링 되었던 데이터의 출력에 있습니다. 사용이 끝난 파일은 곧바로 fclose 함수를 호출해는 것이 좋습니다. 사실 파일 스트림을 형성하는 주체는 운영체제입니다. 여기서 운영체제는 스트림의 형성을 위해 시스템의 자원(메모리)을 사용합니다. 때문에 파일을 닫아주지 않으면 할당된 체로 남아있어 자원의 손실로 이어지기때문이죠. 또한 프로그램과 파일의 실제 입출력은 프로그램과 하드디스크 사이의 '버퍼'라는 공간이 존재합니다. 우리가 fputc와 같은 함수의 호출로 데이터를 전송한다고 해서 파일에 바로 저장되는 것이 아니라 일단 버퍼에 저장이 된다음에 운영체제가 정해놓은 버퍼링 방식에 따라 파일이 저장됩니다. fclose 함수의 호출을 통해서 파일을 닫아주면 메모리 버퍼에 저장되어 있던 데이터가 파일로 이동이 되면서 버퍼는 비워지게 됩니다.

 버퍼를 비우고 싶을때 물론 스트림을 종료하지않고말이죠. 그럴때 사용하는 함수가 ffulsh 함수입니다.

 int  fflush(FILE* restrict stream);
성공시 0, 실패 시 EOF 반환
->버퍼를 비워주는 함수

 그러나 fflush함수에서 중요한 것은 입력 스트림을 비우는 요도로 사용할 수 없습니다. 오직 출력 스트림을 비우는 용도로만 사용이 가능하죠^-^

 FILE* fp = fopen("C:\\prog\\test.txt", "rt");
 fflush(fp); //이것은 잘못된 코드

 FILE* fp = fopen("C:\\prog\\test.txt", "wt");
 fflush(fp); //올바른 코드

 출력 버퍼가 비워진다는 것은 출력 버퍼에 저장된 데이터가 느야 소멸되는 것이 아니라, 출력 버퍼에 저장된 데이터가 목적지에 전송이 되어 비워지는 것을 의미합니다.

 이번에는 스트림의 모드에 대하여 살펴보겠습니다. fopen의 두 번째 인자에 전달되는 정보입니다.

 r  :  읽기                                          r+  :  읽기/쓰기
w  :  쓰기                                         w+  :  읽기/쓰기
a  :  파일의 끝에 덧붙여 쓰기               a+  :  읽기/덧붙여 쓰기

 r, r+ 는 파일이 없다면 에러를 발생하지만 나머지는 파일이 없다면 파일을 생성해버립니다. 쉽게 정리하자면 + 는 읽기, 쓰기가 모두 가능한 스트림의 형성을 의미하고 a는 덧붙여 쓰기가 가능한 스트림을 형성합니다.

 근대 우리가 지금까지 사용한 fopen함수를 보면 wt 나 rt를 사용했죠? t 는 무슨 의미일까요? 텍스트 모드라는 뜻 입니다. 바이너리 모드에서는 b를 사용하죠.

  텍스트 모드 : rt, wt, at, r+t, w+t, a+t
  바이너리 모드 : rb, wb, ab, r+b, w+b, a+b

 바이너리 모드에 대해서는 따로 설명하지 않겠습니다. 텍스트모드가 일반적이고 자주사용하니까 굳이 설명안드려도 될 것 같습니다~

 일단 파일 입출력에서 사용하는 함수를 정리해보도록 하겠습니다.

[문자]
 in fgetc(FILE* stream);     //입력
 int getc(FILE* stream);     //입력
 char* fputc(int c, FILE* stream);    //출력
 char* putc(int c, FILE* stream);     //출력

[문자열]
 char* fgets(char* s, int n, FILE* stream);    //입력
 int fputs(const char* s, FILE* stream);     //출력

ex) fgets (buf, 100, fp); //buf는 배열이름, fp는 FILE구조체 포인터
->fp가 가리키는 파일로부터 최대 길이가 100인 문자열을 읽어서 배열 buf에 저장한다.

ex) fputs(buf, fp);
->buf에 저장된 문자열을 fp가 가리키는 파일에 저장한다.

 파일의 끝을 확인 : feof 함수
 int feof(FILE* stream); 
파일의 끝에 도달한 경우 0이 아닌 값 반환
->포인터가 가리키는 파일이 끝에 도달했는지 판단


 서식에 따른 데이터 출력 : fprintf 함수
char name[10] = "boxbop";
char sex = 'M';
int age = 10;
fprintf(fp, "%s %c %d", name, sex, age);    //fp는 FILE 구조체 포인터
->입출력의 대상은 콘솔이 아닌 파일입니다. 이렇게 만들어진 문자열 (boxbop M 10)은 fp가 가리키는 파일에 저장이 됩니다.

 서식에 따른 데이터 입력 : fscanf 함수
char name[10];
char sex;
int age;
fscanf(fp, "%s %c %d", name, &sex, &age);    //fp는 FILE 구조체 포인터
->fp로 부터 파일을 읽어들입니다. 실패하면 EOF를 반환합니다. 기존에 존재하는 파일로부터 데이터를 읽어들이는 겁니다. 사용자로부터 입력받는게 아니에요~ 주의하세요

 이번장은 여기까지 하도록 하겠습니다~ 다음 장이 마지막 장이 되겠네요~
다음 장으로 넘어가도록 하겠습니다^^

 여러가지 데이터를 하나로 묶기 위해 구조체가 등장하였습니다. 예를 들면 X 좌표와 Y좌표, 가로값과 세로값 그리고 높이값, 이름과 주소, 전화번호, 나이등 연관있는 데이터들을 하나로 묶어서 관리하면 참 편하겠죠~? 소프트웨어 개발 과정에서는 표현하는 데이터들은 그룹으로 관리를 하게됩니다.

 struct MAN
{
    char name[10];
    int age;
 };

 MAN은 구조체의 이름이고 중괄호 안에있는 문장들은 구조체 MAN의 맴버입니다. 이러한 정의가 이뤄지고 난 다음부터 MAN은 변수의 선언에 사용되는 자료형의 이름으로 인식이 됩니다.

 struct MAN boxbop;

 cf) typedef struct MAN MAN; 이라고 추가로 작성하면
      struct MAN boxbop 대신 단순히 MAN boxbop으로 사용할 수 있다.

 이라고 한다면 자료형이 MAN인 새로운 변수 boxbop이 생성됩니다. boxbop 내부에는 name과 age라는 맴버가 존재하겠죠? 그렇다면 이 내부에 있는 맴버변수에 어떻게 접근을 할까요?  .(dot) 연산자를 사용합니다.

 boxbop.age = 10;
 strcpy(boxbop.name, "boxbop");

 변수명.맴버변수 의 형태로 접근을 하게됩니다^-^
그렇다면 이제 포인터의 개념을 조금 적용하여 살펴보도록 하겠습니다.

 MAN boxbop;
 MAN* boxbopPtr;

 boxbopPtr = &boxbop;

 이번엔 포인터 변수도 등장을 했습니다. 포인터 변수는 boxbop의 주소값을 가지고 있군요~ 그렇다면 포인터 변수를 사용하여 boxbop의 맴버변수에 접근하는 방법은 어떻게 해야될까요..? '->' 연산자를 사용합니다.

 구조체 이름에서 접근하는 방법은

boxbop.name
boxbop.age
boxbop.number

 이렇게 '.(dot)' 연산자를 사용합니다.
반면에 포인터를 이용한 구조체 맴버의 접근은

boxbopPtr->name
boxbopPtr->age
boxbopPtr->number

 위와 같이 나타냅니다. 아래와 같은 방법도 옳은 접근방법입니다.

(*boxbopPtr).name
(*boxbopPtr).age
(*boxbopPtr).number

 왜냐하면 (*boxbopPtr)는 boxbop와 동일하기 때문입니다~

 그렇다면 구조체 변수의 선언과 초기화는 어떻게 이루어질까요? 다른 자료형처럼 선언과 동시에 초기화가 가능합니다. 마치 배열의 초기화 방법과 유사합니다. 초기화할 값을 중괄호 안에 쉼표로 구분 지어 표시하면 됩니다.

 struct __person
{
   char name[10];
   char ID[10];
   unsigned int age;
 };
typedef struct __person person;

int mian(void)
{
   person andrew = {"andrew", "anw1234", 10};
 }

 위 예제와 같이 초기화가 이루어 집니다. 간단하죠?

 사실 구조체의 정의 부분에서 typedef 연산을 사용하는 등 조금은 뭔가 불필요한 느낌이 들고 있습니다. 뭔가 좀 더 간단하게 나타낼 방법은 없을까요? 다음 두 예제는 동일합니다.

  struct __person
{
   char name[10];
   char ID[10];
   unsigned int age;
 };
typedef struct __person person;

==>
        
 typedef struct __person
{
   char name[10];
   char ID[10];
   unsigned int age;
 }person;

 구조체는 struct라는 키워드를 사용해서 정의하는 반면, 공용체는 union이라는 키워드를 사용해서 정의합니다. 외관상 차이점은 그게 다입니다.

  typedef union __number
{
   char str;
   int number;
   double dnumber;
 }num;

 그러나 각각의 변수가 메모리 공간에 할당되는 방식과 접근방식에는 많은 차이가 있습니다. 구조체는 각각의 맴버 변수에 개별적인 공간이 할당되지만 공용체 변수는 맴버 중에서 크기가 가장 큰 맴버의 바이트만큼만 메로리 공간이 할당됩니다. 위에서는 double형이 가장 크므로 8바이트만 할당이 되겠죠~?

 공용체의 유용함은 다양한 접근방식을 제공하는데 있습니다. 8바이트를 할당받지만 8바이트를 char형, int형, double형으로 모두 사용이 가능합니다. 

 사용자로부터 int형 데이터를 하나 입력받아서 입력 받은 정수의 상위, 하위 2바이트씩 나누어 출력하고, 최상위 1바이트와 최하위 1바이트 저장된 값을 출력하는 프로그램을 작성해야된다고 한다면 이럴때 공용체가 아주 유용하게 사용됩니다. 뭔가 자잘하게 나눈다는 느낌 안드나요~?ㅋㅋㅋ 다음 예제를 보시고 대충 그까이꺼 이해해보세요

 typedef struct __updownshort
{
   unsigned short up;
   unsigned short lower;
 }udshort;

 typedef union __number
{
   int i;
   char c[4];
   udshort s;
 }number;

int main (void)
{
   number buf;
   buf.i=13451345;

   buf.s.up;
   buf.s.down;
   buf.c[0];
   buf.c[3];
 
   return 0;
 }

 따로 설명하지는 않겠습니다. 진하게 표시되어 있는 부분이 중요하다는 뜻 입니다^-^ 열거형도 구조체나 공용체와 마찬가지로 자료형을 정의하는 방법입니다.

 enum value
 {
     A = 1, B = 2, C = 3, D = 4
 };

==>

typedef enum __value
{
    A = 1, B = 2, C = 3, D = 4
}value;

 A를 상수 1로 정의합니다. 마찬가지로 B, C, D는 2, 3, 4로 정의되구요~ 열거형은 솔직히 별거 없네요....ㅋㅋㅋ 즉 A, B, C, D라는 이름의 상수를 각각 1, 2, 3, 4로 정의하고, 이 값들을 value형 변수가 저장할 수 있는 값들로 제한합니다.

 구조체, 공용체, 열거형 모두 정의하면서 동시에 변수를 선언하는 것이 가능합니다. 

 struct point
{
   int x;
   int y;
 }p1, p2;   -> 변수 p1, p2가 생성

 enum number
{ 
   A, B, C
 }num; -> 변수 num이 생성

 그리고 자료형의 이름도 생략할 수 있습니다. 사실상 열거형은 자료형의 이름을 자주 생략해서 사용하곤 합니다^-^

 struct
{
   int x;
   int y;
 }p1, p2;

 enum
{ 
   A, B, C
 }num; 

 p1.x =1; 이나 num = A와 같은 코드를 작성해 볼 수 있겠죠? 오늘은 여기까지 하도록 하겠습니다. C언어가 거의 마무리 되가네요~ 앞으로 1~2장 정도만 복습하면 끝날 듯 싶습니다~~!!!! 으 지겨워 그 다음엔 C++에 대해서 복습할껀대요 다른 과목들도 같이 복습을 병행해 나갈거라 아주 간단간단하게 설명할 것 같습니다ㅠ 이만 마치도록 하겠습니다(--)(__)(--)!!!
   

 처음에 설명했던 부분 기억나시나요? 실행파일이 컴파일과 링크의 과정을 거쳐서 만들어지는 것으로 설명했습니다. 실제로는 컴파일 이전에 '전처리'라는 과정을 거치게 됩니다. 즉, 소스파일은 선행처리기에 의해 전처리 과정을 한번 거친 후에 컴파일 거치게 됩니다. 사실 선행처리기가 하는 일은 아주 간단합니다. 우리가 작성해 놓은 선행처리 명령문대로 소스코드의 일부를 수정하는 것이 전부입니다.

 지시자   매크로    매크로몸체

 위와 같이 선행처리 명령문은 기본적으로 세 부분으로 나뉩니다. 아래 문장을 예로들어 설명하겠습니다.

 #define A 10

지시자(#define)는 선행처리기에 이어서 등장하는 매크로를 마지막에 등장하는 매크로 몸체로 치환하라는 명령을 내립니다. 즉, A 를 10으로 치환하라는 의미입니다.
 
 ex) #define NAME "boxbop"
      #define AGE 100

 또한 define 매크로는 다음과 같은 형태로도 사용이 가능합니다.

 #define   FUNCTION(X)   X*X

 즉, FUNCTION(123) 이라는 문장이 나올때 123*123 의 형태로 치환하라는 의미입니다. 함수와도 비슷하죠~? 참고로 매크로를 정의할 때는 먼저 정의되어 있는 매크로도 사용이 가능합니다^-^

 그렇다면 매크로 함수의 장점에는 무엇이 있을까요~?

 1. 매크로 함수는 일반 함수에 비해 실행속도 빠르다
 2. 자료형에 따라서 별도로 함수를 정의하지 않아도 된다.

 알다시피 함수가 호출되면 호출된 함수를 위한 스택 메모리의 할당, 실행위치의 이동과 매개변수로의 인자 전달, return문에 의한 값의 반환등 복잡한 절차를 필요로 합니다. 그렇지만 매크로 함수는 이러한 과정이 불필요하다는 것 입니다^^ 하지만 정의하기가 까다롭기 때문에 무분별하게 사용해서는 안됩니다. 함수의 크기, 길이가 짧거나 호출이 되는 빈도수가 높은 함수를 매크로로 정의하면 좋습니다~

 <조건부 컴파일을 위한 매크로>

 매크로 지시자 중에는 특정 조건에 따라 소스코드의 일부를 삽입하거나 삭제할 수 있도록 디자인 된 지시가자 존재합니다.

 [#if ... #endif]

조건부 코드 삽입을 위한 지시자 입니다. #if문 뒤에는 반드시 #endif문이 존재해야 합니다. 예제를 보시면 이해가 빠르실 겁니당~

 #define CODE_A 1
 #define CODE_B 0

int main(void)
{
   int number1, number2;
   number1 = 10;
   number2 = 20;

  #if CODE_A
     number1 += number2;
  #endif

  #if CODE_B
    number1 -= number2;
  #endif

    return 0;
  }

CODE_A의 값이 참이라면 #if ~ #endif 문까지가 코드에 삽입되어 실행되고 그렇지 않다면 실행되지 않습니다. 즉 위의 예제에서는 CODE_A가 1이기 때문에 두개의 피연산자의 덧셈이 실행되고 CODE_B는 0이기 때문에 뺄셈코드는 삭제되어 무시되겠죠~?

 [#ifdef ... #endif]

 위의 지시자도 #if ... #endif 지시자와 비슷합니다. #if는 매크로가 참인지 거짓인지를 기준으로하여 작동하지만 #ifdef는 매크로가 정의되어 있는지 아닌지를 기준으로 동작합니다. 

 #define CODE_A 1
 //#define CODE_B 0  (주석처리)

int main(void)
{
   int number1, number2;
   number1 = 10;
   number2 = 20;

  #ifdef CODE_A
     number1 += number2;
  #endif

  #ifdef CODE_B
    number1 -= number2;
  #endif

    return 0;
  }

CODE_B를 주석처리했기 때문에 정의되어있지 않다고 판단하여 두 피연산자의 뺄셈은 생략이 되겠죠~? 사실상 코드에서 그냥 소멸되어 버립니다. 반면 CODE_A는 정의되어있기 때문에 덧셈코드는 정상적으로 작동하구요~

 [#ifndef ... #endif]

 위의 매크로는 정의되어있지 않!!!았다면 이라는 뜻입니다. #ifdef와는 반대의 개념이죠? 따로 설명하지는 않겠습니다~

 [#else의 삽입]

#if, #ifdef, #ifndef에서 모두 #else를 사용할 수 있습니다.

 #if CODE_A == 2
  .....
 #else
  .....
 #endif

 이런식으로 기존의 if문과 동일하게 사용할 수 있습니다. 그리고 if문에는 esle if문이 여러개 존재할 수 있죠? else if 역할을 하는 매크로도 존재합니다.

 [#elif]

 위 매크로가 기존의 else if 역할을 합니다. 당연히 여러번 사용할 수 있구요~

 #if CODE_A == 1
   .....
 #elif CODE_A == 0
   .....
 #elif CODE_B == 1
   .....
 #else
   .....
 #endif

그러나 #if와 #ifdef에는 한계가 존재합니다. 예를들어 매크로 NUMBER의 값이 5이고, 매크로 CODE가 정의되어 있으며, 매크로 COUNT의 값이 1이 아닌 경우에 어떤 문자열을 출력한다고 가정해봅시다~

 #define NUMBER 5
 #define CODE
 #define COUNT 2

int main(void)
{
#ifdef CODE
   #if COUNT != 1 && NUMBER == 5
          .....
   #endif
#endif

   return 0;
}

위와 같이 복잡하게 됩니다. 그렇다면 매크로의 참, 거짓과 정의의 유무를 한줄로 표현할 수 있는 것이 defined 연산자 입니다.

 [#if와 함께 사용할 수 있는 defined 연산자]

#if defined(CODE)
  .......
#endif

 defined 연산자는 괄호안의 매크로가 존재하는지 존재하지 않는지 판단합니다. 때문에 좀 전에 복잡했던 예제를 다음과 같이 표현할 수 있습니다.

#if defined(CODE) && COUNT != 1 && NUMBER ==5
  .....
#endif

 보기에도 좀 더 간단해 졌죠~? defined처럼 유용한 매크로 연산자가 존재합니다.

 [매크로 # 연산자]

#define   STR(ABC)   #ABC

 ->매개변수 ABC에 전달되는 인자를 문자열 "ABC"로 치환한다

 매크로 ## 연산자

 #define   MIXNUMBER(A, B, C)   A ## B ## C

 ->매개변수 A, B, C에 전잘되는 인자를 ABC 하나로 만들어준다

 만약 12, 23, 22를 전달하면 122322라는 새로운 수가 만들어집니다.
단순히 A ## B ## C를 ABC나 A B C로 사용해버리면 의도하지 않은 결과를 초례합니다~

 [그외 정의되어 있는 매크로들]

 __FILE__  :  현재 소스코드의 파일명을 나타내는 문자열
 __TIME__ :  선행처리 시작을 "시:분:초" 의 형태로 나타내는 문자열
 __DATE__ : 선행처리 날짜를 "월:일:년" 의 형태로 나타내는 문자열
 __LINE__ : 현재 소스코드의 행 번호를 나타내는 상수

 ex)  printf("현재 행 : %d ", __LINE__);
        printf("파일 명 : %s ", __FILE__);

 [행 번호와 파일 이름을 지정하는 #line]

 단순히 행의 기준을 사용자가 원하는 기준으로 정하고, 전체경로를 포함한 파일의 이름이 아닌, 그냥 파일의 이름만 출력을 할 수 있도록 합니다.

 ex) #line  0
        ->현재 행 번호를 0으로 설정한다.
       #line  1  "test.c"
        ->현재 행 번호를 1으로 설정하고, 파일이름을 test.c로 설정한다.

[문자열 함수]

1.
int puts(const char* s);
성공시 0이아닌 값을, 실패 시 EOF 반환
ex) puts("hello boxbop!");

2.
int putchar(int c);
성공 시 출력된 문자 정보를, 실패 시 EOF 반환
ex) putchar('A');

cf)EOF는 End Of File의 약자로 상수 값은 -1입니다. 파일의 끝을 표시하기 위해 정의된 상수입니다.

3.
char* gets(char* s);
성공 시 매개변수로 전달된 값을, 실패 시 NULL 포인터 반환
ex) char str[10];
      gets(str);
이함수를 호출하면서 메모리의 주소 값을 인자로 전달하면, 키보드로부터 입력되는 문자열이, 전달된 주소의 메모리에 저장됩니다.

4.
int getchar(void);
성공 시 입력된 문자를, 실패시 EOF 반환
ex) int ch;
      ch = getchar();

[문자열 컨트롤 함수]

1.
size_t strlen(const char* s);
문자열의 길이 정보 반환

2.
char* strcpy(char* dest, const char* src);
char* strncpy(char* dest, const char* src, size_t n);
->문자열을 배열에 복사합니다.
ex) char src[10]="hi boxbop";
      char dest[10];
      strcpy(dest, src);

3.
char* strcat(char* dest, const char* src);
char* strncat(char* dest, const char* src, size_t n);
첫 번째 매개변수에 전달된 주소 값 반환
->문자열 뒤에 문자열을 복사

4.
int strcmp(const char* s1, const char* s2);
int strncmp(const char* s1, const char* s2, size_t n);
두 문자열이 동일하면 0, 동일하지 않으면 0이 아닌 값 반환
->두 문자열이 서로 동일한지 비교

[문자열 정보 함수]

1.
char* strchr(const char* s, int c);
char* strrchr(const char* s, int c);
문자를 찾을 시 해당 문자의 포인터를, 못 찾을 시 NULL 포인터 반환
->문자열에서 특정 문자가 등장하는 위치를 찾는다.
strchr은 처음 등장하는 위치를, strrchr은 마지막 위치를 찾는다.

2.
char* strstr(const char* src, const char* sub);
문자열을 찾을 시 해당 문자열의 시작 주소를, 못 찾을시 NULL 포인터를 반환
->문자열 안에 특정 문자열이 존재하는지 확인

3.
char* strtok(char* str, const char* set);
다음 번 토큰의 주소 값을 반환하며, 반환할 토큰이 없으면 NULL포인터 반환
->기준을 기준으로 문자열을 나눌경우 사용
ex) char str[] = "aaa-bbb";
      char* tok;
      tok = strtok(str,"-_!"); -, _, ! 을 기준으로 사용

      while(tok != NULL)
  {
     printf("토큰 : %s ", tok);
     tok=strtok(NULL, "-_!");
   }

3번째 줄을 보시면 문자열 str은 기호 -, _, !을 기준으로 토큰이 나뉩니다. 그리고 이렇게 함수가 호출이 되고 나면, 첫 번째 토큰의 주소 값이 반환됩니다. while문 내에 있는 strtok함수를 보면 두 번째 토큰의 정보를 얻기위해 다음과 같은 형태로 함수를 호출하고 있습니다. 첫 번째인자로는 NULL을 전달하여 3번째 줄에서 전달한 str의 정보를 함수 내에서 유지합니다. 두 번째 인자인 기준은 동일합니다.

[문자열 변환 함수]

double atof (const char* str);
int atoi (const char* str);
long atol (const char* str);
long long atoll (const char* str);
->각각 double, int long, long long형 데이터로 변환합니다.
ex) int num;
      num = atoi("123");


[sptrinf & sscanf]

1.
int sprintf(char* restrict s, const char* restrict format,...);
성공 시 저장된 문자열의 길이, 실패 시 EOF 반환
->문자열 배열에 저장한다.

ex)
int num1 = 1;
char str[] = "hello";
float num2 = 1.23;

char strBuf[20];
sptrinf(strBuf,"%d %s %f", num1, str, num2);
puts(strBuf);

2.
int sscanf(char* restrict s, const char* restrict format,...);
성공 시 읽어 들인 데이터의 개수, 실패 시 EOF 반환
->문자열 배열로부터 데이터를 추출한다.

ex)
int num1;
char str[10];
float num2;

sscanf("hello 1 1.23", "%s %d %f", str, &num1, &num2);

 포인터와 관련이 있는 내용들을 설명하겠습니다. 여기서 한장자라고 하면 제한을 걸때 사용되는 키워드라고 할 수 있습니다.

 포인터의 const 선언
const는 변수를 상수화 하는 용도로 사용이 됩니다. 이번에는 포인터에 적용해보도록 하겠습니다.

 int number =10;
 int* ptr = &number;

 여기서 const가 들어갈 수 있는 자리는 2군데 있습니다.

const int* const ptr = &num;

포인터 선언 앞에 사용될 수 있고, 포인터 변수의 이름 앞에 삽입될 수도 있습니다. 두 군데 모두 사용할 수도 있습니다.

 int number = 10;
 const int* ptr = &number;

이렇게 사용이 된다면 포인터 ptr은 가리키는 대상에 대한 값의 변경이 허용되지 않습니다. 예를들어 *ptr=20; 이런 문장이 컴파일 에러를 발생키기죠. 즉, 포인터를 이용한 값의 변경을 허용하지 않겠다는 뜻이 됩니다.

 int number = 10;
 int* const ptr = &number;

 이번에는 포인터 변수의 이름 앞에 사용이 되었습니다. 이 선언은 포인터 변수 ptr을 상수화 시킨다는 의미입니다. 즉, 포인터 변수 ptr에 저장된 값의 변경이 불가능 하다는 뜻이 됩니다. 때문에 이러한 선언을 하게되면 포인터 ptr은 끝까지 변수 num만 가리키게 됩니다.

 결론적으로 첫 번째 선언은 ptr이 가리키는 변수에 저장된 값을 변경할 수 없고, 두 번재 선언은 ptr 자체가 number의 주소값으로 상수화 되어 변경할 수 없다는 의미입니다.

 volatile 과 restrict 키워드는 간단하게 넘어가겠습니다.
volatile 키워드는 변수의 선언 앞에 사용됩니다. 해당 변수와 관련해서는 코드 최적화를 수행하면 안된다는 의미입니다. restrict은 그 반대로 최적화를 우도하는 선언입니다. 포인터 선언에서의 restrict 키워드는 이 포인터가 가리키는 메모리 공간은 이 포인터만으로 접근이 가능하다는 것을 의미합니다. 때문에 해당 포인터가 가리키는 메모리 영역의 접근 연산은 캐쉬 메모리를 기반으로 최고의 성능을 낼 수 있도록 코드가 최적화됩니다.

 다음은 메모리 컨트롤 관련 함수입니다.

 memmove : 어떠한 경우에도 사용할 수 있는 메모리 복사 함수
cf) void* memmove(void* dest, const void* src, sizt_t len);
->매개변수 src로 전달된 값을 시작주소로 하여 len바이트를 읽어 들여서, 매개변수 dest로 전달된 주소에 복사를한다.

 memcpy : 제한된 상황에서의 메모리 복사
cf) void* memcpy(void* restrict dest, const void* restrict src, size_t len);
->memmove와 기능상 차이는 없다. 그러나 dest와 src가 restrict으로 선언되었다. 따라서 함수가 호출되면서 dest와 src로 전달된 주소 값의 메모리는 각각 dest와 src로만 접근이 가능해야 한다.(원본대상과 복사본이 겹치는 경우 사용할 수 없다)