?????

21일차

---------------------

break, contine

---------------------

- break

반복문에서 빠져나가는 제어문

- continue

반복문을 계속 진행하는 제어문

ex) 예제 소스

#include <stdio.h>

int main()
{
  int iNum;
  
  // 30에서 50사이 값 입력
  while(1)
  {
    printf("30에서 50사이 값을 입력하세요 : ");
    scanf("%d", &iNum);

    if(30 > iNum)
    {
      continue;
    }

    if(50 < iNum)
    {
      continue;
    }

    break;
  }

  printf("입력하신 값은 %d입니다. \n", iNum);

  return 0;
}

예제 소스를 보면 continue가 실행되면

그 밑에 명령은 실행하지 않고 바로 반복문 맨 위로 간다.

break를 만나면 그 밑에 명령도 실행하지 않고

반복문을 빠져나간다.

for ( ; ; )
{
  if( )
  {
    break;
    ++iNum;  //  절대 실행되지 못 할 코드
  }
  if( )
  {
    continue;
    ++iNum;  //  절대 실행되지 못 할 코드
  }
}

---------------

switch

---------------

- if문과 유사하다

switch ( 정수형 변수 )

{

case 상수형 정수:

break;

case 상수형 정수:

break;

default:

break;

}

사용법은 위와 같다. 참고로 default에는 break;를 안 넣어 줘도 되지만

왠만하면 보기 좋게? 넣으면 좋겠다.

ex) 예제 소스

#include <stdio.h>

int main()
{
  int iNum;

  printf("숫자를 입력하세요 : ");
  scanf("%d", &iNum);

  switch(iNum)
  {
    case 1:
      printf("1을 입력하셨습니다. \n");
      break;
    case 2:
      printf("2를 입력하셨습니다. \n");
      break;
    case 3:
      printf("3을 입력하셨습니다. \n");
      break;
    case 4:
      printf("4를 입력하셨습니다. \n");
      break;
    case 5:
      printf("5를 입력하셨습니다. \n");
      break;
    default:
      printf("왜 %d를.... \n", iNum);
      break;
  }

  return 0;
}

if문과 비슷하다.

허나 다른점이 있는데 아래 소스를 보자.

#include <stdio.h>

int main()
{
  int iNum = 0;  //초기화를 꼭 해줘야 합니다.

  printf("문자를 입력하세요 : ");
  scanf("%c", &iNum);

  switch(iNum)
  {
    case 'A':
    case 'a':
      printf("A?!! \n");
      break;
    case 'B':
    case 'b':
      printf("B?!! \n");
      break;
    case 'C':
    case 'c':
      printf("C?!! \n");
      break;
    case 'D':
    case 'd':
    case 'E':
    case 'e':
    case 'F':
    case 'f':
      printf("DEF중에 하나 \n");
      break;
    default:
      printf("잘했어요! \n");
      break;
  }

  return 0;
}

위에서 보면 A를 입력시 그냥 case 'a'로 넘어가서

A, a 중 아무거나 입력하면 같은 결과가 나온다!!

또 이건 여담으로 int iNum을 0으로 초기화 해주지 않으면

scanf("%c", &iNum); 에서 쓰래기값과 함께 겹쳐버린다는 것!!

예를 들어 iNum에 처음 쓰래기값으로 20122359라는 정보가 저장 되어있었다면

scanf("%c", &iNum); 로 문자하나 크기 (1byte) 만 입력 받기 때문에 A (65) 입력시

20122365 로 나오기 때문에 초기화를 잊지 말아야 한다.

- if 문과 switch 문 비교

#include <stdio.h>

int main()
{
  int iScore;

  printf("점수를 0~100 중 입력하세요\n : ");
  scanf("%d", &iScore);

  switch(iScore/10)
  {
    case 10:
    case 9:
      printf("점수 : A \n");
      break;
    case 8:
      printf("점수 : B \n");
      break;
    case 7:
      printf("점수 : C \n");
      break;
    case 6:
      printf("점수 : D \n");
      break;
    default:
      printf("점수 : F \n");
      break;
    
  }
/*
  if(90 <= iScore)
  {
    printf("점수 : A \n");
  }
  else if(80 <= iScore)
  {
    printf("점수 : B \n");
  }
  else if(70 <= iScore)
  {
    printf("점수 : C \n");
  }
  else if(60 <= iScore)
  {
    printf("점수 : D \n");
  }
  else
  {
    printf("점수 : F \n");
  }
*/
  
  return 0;
}

같은 결과가 나온다

어떤 구간에 대한 ( 3 < x < 100 ) 것은 if 문이 좋고

정확한 몇개의 값에 대한 ( 3, 4, 5, 6 )  것은 switch 문이 유리하다.

------------

debug

------------

컴파일에서 잡지 못하는 오류를 잡을때 쓴다.

 break point를 걸면 건 곳에서 프로그램이 멈춘다.

 그리고 디버깅을 시작.

 한 줄씩 실행이 가능하고 프로시저 단위로도 실행 가능하다.

 보시다 시피 변수의 값이 변하는 것을 추척할 수 있다.

그리고 조사식1이 선택되어 있는데 지역을 보는 것을 추천한다.

조사식은 내가 보고 싶은 것만 추척하여 볼 수 있다.

20일차

---------------

for 문

---------------

- 반복문이다.

for ( 초기식 ; 조건 ; 반복식 )

{

명령

}

이런 형태이고 재미있는 것은 초기식과 반복식에

다중으로, 생략으로 선언이 가능하다.

ex) 예제 소스

#include <stdio.h>

int main()
{
  int iNum1;
  int iNum2;
  int iNum3;

//  - 5  명령이 한 줄일 경우 중괄호 생략 가능
  for(iNum1 = 0, iNum2 = 0 ; 5 > iNum1 ; iNum1 = iNum1 + 1, iNum2 = iNum2 + 2)
    printf("iNum1 = %d\tiNum2 = %d \n", iNum1, iNum2);

//  - 4
  iNum1 = 0;
  iNum2 = 0;

  while( 5 > iNum1 )
  {
    printf("iNum1 = %d\tiNum2 = %d \n", iNum1, iNum2);
    iNum1 = iNum1 + 1;
    iNum2 = iNum2 + 2;
  }


//  - 3
  iNum1 = 0;
  iNum2 = 0;

  for( ; 5 > iNum1 ; )
  {
    printf("iNum1 = %d\tiNum2 = %d \n", iNum1, iNum2);
    iNum1 = iNum1 + 1;
    iNum2 = iNum2 + 2;
  }

//  - 2
  iNum2 = 0;

  for(iNum1 = 0 ; 5 > iNum1 ; iNum1 = iNum1 + 1)
  {
    printf("iNum1 = %d\tiNum2 = %d \n", iNum1, iNum2);
    iNum2 = iNum2 + 2;
  }

//  - 1
  for(iNum1 = 0, iNum2 = 0 ; 5 > iNum1 ; iNum1 = iNum1 + 1, iNum2 = iNum2 + 2)
  {
    printf("iNum1 = %d\tiNum2 = %d \n", iNum1, iNum2);
  }

  return 0;
}

1, 2, 3, 4, 5번은 다 같은 식이다.

int main()
{
  unsigned int uiCnt = 0;

//  while(1)
  for( ; ; ) // 조건을 생략하면 무한루프가 된다
  {
    printf("%u \n", uiCnt);  // %u = unsigned int
    ++uiCnt;
  }

  return 0;
}

또 while문과 같이 프로그래머의 의도하에 위와 같이 무한루프도 가능하다.

--------------------

if문 (흐름의 분기)

--------------------

- 흐름을 분기하는 제어문

if ( 조건 )

{  A  }

이런 형태이고 조건이 참이면 괄호의 A를 실행하고

거짓이면 그냥 넘어간다.

그리고 밑에 한 명령만 할 경우 괄호를 생략 가능한데

가독성에 도움을 주기 위해 왠만하면 붙여주자.

ex)예제 소스

#include <stdio.h>

int main()
{
  int iOpt;
  double dNum1;
  double dNum2;

  printf("1.덧셈 2.뺄셈 3.곱셈 4.나눗셈 \n");
  printf(" : ");
  scanf("%d", &iOpt);

  printf("연산하실 두 숫자 입력 \n : ");
  scanf("%lf %lf", &dNum1, &dNum2);

  if(1 == iOpt)
    printf("%.3lf + %.3lf = %.3lf \n", dNum1, dNum2, dNum1 + dNum2);
  if(2 == iOpt)
    printf("%.3lf + %.3lf = %.3lf \n", dNum1, dNum2, dNum1 - dNum2);
  if(3 == iOpt)
    printf("%.3lf + %.3lf = %.3lf \n", dNum1, dNum2, dNum1 * dNum2);
  if(4 == iOpt)
    printf("%.3lf + %.3lf = %.3lf \n", dNum1, dNum2, dNum1 / dNum2);

  return 0;
}

- if ( 조건)

{  A  }

else

{  B  }

이것은 앞서 배웠던 if문에 else가 붙었는데

조건이 참일 경우 A ,

조건이 거짓일 경우 B 를 실행한다.

ex) 예제 소스

#include <stdio.h>

int main()
{
  int iNum;

  printf("숫자를 입력하세요 : ");
  scanf("%d", &iNum);

  if(0 < iNum)
  {
    printf("%d 는 0보다 큽니다 \n", iNum);
  }
  else
  {
    printf("%d 는 0보다 작습니다 \n", iNum);
  }

  return 0;
}

- if ( 조건 )

{  A  }

else if ( 조건 )

{  B  }

else

{  C  }

이건 조건이 여러개일 경우 위와 같이 갔다 붙이면 된다.

ex) 예제 소스

#include <stdio.h>

int main()
{
  int iOpt;
  double dNum1;
  double dNum2;

  printf("1.덧셈 2.뺄셈 3.곱셈 4.나눗셈 \n : ");
  scanf("%d", &iOpt);

  printf("두 개의 실수 입력 : ");
  scanf("%lf %lf", &dNum1, &dNum2);

  if(1 == iOpt)
  {
    printf("%.3lf + %.3lf = %.3lf \n", dNum1, dNum2, dNum1 + dNum2);
  }
  else if(2 == iOpt)
  {
    printf("%.3lf - %.3lf = %.3lf \n", dNum1, dNum2, dNum1 - dNum2);
  }
  else if(3 == iOpt)
  {
    printf("%.3lf * %.3lf = %.3lf \n", dNum1, dNum2, dNum1 * dNum2);
  }
  else if(4 == iOpt)
  {
    printf("%.3lf / %.3lf = %.3lf \n", dNum1, dNum2, dNum1 / dNum2);
  }
  else
  {
    printf("Error!! \n");
  }

  return 0;
}

이것 같은 경우 처음 if문 예제소스와 같은 기능인데

처음 if문의 경우 일일이 if문 조건을 만날 때마다 다 확인하고

넘어가지만

else if문의 경우 참인 조건을 만나면 명령을 실행하고

한 방에 다 빠져나가버린다

그러니 if문을 여러개 쓰는 것 보다 효율이 좋다.

또한 조건을 넣을 때 가능하면 확률이 가장 높은 순서대로

위에서부터 나열해 오면 더 높은 효율을 볼 것이다.

--------------

삼항연산자

--------------

- 조건 ? A : B

if문과 똑같은 역할을 한다.

참이면 A

뻥이면 B

그냥 예제를 보자

ex) 예제 소스

#include <stdio.h>

int main()
{
  int iNum;

  printf("숫자를 입력하세요 \n :");
  scanf("%d", &iNum);
  
/*
// if문을 쓴 경우

  printf("입력하신 숫자는 100보다 ");

  if(100 < iNum)
  {
    printf("큼");
  }
  else
  {
    printf("작습");
  }

  printf("니다. \n");
*/

// 삼항 연산자를 쓴 경우

  printf("입력하신 숫자는 100보다 %s니다 \n", 100 < iNum ? "큼" : "작습" );

  return 0;
}

if 문과 삼항연산자의 속도는 똑같다

다만 그 안에 들어가는 명령어에 따라

삼항연산자가 훨씬 좋은 효율을 낼 경우가 있다.

자주는 쓰지 말되 위와 같은 상황에만 쓸 것.....

19일차

-----------------

제     어     문

(반     복     문)

-----------------

-------

while

-------

while(조건) //조건이 참일 경우 아래 중괄호 실행, 거짓이면 탈출.

{

(명령문)

}

ex) 예제 소스코드

#include <stdio.h>

int main()
{
  int iNum = 0;

  while(5 > iNum)                   // 처음에 iNum이 0이므로 조건이 참이다
  {
    printf("Hello World! \n");
    ++iNum;                             // iNum을 증가시켜 1이 되고 다시 조건으로 올라가고
  }                                        // 조건이 거짓이 될 때까지 반복한다.

  return 0;
}

결과 화면

- 순서도

- while 문 조건은 참, 거짓으로 판별하기 때문에

참이면 1을, 거짓이면 0을 나타내므로

0을 제외한 나머지 값은 다 참으로 인식한다.

while( 1 )  // 조건이 계속 참이므로 무한 반복.
{
// 명령
}

while( -1 ) // 이것도 조건이 0이 아니니 참이므로 무한 반복
{
// 명령
}

while( 0 ) // 조건이 0이므로 거짓이므로
{             //  괄호 안에 명령은 절대로 실행되지 않는다.
// 명령(세계 정복)
}

------------

do while문

------------

while문은 조건을 검사하고 괄호 내용을 실행하지만

do while문은 우선 괄호 안을 먼저 실행하고 조건 확인 후

계속 실행할지 여부를 판단한다.

do

{

명령

} while(조건);

한가지 빼먹지 말아야 하는 것은 while(조건) 뒤에 꼭 " ; "을 붙여줘야 된다.

ex) 예제 소스 코드

#include <stdio.h>

int main()
{
  int iNum;
  int iTotal;

  iTotal = 0;
  iNum = 0;

  do
  {
    iNum = iNum + 2;
    iTotal = iTotal + iNum;
  } while(100 > iNum);

  printf("%d \n", iTotal);

  return 0;
}

결과 화면

  2550 

또 생각해야 할 것이 while문과 다르게 먼저 실행을 한 번하고 나서 반복하니

조건을 기입할 때 한 번 실행했다는 것을 생각하고 조건을 대입해야 한다.

-----------

중첩 while

-----------

while 문을 중첩 시킨 것인데 음....

그냥 밑에 예제를 보자.

#include <stdio.h>

int main()
{
  int iCnt1;
  int iCnt2;

  iCnt1 = 0;

  while(5 > iCnt1)
  {
    iCnt2 = iCnt1;

    while(0 < iCnt2)
    {
      printf("O");
      --iCnt2;
    }

    printf("* \n");
    ++iCnt1;
  }

  return 0;
}

출력 화면

필요에 따라 몇 번이고 중첩 시키면 되는데

중첩을 시키면 시킬수록 헷갈리게 되니 생각을 잘해서 쓰는게 좋겠다.

오늘 배운 마지막은 순서도인데 아까 위에서 보았던 그것이다.

나중에 쓸 일이 생길거라고 꼭 알아두시라고 알려주셨다

순서도를 소스코드로 만들 줄 알아야 하고

소스코드도 순서도로 만들 줄 알아야 한다.

작성하기 쉬운 프로그램으로는 엑셀과 파워포인트이고

여기서 작성한 도형들?을 복사해서 그림판에 그대로 붙여 넣을 수 있다.

예제)

18일차

----------------------

리터럴(Literal) 상수

----------------------

- 변수가 아닌 것 상수를 리터럴 상수라 함.

ex) int iNum = 3;    // 여기서 3이 리터럴 상수.

- int형으로 저장 가능한 것은 int형으로 약속하고

- double형으로 저장 가능한 것은 double형으로 저장하기로 약속했다.

----------------

접     미     사

----------------

- (리터럴) 상수 뒤에 써주는 것으로 상수의 자료형을 바꿀 수 있음.

확인 예제 소스

#include <stdio.h>

int main()
{
  printf("3 \t: %d \n", sizeof 3);
  printf("3LL \t: %d \n", sizeof 3LL);
  printf("3.14 \t: %d \n", sizeof 3.14);
  printf("3.14F \t: %d \n", sizeof 3.14F);

  return 0;
}  

출력 화면

---------------------

아스키코드 (ASCII)

---------------------

- 영문자를 표기하기 위해 아스키코드 표를 만들어 그에 상응하는

숫자를 글자 형태로 출력시 영문자가 출력된다.

예제 소스코드

#include <stdio.h>

int main()
{
  char cCh1 = 'A';
  char cCh2 = 65;
  char cCh3 = 'Z';
  char cCh4 = 90;

  printf("%c %d \n", cCh1, cCh1);
  printf("%c %d \n", cCh2, cCh2);
  printf("%c %d \n", cCh3, cCh3);
  printf("%c %d \n", cCh4, cCh4);

  return 0;
}

출력 화면

따라서 문자도 컴퓨터 내에선 숫자로 취급한다.

- 0부터 31까지는 제어문자

- 65 = 'A'      - 90 = 'Z'       - 97 = 'a'     - 122 = 'z'

- 문자열이 아닌 문자 하나만 쓸 경우 char 형 말고 int 형으로 쓰는 것이

더 빠르다. 왜냐하면

-------------------

캐 스 팅 Casting

-------------------

- 묵시적 형변환

컴파일러가 어떠한 언급도 없이 형변환

두 가지로 나뉜다.

- down casting(하향식 형변환)

서로 크기가 안 맞을 경우 맞지 않는 부분 만큼 버림.

ex)

int iNum;

char cNum;

iNum = 257.9;

cNum = iNum;

이와 같이 소스를 짜면 iNum에는 257, cNum에는 1이 들어간다.

iNum에서는 뒤에 소수를 버리고 cNum은 257이 이진수로 1 0000 0001인데

1byte만 가져가므로 0000 0001 만 들어감.

- up casting(상향식 형변환)

데이터의 손실을 막기 위해 범위가 더 큰쪽으로 맞춘다.

ex)

dNum = 1 + 1.4;

1도 double형으로 바뀌어 1.4와 연산되어 dNum에 들어간다.

- 명시적 형변환

프로그래머가 알려서 바뀌는 것

ex)

int iNum1 = 3;

int iNum2 = 4;

double dNum;

dNum = (double)iNum1 / iNum2;

() 괄호는 casting 연산자라 부르고

결국 iNum1이 double형으로 승격하고

묵시적 변환으로 iNum2도 double형으로 승격되어 계산됨.

---------------------------

printf 서식 문자와 특수 문자

---------------------------

추가로 %출력은 %%이다.

17일차

-------------

비트연산자

-------------

비트 연산자 종류는

|     OR  조건 하나가 참일 때 참

&   AND  조건 둘 다 참일 때 참

^   XOR  두 조건이 서로 반대일 때 참

~ TILDE 비트 반전

<< LEFT SHIFT 왼쪽으로 비트 이동

 >> RIGHT SHIFT 오른쪽으로 비트 이동

가 있다.

아래 예제 소스코드를 보자.

#include <stdio.h>

int main()
{
  int iNum1;
  int iNum2;
  int iNum3;

// OR
  iNum1 = 0xB;
  iNum2 = 0x4;
  iNum3 = iNum1 | iNum2;

  printf("OR  : 0x%X\n\n", iNum3);

// AND
  iNum1 = 0xB;
  iNum2 = 0x4;
  iNum3 = iNum1 & iNum2;

  printf("AND : 0x%X\n\n", iNum3);

// TILDE
  iNum1 = 0xFFFFFFF0;
  iNum2 = !iNum1;
  iNum3 = ~iNum1;

  printf("iNum1 : 0x%08X\n", iNum1);
  printf("iNum2 : 0x%08X\n", iNum2);
  printf("iNum3 : 0x%08X\n\n", iNum3);

// XOR
  iNum1 = 0xB;
  iNum2 = 0x6;
  iNum3 = iNum1 ^ iNum2;

  printf("XOR  : 0x%X\n\n", iNum3);

// right SHIFT
  iNum1 = 0x18 >> 1;
  iNum2 = iNum1 >> 1;
  iNum3 = iNum2 >> 2;

  printf("iNum1  : 0x%X\n", iNum1);
  printf("iNum2  : 0x%X\n", iNum2);
  printf("iNum3  : 0x%X\n\n", iNum3);

// left SHIFT
  iNum3 = iNum3 << 3;

  printf("iNum3  : 0x%X\n", iNum3);

  return 0;
}

실행 결과

결과물에 위에 iNum2 : 0x00000000은 ~와 !가 헷갈려서

넣어서 비교해 보았다.

여기서 SHIFT 연산자를 좀 자세히 보기로 하였다.

아래 소스코드

#include <stdio.h>

int main()
{
  signed int iNum;
  unsigned int uiNum;

//
  iNum = 0xFFFFFFFF;
  uiNum = 0xFFFFFFFF;

  printf("1\n");
  printf("iNum  : 0x%X\n", iNum);
  printf("uiNum : 0x%X\n", uiNum);
  printf(" >> 1\n");

  iNum = iNum >> 1;
  uiNum = uiNum >> 1;

  printf("iNum  : 0x%X\n", iNum);
  printf("uiNum : 0x%X\n", uiNum);

//
  iNum = 0x82345678;
  uiNum = 0x82345678;

  printf("\n2\n");
  printf("iNum  : 0x%X\n", iNum);
  printf("uiNum : 0x%X\n", uiNum);
  printf(" >> 1\n");

  iNum = iNum >> 1;
  uiNum = uiNum >> 1;

  printf("iNum  : 0x%X\n", iNum);
  printf("uiNum : 0x%X\n", uiNum);

//
  iNum = 0x72345678;
  uiNum = 0x72345678;

  printf("\n3\n");
  printf("iNum  : 0x%X\n", iNum);
  printf("uiNum : 0x%X\n", uiNum);
  printf(" >> 1\n");

  iNum = iNum >> 1;
  uiNum = uiNum >> 1;

  printf("iNum  : 0x%X\n", iNum);
  printf("uiNum : 0x%X\n", uiNum);

//
  iNum = 0x72345678;
  uiNum = 0x72345678;

  printf("\n4\n");
  printf("iNum  : 0x%X\n", iNum);
  printf("uiNum : 0x%X\n", uiNum);
  printf(" << 1\n");

  iNum = iNum << 1;
  uiNum = uiNum << 1;

  printf("iNum  : 0x%X\n", iNum);
  printf("uiNum : 0x%X\n", uiNum);

//
  iNum = 0x82345678;
  uiNum = 0x82345678;

  printf("\n5\n");
  printf("iNum  : 0x%X\n", iNum);
  printf("uiNum : 0x%X\n", uiNum);
  printf(" << 1\n");

  iNum = iNum << 1;
  uiNum = uiNum << 1;

  printf("iNum  : 0x%X\n", iNum);
  printf("uiNum : 0x%X\n", uiNum);

  return 0;
}

 실행 결과

여기서 변수 앞에 signed, unsigned를 붙여서 연산한 결과가

다르게 나온다는 것을 볼 수 있다.

>> 오른쪽 SHIFT로 비트를 움직일 경우

1번과 2번의 결과를 통해

signed는 맨 앞에 부호비트로 인식?해서 맨 앞자리는 계속 1(음수)을 채워 넣고

unsigned는 명령하는 대로 움직이는 것을 볼 수 있다.

하지만 3번과 4번, 5번을 통해

signed의 맨 앞자리가 0일 경우(양수) unsigned와 같은 결과를 보고

<< 왼쪽 SHIFT로 비트를 움직일 경우

둘 다 명령처럼 움직이는 것을 볼 수 있다.

* 따라서 SHIFT연산을 할 경우 원하는 값대로 나오게 하려면

unsigned를 붙여야 한다. 또 컴퓨터 내에서 unsigned가 더 빠르다

-------------------

상수와 변수, const

-------------------

const는 변수를 상수화 시키는 것이다.

오직 읽기만 가능하기에 반드시 선언시에 초기화를 해야한다.

아래는 const상수 실습 소스코드.

#include <stdio.h>

int main()
{
  int iNum = 3;
  const int ciNum = 100;

  iNum = 100;
//  ciNum = 1000;
  printf("%d\n", ciNum);

  return 0;
}

위에 ciNum = 1000;을 넣으면 l-value Error가 뜬다.

iNum = 100;

=을 중심으로 왼쪽은 l-value (Left Value),

오른쪽은 r-value (Right Value)라고 부른다.

-------

sizeof

-------

변수나 상수 등 크기를 측량하는 연산자.

지금까지 sizeof()가 뒤에 괄호가 붙으니 함수인지 알았는데

연산자였다.... 괄호는 우선순위만 정해주는 역할이었다.. 충격..

아래는 실습 소스코드

#include <stdio.h>

int main()
{
  int iNum;

  printf("char : %d\n", sizeof(char));
  printf("short : %d\n", sizeof(short));
  printf("int : %d\n", sizeof(int));
  printf("long : %d\n", sizeof(long));
  printf("long long : %d\n", sizeof(long long));
  printf("float : %d\n", sizeof(float));
  printf("double : %d\n", sizeof(double));
  printf("long double : %d\n", sizeof(long double));
//  printf("sizeof 3.5 : %d\n", sizeof 3.5 );
//  printf("sizeof iNum + 3 : %d\n", sizeof iNum + 3);

  return 0;
}

출력 화면

왼쪽은 MS-DOS VC++로 실행한 결과이고

오른쪽은 Linux gcc에서 실행한 결과이다.

변수의 크기는 컴파일러 마다 다르기 때문에

새로운 컴파일러를 사용시 꼭 확인해야 한다.

그리고 아래는 sizeof가 함수가 아니라 연산자라는 것을 확인한 것이다

위에 소스에서 주석 처리한 부분을 실행한 결과다. 

결과 화면과 같이 sizeof 는 연산자였다.......

그리고 실수를 넣었을 때에 컴파일러 마다 float일지 double형일지는

이것도 확인해 봐야 한다고 한다.

16일차

-----------

scanf 함수

-----------

scanf("서식문자", &변수);

여기서 &기호는 나중에 포인터 나올 때에 다시 배우기로 하고

우선 scanf 함수 내에 변수 앞에는 무조건 붙인다.

---------------

16진수와 10진수

---------------

보통 프로그램 만들 때에는 10진수를 사용하지만

임베디드는 주로 16진수를 사용한다고 한다.

위에 그림과 같이 LED에  불을 킨다면 한 자리당 그 해당하는 LED 스위치를

담당한다고 한다. 0이 켜지는 것이라고 하셨다.

그래서 소스에

int iSwitch = 0x05; // 0101 (2) == 0x05 (16)

이런 식으로 표현될 것이라고 하심.

----------

실       수

----------

실수 구조 ( IEEE 754 )

- 오늘 알게된 것 중 주관적으로 가장 중요한 것이라고 생각하는 것이

cpu내에서 실수는 정수보다 훨씬 느리다. 가급적이면 정수를 사용할 것.

정수가 메모리에 저장되는 구조와 실수가 저장되는 구조가 다르고 실수가 훨씬 어렵다

-실수 변수 사용 예

#include <stdio.h>

int main()
{
  float fNum;

  fNum = 3.0/2;  /* 여기서 잿수와 피잿수 중 하나라도 실수가 아니면

                           정수로 계산하여 실수형태로 저장하기 때문에 둘 중 하나는

                           반드시 실수형태여야 한다. */

  printf("%f\n", fNum);   // 실수는 %f 로 사용.

  return 0;
}

15일차

------------------------------------------

Magnitude 방식과 2'Complete(2의 보수법)

------------------------------------------

unsigned 붙은것과 안 붙은것

2의 보수법을 취하는 것을 보는 소스다.

#include <stdio.h>

int main()
{
  unsigned char cNum1;
  char cNum2;

  cNum1 = 127;
  cNum2 = 127;
  printf("%d    %d\n", cNum1, cNum2);

  cNum1 = 128;
  cNum2 = 128;
  printf("%d    %d\n", cNum1, cNum2);

  cNum1 = 129;
  cNum2 = 129;
  printf("%d    %d\n", cNum1, cNum2);

  cNum1 = 255;
  cNum2 = 255;
  printf("%d    %d\n", cNum1, cNum2);

  return 0;
}

출력 화면

------------------

관계, 논리 연산자

------------------

#include <stdio.h>

int main()
{
  int iNum1;
  int iNum2;
  int iNum3;
  int iNum4;
  int iNum5;
  int iNum6;
  int iNum7;
  int iNum8;
  int iNum9;
  int iNum10;

  iNum1 = 6 > 5;
  iNum2 = 6 > 7;
  iNum3 = 7 == 6;
  iNum4 = !3;
  iNum5 = 7 != 6;
  iNum6 = 7 <= 7;
  iNum7 = 7 && 6;
  iNum8 = 8 || 0;
  iNum9 = 100;
  iNum10 = 7 || (++iNum9);

  printf("iNum1 = %d\n", iNum1);
  printf("iNum2 = %d\n", iNum2);
  printf("iNum3 = %d\n", iNum3);
  printf("iNum4 = %d\n", iNum4);
  printf("iNum5 = %d\n", iNum5);
  printf("iNum6 = %d\n", iNum6);
  printf("iNum7 = %d\n", iNum7);
  printf("iNum8 = %d\n", iNum8);
  printf("iNum9 = %d\n", iNum9);
  printf("iNum10 = %d\n", iNum10);

  return 0;
}

출력화면

여기서 재미있는게 있는데

바로 iNum9의 값이다.

원래 예상대로라면 101이 나와야 하지만 100이 나왔다.

왜냐하면 cpu에서도 일을 적게하려 하기에 || (or) 을 실행 시

앞의 조건이 참이면 뒷 조건은 실행하지 않는다.

반대로 앞 조건이 거짓이면 뒷 조건을 실행한다.

14일차

C프로그래밍을 배움.

Windows 환경과 Linux 환경을 비교해가며 배움.

Linux에서도 cc 사용 가능.(cc를 쓰면 자동으로 gcc를 사용하도록 되있다고 한다.)

- printf("\n");

ms-dos에서는 프로그램을 실행하고 명령입력창?( C:\>_ )을 띄울 때

라인피드와 캐리지 리턴을 실행하는 반면,

linux에서는 프로그램을 실행하고 명령입력창?( [id@server path] _ )을 띄울 때

캐리지 리턴만 하는 것 같다.

그래서 마지막 printf() 함수에서 \n개행문자를 안 넣어주면

결과 값이 다르게 나온다는 것을 보았다.

오늘 배운 것 중에 유심히 본 것이 일의 순서에 대하여 언급하신 것인데

나중에 임베디드 프로그래밍을 할 때에 저렇게 완다갔다 하는 시간을

줄여서 최적화하는데 한 몫하지 않나 싶다. 아직은 잘 모르니 앞으로 유심히 봐야 할 것.

13일차

컴파일 : C언어에서 기계어로 바꾸는 과정

   ***.c       ---->    ***.i      ---->    ***.s(asm)   ----->   ***.o(obj)   ---->  ***.(exe)

(소스파일)   전처리               컴파일                    어셈블리                    링크

- int : 반환하는 값의 형식

- main : Entry Point 라고 진입점. 프로그램이 시작할때 처음 진입하는 함수.

- () : 조건부로 보면 되는데 인수가 들어간다. 이건 나중에 배울 예정.

- {  } : main 처럼 함수의 끝과 시작.

- return : 반환하라는 의미로 함수의 종료를 뜻한다.

- 0 : 반환하는 값을 0으로 주는데, 프로그래머의 재량으로 아무 값이나 주면 되는데

       c표준으로 0을 쓰면 아무 문제 없이 잘 끝났다는 의미로 사용.

- ; : 세미콜론으로 한 명령이 끝 날 때마다 사용. 명령어 구분.

12일차

cl 환경변수로 등록

clexe 환경변수 등록과정.pptx

오전에는 전에 배운 리눅스 복습, 오후엔 프로그래밍을 조금 배웠다.