블로그 이미지
송시혁

calendar

1 2 3
4 5 6 7 8 9 10
11 12 13 14 15 16 17
18 19 20 21 22 23 24
25 26 27 28 29 30 31

Notice

Tag

Recent Post

Recent Comment

Recent Trackback

Archive

9구단 프로그램.


#include <stdio.h>
int main()
{
  unsigned int uiCnt;
  unsigned char ucdan;
  ucdan =2;
  uiCnt =1;
  
  while(ucdan<=9)
  {
  
  
    
    
    printf("%d단\n", ucdan);
    printf("\n");
    while(uiCnt<=9)
    {
     

     printf("%d * %d= d\n",ucdan, uiCnt, uiCnt*ucdan);
     uiCnt = uiCnt +1;
    
    }
    ucdan = ucdan +1;//단수를 한 단계 높인다. 2,3,4....
    uiCnt =1; // uiCnt를 초기화.
  printf("\n");
  
  }
  return 0;
}


출력은 너무 길어서 생략. 프로그램을 구성시에는 반드시 하나 하나 따져본다. 이 변수의 값을 지정하면 어떤값이 들어가는지 하나하나 따져보면서 하자. 필자도 솔직히 고생많이 했다. 본론으로 가자면,  while문내부에 while문을 중첩해서 썼다. 와일문 내부는 어제 정리했던 5구단을 옮겨온것이다. 이것은 제껴두고 생각한다.(기억안나면, 3월13일것 참고)

먼저 2구단. 2구단은 아홉번이 나오고 다음 3구단으로 넘어가야한다. 그러나 아래와 같은 소스를 짜면, 넘어가지 않는다. 

while(ucdan<=9)
  {

while(uiCnt<=9)
    {
      printf("%d * %d= %d\n",ucdan, uiCnt, uiCnt*ucdan);
      uiCnt = uiCnt +1;
    
    }
    ucdan = ucdan +1;
 
  
  }

위의 소스에서 내부while은 일단 없다고 가정한다. ucdan에서 1을 증가시키는 것을 썼는데도 출력은 2구단만 출력된다. 그 이유는 바로 메모리 저장형태를 잘 생각해보자. while문에서 ucdan이 초기값2는 프린트문에 들어가서 출력된다. 그러나, 다음 ucdan은 2를 아래 선언한 ucdan = ucdan +1; 에 저장이되어 3이된다. 그러나 3단은 나오지 않는다. 그 이유는 uiCnt에 있다. uiCnt는 내부while문에서 9를 넘으면 10의 값이 바깥으로 나가게된다.여기서 10은 메모리를 말한다. 그러니깐 2단수로 따지자면,

2*1, ~2*9까지 실행한후 10의 값은 원래는 2*10이 되나, 조건에서 uiCnt<=9이므로 조건을 만족시키지 못한다. 그래서 화면에는 2*9까지만 출력이 된다. while(안쪽)문이 실행을 멈춘다.

그래서 밖에 while문에 선언된  ucdan = ucdan +1; 에 값은 3은 들어가지만 정작 곱해야하는 수인 uiCnt는 출력되지 않으므로 실행되지 않는다. 그래서 따로 초기값을 설정한다!!

이것이 이 프로그램에 핵심이다. 안쪽 while문을 실행한 다음, while문에 uicnt =1;이라고 초기화 시켜야한다. 그래야 uicnt가 내부 while문에서 9까지 실행한 다음에 초기값에 의해 1이 되고 3단을 출력한다.

while(ucdan<=9)
  {

while(uiCnt<=9)
    {
      printf("%d * %d= %d\n",ucdan, uiCnt, uiCnt*ucdan);
      uiCnt = uiCnt +1;
    
    }
    ucdan = ucdan +1;

uiCnt = 1; // 여기에 초기화 값 넣는다.
 
  
  }



while 조건이 <=9이므로 9단까지 출력이 되는 것이다.





홀수구구단 3,5,7,9







#include
 <stdio.h>
int main()
{
  unsigned int uiCnt;
  unsigned char ucdan;
  ucdan =3;
  
  
  
  while(ucdan<=9)
  {
    uiCnt =1;
    while(uiCnt<=9)
      
    {  
      
      printf("%d * %d= %d\n",ucdan, uiCnt, uiCnt*ucdan);
      uiCnt = uiCnt +1;
    
    }
      ucdan = ucdan +2;// 단수를 +2를 하여 3,5,7....
    
  }       
  return 0;
}

간단하다


 그러나 다른 형식으로 홀수 프로그램 소스.


#include <stdio.h>
int main()
{
  unsigned int uiCnt;
  unsigned char ucdan;
  ucdan =2;
  
  
  
  while(ucdan<=9)
  {
    if(0==ucdan%2)
    {
      
      ++ucdan;  
      continue;
      


  
    }
    uiCnt =1;
    while(uiCnt<=9)
      
    {  
      
      printf("%d * %d= %d\n",ucdan, uiCnt, uiCnt*ucdan);
      uiCnt = uiCnt +1;
    
    }
      ucdan = ucdan +1;
    
  }       
  return 0;
}
while문안에 if문을 사용하여 홀수 프로그램을 구성한 것이다.

if에 조건은 ucdan을 2로 나눈 나머지가 0과 같다면, ucdan은 1증가된다. 그리고 continue에 의하여 if문에서 위에 while문으로 올라가서 다시 실행된다. 즉 if문이 참이면 그 값이 아래 while문으로 가는 것이 아니라 if문 아래 ++ucdan;이 실행되고  continue;에 의해 if문으로 다시 올라가 조건을 따지게 된다. 여기서 continue는 현재위치에 다시 올라가서 반복을 하게 해주는 명령문이다. 그래서
ucdan<=9로 값이 가서 다시 조건을 따진다.

2%2= 0(나머지) 이므로 uiCnt가 1증가하여 다시 if문으로 가서 조건을 따진다.

3%2 =1(나머지) 나머지가 1이므로 if문은 실행되지 않고 while문으로 내려가 실행된다. 그래서 3단이 출력되고 다음에 5단 ,7단이 출력이 되는 것이다.




#include <stdio.h>
int main()
{
  unsigned int uiCnt;
  unsigned char ucdan;
  ucdan =2;
  
  
  
  while(ucdan<=9)
  {
    uiCnt =1;
    while(uiCnt<=9)
      
    {  
      
      printf("%d * %d= %2d ",ucdan, uiCnt, uiCnt*ucdan);
      uiCnt = uiCnt +1;
        
        if(0==(uiCnt-1)%3)
        {
      
          putchar('\n');  
                


  
        }

    
    }
      ucdan = ucdan +1;
      putchar('\n');
    
  }       
  return 0;
}


출력을 잘보면 답이 나온다. 이번에는 내부에 while문에 if문을 썻다. if문에 의해 나머지가 0이 아니면 거짓이므로 if문 소스는 실행되지 않는다. 그래서 내부while문만 실행된다. 하지만, 나머지가 3이 되는 순간, if문이 실행되고 '\n'에 의해서 줄바꾸기가 실행된다. 그상태에서 계속 반복하여 3줄씩 출력된다. 이것은 보는것 보다 직접 입력해서 컴파일 하면 쉽게 이해 할 수 있다.

다음은 글자수를 알려주는 프로그램.

#include <stdio.h>
int main()
{
  char ch;
  int count = 0;
  
  printf("Please enter characters <q for quit>: ");
  ch = getchar();
  while (ch !='q')
  {
    count = count +1;
    ch = getchar();
  }
  printf("the number of character is %d\n", count);
  printf("This is the end of program.\n");
  return 0;

}
  

while조건문 ch !='q'를 주목한다. !=와 같이 않으면 참이라는 뜻이다. q와 같지 않으면 실행된다. 그래서 q를 누르기 전까지 한 없이 반복되고 count에 의해 숫자가 늘어난다. 즉 a를 쓰면 1번, ab를 쓰면 2번 .... 이런식으로 값이 메모리에 저장하다고 q를 누르는 순간 멈추고 가장 아래 프린트문을 출력한다.

 


 p3-14예제

#include <stdio.h>
int main()
{
  int number;
  long sum = 0;
  number = 100;
  while(number != 0)
  {
    sum += number; // sum = sum + number;
    printf("Please enter an integer <0 to quit> : \n");
    scanf("%d"&number);
  }
  printf("The sum of numbers is %1d.\n", sum);
}
  

 number가 0과 같지 않으면 while문이 실행된다.

그래서 scanf로 키보드 숫자를 입력받아서 조건에 만족하면 계속 반복한다.

그러다가 0을 입력하면 실행을 멈추고 이때까지 입력했던 number를 더한다.

아래 9.2.3.100을 입력하다 0을 입력하니 바로 실행이

 멈춤고(while문 멈춤) 214라는 값이 출력되었다. 214는 필자가 임의로 입력

한 것을 더해서 계산된 값이다.

 

 

 

 

 

p3-15예제

위와 비슷한 프로그램. 여기에서는 초기화를 scanf로 한 것 뿐이다.

#include <stdio.h>
int main()
{
  int number;
  long sum = 0;
  
  printf("Please enter an integer <0 to quit> : ");
  scanf("%d"&number); //제어변수 초기화
  
  while(number != 0//반복여부를 결정하는 논리식
  {
    sum += number;
    printf("Please enter an integer <0 to quit> : \n");
    scanf("%d"&number); //제어변수 값의 변경
  }
  printf("The sum of numbers is %1d.\n", sum);
  return 0;
}

scanf로 키보드로 받은 값이 초기값으로 설정되고 while문이 실행된다. 실행되는 방법은

위의 소스와 동일하다. 단 이프로그램에서는 초기화를 scanf로 한것 뿐이다.

 

 

posted by 송시혁

문자입출력함수

getchar() - 한글자 읽을 때 사용

putchar() - 한글자 출력할 때 사용


#include <stdio.h>
int main()
{
  printf("hello\n");
  getchar();
  return 0;
}



#include <stdio.h>
int main()
{
  char ch;
  printf("Please enter any character: ");
  ch = getchar();
  putchar (ch);
  printf(" is a letter you typed.\n");
  fflush (stdin);
  printf("Please enter any character:");
  scanf("%c"&ch);
  printf("%c is a letter you typed.\n", ch);
  return 0;
}



출력화면에서 보듯이 d를 입력하고 엔터를 쳐야 해당 프린트문이 생성된다.

즉, 버퍼를 기다리고 그것을 실행한다.

여기서 fflush는 보이지 않는 버퍼를 없애버린다. 여기서 보이지 않는 값은  엔터 키이다. 버퍼를 지움으로서 그 다음 문장인 printf("Please enter any character:");를 기다리게 하는 기능이다. 그러니깐 먼저, d is a letter you typed. 먼저 실행되고 입력을 받을 때까지 기다리다 문자를 입력하면 비로소 Please enter any character: 에 문자를 입력해야 a is a letter you typed가 생성된다.


#include <conio.h>// getch(), getch(), putch()
#include <stdio.h> printf()
int main()
{
  int ch;
  printf("Please enter any character: ");
  ch = getche();
  putch (ch);
  printf(" is a letter you typed:\n");
  
  printf("Please enter any character: \n");
  ch = getch(); //입력문자는 화면에 출력되지 않음.
  putch(ch);
  printf(" is a letter you typed.\n");
  return 0;
}

conio.h는 콘솔입출력 함수.
getch()는 출력화면 입력시 아예 보여주지 않는다. 리눅스 패스워드
getche() 는 값을 출력이 되나, 값과는 다른 형태로 출력. 예) 패스워드:*******
putch() 출력

a를 입력하면 엔터키를 치지 않아도 화면에 출력이 된다.


반복문

while(정지조건) -> 논리값

while(참) 정지, 그렇지 않으면 무한반복

프로그램 정지시키는 법 ctrl + break, ctrl + c 가능하면 ctrl + break를 
쓴다 컨트롤 시는 안먹힐 때가 있다.

형식

while()

{

명령문

}


#include <stdio.h>
int main()
{
  int num;
  num = 0//제어변수 n의 초기화
  while(num <=5//반복여부를 결정하는 논리식
  {
    printf("%d\t", num); //\t tab건너뛰다. num = num +1;으로 6이되면 탈출.
      num = num +1// 제어변수의 값의 변경
  }
  printf("\n");
   return 0;
}




#include <stdio.h>
int main()
{
  unsigned int uiCnt = 490;
  
  while(1)
  //while(500 >=uiCnt)

  {
    if(uiCnt>500)
    {
      break;
      
    }
    printf("%u he\n", uiCnt);
    ++uiCnt;

  }  
  
/*      
  while(1)
  {
  }
*/

  
   return 0;
}
while문에 uiCnt가 500이 되었을때 실행을 멈춘다. 그전에는 조건을 계속 만족시켜

 반복적으로 실행이 된다.그래서 490 he, 491 he....가 차례대로 실행된다.

여기서 주의 할것은 아래 출력화면을 보면 500 he까지 출력되는 것을 확인 할 수 있다.초기값 490에서

500이 넘으면 실행이 되지 않다고 조건을 걸고 있으나, 실제로

실행하는 횟수는 11번이다.그래서 500 he까지는 출력이 되고 501 he가 되면

 정지가 되어 실행되지 않는다.



5단 구구셈

#include <stdio.h>
int main()
{
  unsigned int uiCnt;
  unsigned char ucdan = 5;
  uiCnt = 1;// 여기에 초기값을 선언해야한다.
  
  while(uiCnt<=9)
  {
    printf("%d * %d= %d\n",ucdan, uiCnt, uiCnt*ucdan);
    uiCnt = uiCnt +1;
  }
  

  
    
   return 0;
  
}




posted by 송시혁

if문 예제p3-5

 

#include<stdio.h>
int main()
{
  int num1;
  int num2; 
  int bigger;

  printf("Please enter two integers: ");
  scanf("%d %d"&num1, &num2);
  bigger = num1;
  if(num1 < num2) 
  {
    bigger = num2;
  }
  printf("The larger number is : %3d\n", bigger);


}

swap = 바꾸는것, 예를 들어 bigger = num1이 였는데 아래에 if문에 조건이 맞아

 bigger = num1이 되는데 이렇게 프로그램내부에서

 값이 변하는 것을 스왑(swap)이라한다.

2줄이상은 반드시 중괄호를 해야한다. 그러나 1줄을 생략가능

if문으로 큰 수 나오게 입력하기

어제 공부했듯이 if문은 참일 때만 실행된다.

if(num1 <num2)에서 num1이 num2보다

 작을 경우 참이 되므로 num2는 bigger에 대입된다.

 그래서 10, 20을 입력했을 때 20이 num2에

저장되므로 출력된다.

20 10으로 입력된경우 넘1이 넘2보다 더 크므로

 if의 조건은 거짓이 된다. 그래서 num1이

그래도 20이라는 값을 가진다.

그래서 아래 프린트문에 출력된다.

프린트문은 if과 관게없는 관계로 무조건 출력된다.












if else문 예제 p3-6


#include <stdio.h>
int main()
{
  int num1;
  int num2;
  int bigger;
  int smaller;
  
  printf("Please enter two integers: ");
  scanf("%d %d"&num1, &num2); 
  if(num1 < num2)
  {
    bigger = num2; 
    smaller = num1;
  }

  else //if의 조건이 맞지 않는경우 아래와 같이 실행.
  {  
    bigger = num1;
    smaller = num2;
  }
  printf("%d is larger than %3d\n", bigger, smaller);

  return 0;
}

 위와 마찬가지로 if문에 조건이 맞으면 그래도 bigger = num2에 정장.

smaller = num1이다. 그러난 조건이 거짓이면,

 else문으로 넘어가 num1이 bigger에 대입되고

 num2가 smaller가 된다.  그리고

printf문으로 출력된다.

주의할 점은 if, if else에서는 들여쓰기가 중요하다.

들여쓰기

만약에 if(조건) { 명령문, 명령문,~~~~

길게 이어쓸수 있지만, 시각적으로 좋지 않기

 때문에 프로그램이 장문인 경우 좋지 않다. 그래서


int main()

{

if(조건)

{

명령문

}

}



이런식으로 {}중괄호를 쓰면, if의 명령문이 어디까지인지

 보기가 좋고 나중에 에러가 떴을 때 쉽게

 수정해나갈 수 있다.


 





p3-7 if와 else if

#include <stdio.h>
int main()
{
  int score;
  char grade = 'X';
  
  printf("Please enter examination score: ");
  scanf("%d"&score); //90을 치면 10을 나눠 9를 만든다.
  if((score <= 100)&&(score >=90)) //9
  {
    grade = 'A';
  }
  else if((score < 90)&&(score >=80))
  {
    grade = 'B';  
  }
  else if((score < 80)&&(score >=70))
  {
    grade = 'C';
  }
  else if((score < 70)&&(score >=60))
  {
    grade = 'D';
  }
  else if((score < 60)&&(score >=0))
  {
    grade = 'F';
  }
  else 
  {
    printf("Wrong score\n");
  }
  printf("The grade is %c\n", grade);

  return 0;
}

위에서 else가 뭐하는지 알았다.

 

그런데 여기에서는 마지막 빼고는 else if를 썻다.

 

그이유는 else는 중첩해서 쓸수 없기 때문이다. 

 

마찬가지로 if문이 조건을 만족시키지 못하면

elseif가 차례대로 실행된다. 예를 들면 90을 입력한다.

 90의 조건에 맞는 첫번째 if문에 참값이 된다.

 그리고 나머지 엘스 이프~~~엘스를 건너뛰어  

출력을 하게 된다. 만약에 68이라면 

 

else if((score < 70)&&(score >=60))문에 만족시킴으로

 

참값이 되고 아래를 건너뛰어 출력이 D로 출력된다.

 

위 프로그램에서 else가 없어도 결과는 같다.

 

하지만,엘스가 없다고 가정하자.
100을 입력하면, 처음 if문이 참값으로 받아들여도

 

아래 if문을 건너뛰지 않고 따지게 된다.

 

즉, 처리속도가 느려서 문제가 발생할 수도 있다.

 

따라서, elseif를 쓴것이다.


if

스위치문(swich).

바꾸다, 변환하다라는 뜻.

case 형식: case 정수(정수중에서 상수) ; 


p3-8

#include <stdio.h>
int main()
{
  int score;
  char grade;
  
  printf("Please enter examination score: ");
  scanf("%d"&score);
  score = score / 10;
  switch (score)
  {
    case 10:
    case 9
      grade = 'A'
      break;
    case 8
      grade = 'B'
      break;
    case 7
      grade = 'C'
      break;
    case 6
      grade = 'D'
      break;
    default
      grade = 'F'
      break;
  }
  printf("The grade is %c\n", grade);
}
break;는 실행을 멈추는 역할 case문이

 실행되면 그것을 정지하여 default값에 보내어진다.

만약에 90이라 입력하면 score에서 연산/을 하여 9가 된다.

 9가 되면, case 9: 의 값이 들어가고 A가 출력된다.

'A'는 아스키코드. 끝에 확장자 %c이기 때문에 그대로 A출력된다.

elseif- 범위지정

swich - 값을 일일이 지정해야한다.

 예를 들어 99를 입력하면 case99:~~~~

 이렇게 적어놓아야 한다.

위의 소스는 score =score /10을 하여 10을 나눔으로서

 일의 자리로 값을 나누게 된다. 99를 9.9로 되고 .9를 날려서

 9의 값을 가지고 case 9:에 실행된다. 

elseif는 범위지정을 하고 프로그램을 짤때

 유리하고 swich(case)문은 값이 명확할때 유용하다.






break문을 주석처리


#include <stdio.h>
int main()
{
  int score;
  char grade;
  
  printf("Please enter examination score: ");
  scanf("%d"&score);
  score = score / 10// 77을 입력하면, 7.7 소수버리고 case7로 간다.
  switch (score) // ()에는 정수변수
  {
    case 10//케이스 정수중에서 상수
    case 9
      grade = 'A'// 들여쓰기
      //break;
    case 8
      grade = 'B'//case:
      //break;
    case 7
      grade = 'C'//        명령;
      //break;
    case 6
      grade = 'D'//  위의 주석문 형태로 케이스 들여쓰기.
      break;
    
    default: grade = 'F'

       //break;
  }
  printf("The grade is %c\n", grade);
}

이경우 어떠한 수를 넣어도 F가 출력한다.

break는 조건을 만족시키면 정지시키고 printf문으로 바로

출력할 수 있게 한다. 그러나, 모두  break를 주석처리

 했기때문에 멈추지 않아 결국 default값으로 저장된다.


p3-9


#include
 <stdio.h>
int main()
{
  char ch;
  printf("Please enter a number between 0 to 9:");
  scanf("%c"&ch);
  switch(ch)
  {
    case'0':
          printf("Input Number is zero.\n");
        break;
    case'1':
          printf("Input Number is one.\n");
        break;
    case'2':
          printf("Input Number is two.\n");
        break;
    case'3':
          printf("Input Number is three.\n");
        break;
    case'4':
          printf("Input Number is Four.\n");
        break;
    case'5':
          printf("Input Number is five.\n");
        break;
    case'6':
          printf("Input Number is six.\n");
           break;
    case'7':
          printf("Input Number is seven.\n");
        break;
    case'8':
          printf("Input Number is Eight.\n");
        break;
    case'9':
          printf("Input Number is Nine.\n");
        break;
    default : printf("wrong number\n");
  }
  return 0;
}


0에서 9범위안에 숫자를 넣으면 해당 프린트문이출력된다.





posted by 송시혁


 증감연산자.

 a = a +1; , ++a;는 같은 뜻.


예) b=100; ,a=5;


b= ++a;(1)


b = a++;(2)


1. 전치문 a : 6,  b : 6


2. 후치문 b : 5,  a : 6


b = ++a; 알아보기 쉽게 표현.


a = a + 1;


b = a;


b = a++; 알아보기 쉽게 표현.


b = a;


a = a+1;





부가연산자.(대입연산자)

부가 연산

부가

x += 5;

x = x + 5;

-5;

x = x - 5;

x %= 5;

x  = x % 5;

*x;

x = x * 5;


가능하면 오른쪽으로 프로그래밍 한다!!

좌변 = 우변

좌변  = l(L) value

우변  =  r(R) value

'='이 기준이다.

변수선언시 유의

변수 = 변수, 상수, 수식, 함수

예) 3= 5;(x) 좌변이 상수(x)

3 + 1 = 5 + 4; 좌변이 수식(x)

 다음은 변수에 함수를 넣어 만든 소스.

#include <stdio.h>
int main()
{
  int inum;
  inum = printf("12\n");
  printf("%d\n", inum);
  return 0;
}

enter까지 포함하여 화면에 inum의 갯수 가 출력된다.

지금 inum = printf("12\n");선언 되었다. 프린트문에 12가 출력되겠지만

이것이 printf("12\n"); inum에 대입되었다. 그래서 아래에 프린트문에서 %d로 받아 출력이 된다

그런데 3이 출력이 되었다. 12인데 3으로 출력이 된것은 우리가 enter키를 포함해서 출력한 것이다. 즉, 12가 출력이 되고 키보드로 enter를 누른 것까지 합하여 3이 나온것이다.





#include <stdio.h>
int main()
{
  int num = 17;
  printf("num += 5: %d\n", num += 5);
  printf("num -= 5: %d\n", num -=5);
  printf("num *= 5: %d\n", num *=5);
  printf("num /= 5: %d\n", num /=5);
  printf("num %= 5: %d\n", num %=5);    
  
  return 0;
}

 x += 5; -> x= x+5;만 쓴다.(알아보기 쉽다)

int num;

num = num +5;(초기화되지 않았다)

num  =17; 선언하면-> 초기화된 상태. 

num + 5;에서 17을 + 5 연산을 먼저한 뒤, = 좌변에 있는 num에 저장된다.

그래서 아래 출력에 22가 나온다. 2번째 프린트문에서도 마찬가지로  num = num -5;

에서 num이 저장되어 있는 값 22를 먼저 -5한 다음 = 좌변에 있는 num에 대입이 된다.

그래서 17이 된다. 그와 같은 방법으로 연산이 되어 아래와 같은 결과가 나온다.

이부분은 잠깐 맨마지막 참고 자료에서 따로 언급하겠다.





캐스트 연산자.

int + float 인 경우 생각해보자. int가 정수형 float이 실수형. 서로가 다른 타입의 자료형

이 때 int가 실수형인 float으로 변환하여 연산된다. 이처럼 int의 타입이 실수형으로 임시적으로

변하게 이것을 캐스트라고 부른다.

캐스트  : 타입을 바꾸는 것, 상수, 변수 앞에()를 붙이면 수동적으로 자료형을 바꿀 수 있다.

예) 4+3.2f = 묵시적형변환(컴파일시 error를 띄우지 않는다)

(float)4 + 3.2f = 명시적형변환(수동적으로 캐스트를 집어넣었다.)

4를 (float)으로 지정하지 않아도 자동적으로 캐스팅 되지만(위의 예),

(float)으로 수동적으로 해주면 정확한 결과를 얻을 수 있다. 다음의 예제를 보면서 생각해보자.



#include <stdio.h>
int main()
{
  int intA= 14, intB =3;
  
  float floatC = 0;
  
  floatC = intA / intB; //
  printf("%f\n",floatC);
  
  floatC = (float) intA / intB;
  printf("%0.10f\n", floatC);
    
  
  return 0;
}

floatc = intA /intB;에서 자료형인 intA와 intB는 같은 정수형이다. 그래서 먼저 14/3을 연산하여 몫이 4가 나오는데 = 좌변인 float의 의해 실수형이된다. 그러나 이미,  intA /intB;가 대입하기 전에 먼저 int형으로 계산하여 float에 대입된다. 

즉, intA /intB; = 4.xxxxx에서 .xxxxxx가 지워지고 4만 남게 된다. 그리고 이제야 실수인 float에실수형의 변환하지만, 4.0000000으로 출력된다. 이미, .xxxxxxxx부분이 날아갔기 때문이다.

하지만, 다음구문floatc = (float)intA /intB; 에서는 수동적으로 캐스트를 해주었다. 즉 intA는 실수가 되는 것이고 따라서 intB또한 실수형으로 변환한다. intA/intB가 캐스트되어 실수형소수까지 연산되고, = 좌변읜 float에 대입된다. 이때, 똑같은 실수형이므로 출력이 4.xxxxxx까지 출력된다. 위의 프린트문에서는 소수점 10자리까지 표현되었다.

 그런데 결과값이 제대로 나오지 않았다  그이유는 float의 크기가 작아 다 표현하지 못해 에러가 났다

이런 경우 float 값을 double 로 바꾸면 정상적으로 출력된다.


printf()함수

형식

1.("내용");

2.(" %형\n", 변수,상수); 

3.("%형%형", , , ); 그림참조


 4.대소문자.

5.소수점사용가능 예)4.5;

다음예제보기. 30을 10진수, 8진수, 16진수




#include <stdio.h>
int main()
{
  int num;
  num = 30;
  printf("%d\n", num); //10진수
  printf("%o\n", num);//8진수 
  printf("%x\n", num);//16진수
  
  return 0;
}





scanf()함수

scanf() 수가 키보로부터 값을 받을 때는 사용 <엔터 >  

지는 입력  는다.

버퍼 - 그램과  이에 일시으로 값을 저장

단락문자(공백문자) - 여러개의 입력값은 동시에 읽을 경우 사용

                                , 문자, 탭문자


127을 소스에 입력한다고 생각하자. 
scanf내부처리를 표현하면 
num = ('1' - '0')*100; // 1*100이되어 100
num = ('2' - '0')*10 + num; //  (2-0)*10+ 100이되어 120.

num = ('7' - '0') + num; // 7+120이 되어 비로소 127이된다.





#include <stdio.h>
int main()
{
  printf("%d\n"'9'-'0');
  printf("%p\n"255);
  printf("%08x\n"255); // 8자리를 나타내되, 앞에 비워있는 곳은 0.
  
  return 0;

}




%p를 쓰면 000000FF로 출력된다.

%08x = 000000ff로 출력된다.이것을 보아 %08X를 하면 %p와 같은 값이 나온다고 알 수 있다.

08에 8은 여덟자리를 나타내고 앞에0은 숫자가 없는곳은 0으로 표현한다.





#include
 <stdio.h>
int main()
{
  int a =123;
  
  printf("*1234567890*\n");
  printf("*%5d*\n", a);
  printf("*%7d*\n", a);
  
  
  return 0;
}





%5d와 %7d.

%5d는 5자리까지 표현. -를 붙이면 *123__*로 된다.(__는 보여주기 위한 것.)

%7d는 7자리까지 표현 *____123*, %-7d는 *123____*이 나온다.



#include <stdio.h>
int main()
{
  int num;
  char ch;
  float fnum;
  
  printf("Please enter integer, character\n, floating poinber number : ");
  scanf("%d %c %f"&num, &ch, &fnum);
  printf("You typed na integer : %5d\n", num);
  printf("You typed na integer : %5c\n", ch);
  printf("You typed na integer : %9.2f\n", fnum);
  
  return 0;
}




제어문 - 실행순서를 정하는 문.

원래는 프로그램은 위에서 아래로 순차적으로 실행되어 최종값을 도출하나, 제어문에서는 그것을 반대로 하거나 중간에 있는 것을 뛰어넘고 실행할 수도 있다. 그래서 제어문이다.

복합문 : {}가 2세트 이상 들어가 있는 소스.(괄호의 줄을 맞춰서 작성한다. 그래야 분별이 쉽다.)

선택문 : if/if else/swich문 ....

반복문 : for/while/do -while.......


#include <stdio.h>
int main()
{
  if(1)
  printf("하이\n");
  if(0)
  printf("하이\n");  
  return 0;
}
if()의 가 참일 때 다음 프린트문이 실행되고 거짓일 때는 실행되지 않는다.
그래서 if(1) = 참이다. 괄호안에 1이면 참 0이면 거짓이다.
그래서 아래와 같이 if(1)아래 프린트문과 실행되고 if(0)은 실행되지 않는다.










복합문

#include <stdio.h>
int main()
{
  int a, b; //
  a = 15;
  {
    int a = 100// 새로 변수를 지정 100
    b=23;
    printf("a + b = %d and a - b =%d\n", a + b, a -b); //123, 77
  }
  printf("a + b = %d and a - b =%d\n", a + b, a -b);//중괄호를 벗어낫기 때문  
  return 0;
}
변수를 중복 지정 할 수 없지만, 복합문에 중괄호에는 지정이 가능.
그러나 중괄호안에서만 효과가 있다. a + b에서 새로선언한 100이 연산되어 값이 저장된다.
글래서 123. 77이 나온다.
그러나 }중괄호 닫히는 순간, 바낕쪽 소스에는 int a = 100; 선언은 효과가 없다. 그래서 제일 위에
선언한 int a; , a = 5;가 저장되어 출력값 38, -8이 나온다.



참고

미정값 = 값은 있지만,불명확한 값 (일명, 쓰레기값)

cpu와 메모리

int num = 100;

num = num - 5;

num = num + 5;

num = num + 1;.........

printf("...\n",?);

있다고 가정하자. 여기서 cpu를 다시보자.

cpu의 주요 3대기능이 arithmatic(산술), cu(제어), reg(저장)이 있다. 위에서 int num = 100;은 메모리의int의 넘이라는 미정값이 저장된다.  그리고 100이라는 숫자가 num에 저장되어 메모리의 초기화가 된다. 이때 cpu에도 저장을 하는 역할을 reg가 담당한다. 그리고 num이 -5를 연산하는데 이 때의 역할을 alu가 담당한다. 그리고 cpu가 메모리에 보내는것을 cu가 제어한다.

자 그럼 cpu와 메모리의 저장되는 형태, 순서를 정리해보자.

최초의 int num은 메모리에 기억(미정값)

그리고 = 100;에 의해 초기화.

cpu에도 초기환 된값을 저장되어있다(reg)

다음 -5;를 연산하는데 일단 cpu가 이 연산한 값95를 가지고 있다. 그러나 메모리에 보내지 않고 그대로 cpu에 남아서 연산처리 한다. 이 연산처리를 프린트문 바로 윗줄까지 cpu의 저장한 다음에 비로소 최종출력값만 메모리에 보내게 된다. 즉, 최종출력을 하기전에 cpu가 연산하여 저장하는 값을 캐시(chache)라고 한다. 

cpu가 캐쉬를 반복하여 한계에 다다른면, 제일 오래된 캐쉬값부터 지우고 새로운 값을 저장해 나간다. 위에 예에서는 가장 먼저 저장 되는 캐쉬는 95이다. num =num -5;에서 연산되 95이다. 지금 당장에는 문제가 되지 않는다. 그러나 나중에는 문제가 발생한다. 지금단계에서는 개념만 이해하자.




<!--[endif]-->

posted by 송시혁

 

아스키코드 = (ASCII CODE)

American Standard Code for Information Interchange의 약자.

아스키코드 = 1바이트

다른 문자를 넣기 위해 확장 아스키코드 = 유니코드

0~7까지인 아스키코드에서 한 자리를 넘어선다.

그래서 한글을 비롯한 한문은 한글자당 2바이트.

영문 = 1바이트

한글 = 2바이트

아스키코드 참고.0~ 31은 제어 문자. 32~부터 출력.

32는 띄어쓰기(space bar)

아스키코드와 숫자

 

#include <stdio.h>
int main()
{
  char ch;
  
  printf("Please enter any character:");
  scanf("%c"&ch);
  printf("The ASCII code for characer %lc is %3d.\n", ch, ch);
  
  ch = '1' + '1';
  printf("The ASCII code for characer %lc is %3d.\n", ch, ch);
  
  return 0;
}

 

 

 아래 출력을 보면 49와 98이 나왔다. 이것을 비교해보자.

 

위의 printf 문에는 아무것도 하지 않고 변수만 지정한다. 이경우 화면상에 1을 치면 49가 나온다. 1의 아스키 코드번호가 %c에 의해 출력된다.

그러나 밑에 변수 ch = '1' + '1';은 98이다. '1'은 1의 아스키코드 값을 갖는다. 1의 아스키 코드값은 49이다. 그래서 변수에서 49 + 49가 되어 98이 출력이 된다.

1은 아스키코드도 되며, 숫자 1도 가능하다.

pdf표 참고.

 

escape sequence

 

 

#include <stdio.h>
int main()
{
  char ch;
  ch = 7;
  
  printf("%c", ch);
  return 0;
}

다음은 escape sequence를 활용한 프로그램이다. 위의 소스인 7번은 경보소리 

bell 이라는 것을 알 수 있다.                                   

escape sequence 표를 참고해서 실행해본다.

 

 

 아래 두 가지 소스를 짰다.

#include <stdio.h>
int main()
{
  char ch;
  ch = 92;
  
  printf("%c", ch);
  return 0;
}


변수에 번호를 넣는 방법

#include <stdio.h>
int main()
{
  char ch;
  ch = 7;
  
  printf("\\", ch);
  return 0;
}

프린트문에 직접 \\를 넣는 방법.

출력은 같다. 여기서 ch = 7; 은 신경안써도 된다. 7은 앞에 말했듯이 경보소리이나,

지금여기에서는 린트문에 %가 아닌 \\를 두개었다.

 

 

 

 

 

아래그림을 표와 비교해보자.

문문자열과
#include <stdio.h>
int main()
{
  printf("10진수 65: %c\n"65 ); // A 문자
  printf("16진수 40: \x40\n"); // @ 문자
  printf("8진수 73: \073\n"); // 세미 콜론
  printf("백슬래쉬 \\, 작은 따옴표 \', 큰 따옴표\"\n");
  printf("2 bell sound \a\a\n");
  
  
  return 0;
}

  

 

 

 

이 출력화면을 이해하려면 아스키코드를 보고 비교해봐야 한다. 일단, 

깊게 파고들지 말고 대충 이런형태로 출력이 되는 것을 이해하자.

 

문자열과 문자배열.

\0null이 뒤에 뭍으면 문자열이다. 다음은 "This is a string"이 메모리 형태로 저장된 그림이다.

\0이 실제로 있지만, 컴퓨터가 생략하여 실제 화면에서는 나타나지 않는다.

 어차피 \0은 없다, 공백문자이다.

'a'와  "a"의 메모리를 비교하면 'a' = a

"a" = a\0이 된다. -> \0이 생략되어 있다. 어쨌든 문자열이다.
  

문자배열의 선언 프로그램.

#include <stdio.h>
int main()
{
  char word[30]; /*문자배열의 선언 */
  
  printf("Please enter anything: ");
  scanf("%s", word);
  printf("%s, this is what you typed.\n", word);
  
  return 0;
  
  
  
}

word[30] = [30]은 30개의 공간을 만들어낸다. 제일 word[0]이 처음이고 

맨 마지막이 word[29]까지이다. 저기에서 a b를 입력하였다. 

a를 띄우고 b를 쓴다면, b는 출력되지 않는다. 즉, b는 저장되지 않느다.

메모리 주소로 표현하면, a\0이 저장된다. word[0]자리에 a가 들어가고 

word[1] \0에 들어간다.


\0은 공백이므로 a만 출력된다. 그리고 %s의 주목. string의 약자로 

%c가 한 문자만 받는데 비해 %s는 여러개의 문자를 받을 수 있다. 

그래서 문자열 형수정자라고 생각하면 된다.

scanf함수에서 문자열은 &를 쓰지 않는다.

 

문자배열의 다른 예제. 이 예제를 보고 다시 이해하자!

 

 

#include <stdio.h>
int main()
{
  char word[30]; /*문자배열의 선언 */
  
  printf("Please enter anything: ");
  scanf("%s", word);
  printf("%s, this is what you typed.\n", word);
  printf("%c\n", word[0]);
  printf("%c\n", word[1]);
  printf("%c\n", word[2]);
  printf("%c\n", word[3]);
  printf("%d\n", word[4]);
  return 0;
  
  
}

 

word[0] ,word[1],..... 각각의 자리에 t, s,....가 저장되어 

출력한다는 것을 알 수 있다.

word[4]자리에는 \0공백이 메모리에 저장되어 있으나, 화면에 출력되지 않는다.

글새서 %c로는 아무것도 나타나지 않는다. %d로 출력하여 0이 나타난다. 이것은

이자리에 공백문자 \0이 있다고 보여주기 위함이다.

연산자.

 

순서대로 우선순위이다.

가장 최고 높은 놈은 ()이다.

 

1(상수) +(연산자) num(변수); = 표현식.

단항연산자 : 1개의 항. 예) -1, a =1 단항이 아님.항이 2개.

산술연산자.

5/3 =1...... 2

%=2 나머지

/ = 1 몫

5칙연산자 중의 %와 /차이점 보기.

#include <stdio.h>
int main()
{  
  char cnum1;
  char cnum2;
  cnum1 = 100%3// '%'는 나머지
  cnum2 = 100/3// '/'는 몫
  printf("나머지와 몫은 : %d %d\n", cnum1, cnum2);
  printf("나머지는 : %d\n", cnum1);
  printf("몫은 : %d\n", cnum2);
  return 0;
}

 

위의 연산자의 숫자를 7 / 5로 바꾸어 보자. 그러면 소수는 계산이 안되고

정수만 출력될 것이다.

소수점을 출력하기 위해서는 변수 실수형인 float을 지정한다.

*두개의 연산자의 자료형인 다른 경우

char num;

int num1;

num + num1 이라면 num이 원래는char 선언되어 1바이트크기를 가지나 

num1이라는 int4바이트의 우선순위의 의해서

num도 정수형으로 된다.

int, float

inum + fnum

inum = 실수형으로 변한다.

연산의 우선순위를 잘 봐야한다.


 

비교연산자 




cnum 3<5 = 1. 

3이 5보다 작다는 것은 참이다. 참이면 1. 즉, 3<5는 이 자체가 1의 값을 가진다. 거짓이면 0이다.

cnum 3<=3;이면 3=3은 같기 때문에 참의 값이 된다.1

'='는 반드시 오른쪽에 위치한다.

c에서 =<쓰면 컴파일시 오류가 뜬다!!!

cnum ==3 해석하면 cnum와 3이 같으냐?라고 묻는것이다. 같으면 참이고 다르면 거짓.

5==3; 이라면 거짓이라 0의 값을 갖는다.

!= 같지않다. 5!=3은 같지 않기 때문에 참이 된다. 굉장히 특이한 놈ㅋ




논리 연산자



&& and &(주소), &(비트논리), &&(논리)

|| or

! not

char cnum;

cnum = 1&&1; 같으니 참

cnum -100&&30은 논리 연산자에서 0이 아니면 1로 간주한다. c문법에서는!!!

그래서 -100 = 1 30 = 1이므로 둘다 1로 간주하여 참이된다.

| = shift + \누르면 된다.

 

(x < 10)&&(y = 5); 해석하기 x=5라고 가정.

x < 10에서 5 < 10이기 때문에 참이 된다. 그래서 x < 10자체는 1이된다.

y =5 이므로 x의 값과 같다. 따라서 참이 된다. y = 100;이라고해도 (y =5)에서 5가 y에 대입되어 영향을 미치지 못한다.

 



 

#include <stdio.h>
int main()
{  
  int number;
  scanf("%d"&number);
  printf("Is number less than 10? %3d\n", number < 10);
  
  printf("Is number not equal to 10? %3d\n", number != 10);
  return 0;
}

위 프로그램을 보면,number < 10은  10보다 작으면 참이 됨고,

아래 프린트문 10이 아니면 참이 된다.

역시 scanf문에서 조건을 만족시키는  값을 지정해주면 참값이 출력된다.

논리연산자&&(and), ||(or), !(not)

#include <stdio.H>
int main()
{
  char cnum;
  cnum = -100 &&30;
  printf("%d\n", cnum);
  
  cnum = 0||0;
  printf("%d\n", cnum);

  cnum = !0;
  printf("%d\n", cnum);
}
  

 위에서 언급했듯이 첫번째 출력은 둘 다 1이므로 1이되고 두번째 출력은 0

은 0이으로 0이된다.

or는 하나만 1이라도 참의 값이 나온다. 세번째 출력은 0이를 부정하는

 부정논리이므로 0이 아닌 1이된다.

 

 

 

 

#include <stdio.h>

int main()
{
  char cNum;
  char cNum2;
  cNum = 100;
  cNum2 = ++cNum;
  
  ++cNum; //
  cNum++;
  cNum = cNum +1;
  printf("%d\n", cNum);  
  
  --cNum;
  cNum--;
  cNum = cNum -1;
  
  printf("%d\n%d\n", cNum, cNum2);
  

  cNum2 = cNum++;
  printf("%d\n%d\n", cNum, cNum2);
  return 0;
}

 위의 소스를 차례대로 해석해보자.

 

cNum 100이 저장되는 것은 알 수있고 ++cNum이 101이 되어 cNum2에 저장된다

그리고 다시 ++cNum에 저장되고 cNum = cNum +1;에

각각 1이 저장되어 104가 출력이 된다.

다시 -- 하여 되돌아온다는 것을 알 수 있다. cNum2 = cNum++;위까지

 cNum, cNum2가 각각 101의 값으로 저장되어있다.

변수 ++cNum, cNum++ 다음문법에서 차이를 보인다.

cNum2 = ++cNum;인 경우 ++cNum이 우선순위가 되어 ++cNum이

먼저 계산되고 cNum2에 대입된다. 그러나 cnum2= cnum ++;

이부분에서 우선순위가 갈린다. 

cnum2에 cnum의 값이 먼저 들어가서 101이 출력되고 다음에 cnum이 ++이되어

1이 더해져 102가 된다.

 이것이 뒤에 변수앞에 ++가 변수뒤 ++의 미묘한 차이이다.




#include <stdio.h>
int main()
{
  int cnum;
  int cnum2;
  cnum = 100;
  cnum2 = ++cnum;
  
  ++cnum;
  cnum++;
  cnum = cnum + 1;
  printf("%d %d\n", cnum, cnum2);
  
  --cnum; //103
  cnum--; //102
  cnum2 = cnum-1// cnum = 102, cnum2 = 101
  
  printf("%d %d\n", cnum, cnum2);
  return 0;
}

 


자 이번에는 좀 다른게 cnum2 = cnum -1;은 cnum2 = --cnum;와는 달리 cnum-1을

연산한 값이 나온다. 그래서 출력값이 다르게 나온다.


  

           


posted by 송시혁

#include <stdio.h>
int main()
{
  int num;
  num = 2147483647;
  num = num + 2;
  printf("양의 최대값보다 + 2가 큰 값은 %d.\n", num);
  num = num - 2;
  printf(" 양의 최대값 %d.\n", num);
  return 0;
}

 

실행 출력값이 -2147483647 첫번째 줄

2147183647 두번째 줄로 출력된다.

정수 자료형인 int에 최대값은 0에서 429496729775이다.

이것을 반으로 나누어 정수로 생각했을 때는 양의 정수 0~ 2147483645

음의 정수 2147183648 ~ 4294967295이다.

수직선이 있다 생각하고 음수를  나열하면 제일 왼쪽 끝에서

2147183648/       2147183649     /  2147183650....등으로 나열된다.  이것은

(-2147183648)     (-2147183647)     (-2147183646) 이된다.

따라서 2147183647이가 num = num +2;에서 숫자로는 2147183649가 된다

음수로 -2147183647 이된다. 그리고 밑에 프린트문은 다시 -2를 하니 되돌아 온다.

 

scanf 프로그램

scanf는 키보드로부터 데이터를 입력을 받기 위한 함수.

scanf 형식

scanf("내용", 여기까지는 printf문과 동일.(단, 대행문자 \n은 쓰면 안됨.)

, 뒤에 &과 변수가 붙는다. & (and, 앤 퍼세트(%)라고 읽는다.)

scanf("내용", & 변수나 상수); 이것이 scanf의 형식

아래 소스를 보자.

#include <stdio.h>
int main()
{
  int number; // number 변수 지정
  printf("Please enter a number :"); // 아래화면 내용 참고
  scanf("%d"&number);  // 정수를 입력하기 위해 %d를 사용.
  printf("The number you typed is %d.\n", number); //최종화면 출력.
  return 0;
}



 

출력화면은 100을 입력하자 그대로 100이 나오도록 되어있다. 처음에 실행시키면 , 아무것도 안뜨다가 100을 입력하면 Please enter a number : 100이 뜬다.

 

 

#include <stdio.h>
int main()
{
  int number;
  printf("Please enter a number :");
  scanf("%d"&number);
  printf("The number you typed is %x.\n", number);
  return 0;
}

이번에는 프린트문에 %x를 썼다. scanf에서는 정수로 키보드를 치지만, 마지막 출력화면에는 16진수로 받는 형태의 소스이다. 10진수를 16진수로 빨리 알고 싶다면 유용한 소스이다. 이 방법으로 계산기를 만든다. ㄷㄷ;(어렵다 ㅜㅜ)

 

 

 

 

 

연산자 sizeof

sizeof는 printf, scanf와 비슷하게 생겨서 함수라고 착각할 수 있지만, 연산자이다. 다음 소스를 보면서 sizeof를 이해하자.

 

#include <stdio.h>
int main()
{  
  printf("char의  크기는 %dbyte입니다.\n"sizeof(char));
  printf("short의  크기는 %dbyte입니다.\n"sizeof(short));
  printf("int의  크기는 %dbyte입니다.\n"sizeof(int));
  printf("long의  크기는 %dbyte입니다.\n"sizeof(long));  
  return 0;
}


저번시간에 배웠던 자료형인 char, short, int 그리고 long이 추가되었다. 자료형의 바이트크기는 CPU에 따라 조금씩 다르다. 어쨌든 내가 배우는 프로그램에서는 각각 1, 2, 4, 4의 바이트의 크기를 갖는다.

char ≤ short ≤ int ≤ long

1           2       4        4

 

각가의 바이트 크기에 따라 출력이 된다.

 

 

#include <stdio.h>
int main()
{
  int x, y;
  x=2;
  y = x + 5;
  
  //자료형의 경우
  printf("The size of int is %3d bytes.\n"sizeof (int));
  printf("The size of int is %3d bytes.\n"sizeof (short));
  printf("The size of int is %3d bytes.\n"sizeof (long));

  //변수의 경우
  printf("The size of x is %3d bytes.\n"sizeof x);

  //수식의 경우
  printf("The size of (x + 2) is %3d bytes.\n"sizeof (x + 2));
  return 0;
}

소스에서 sizeof x, sizeof (x +2) 가 있다. 이것을 주목하고 아래그림을 보자.

sizeof(int), sizeof(short), sizeof(long)는 제대로 4, 2, 4로 출력이 되었다.

그런데 sizeof(x), sizeof(x + 2)는 4바이트로 나온다. 위에서 x는 int x;라고 선언되어있다. 그래서

4바이트가 나온다. int니깐!!!! 당연히 char나 short로 선언하면, 다른 바이트의 크기가 출력된다.

이처럼 sizeof연산자는 각각의 자료형의 대한 바이트크기를 표현하는데 쓰인다.

 여기서 하나 더 언급하자면, 위의 수식의 경우 주목. 다른것은 sizeof다음에 ()가 있는데 변수를 적을 때는 ()없는 것을 알 수 있다. 저것을 주목하고 오류없이 구성해야 한다.

 

 아래소스들은 참고.

#include <stdio.h>
int main()
{
  unsigned int num1 = 67U;
  unsigned long int num2 = 89UL;
  
  printf("5%d: size of 67U is %3d byte\n", num1, sizeof(67U));
  printf("5%d: size of 89UL is %3d byte\n", num2, sizeof(89UL));
  return 0;
}

 



 

#include <stdio.h>
int main()
{
  
  int inum = 23;
  short snum = 23;
  
  
  printf("The size of int 23 is %3d bytes.\n"sizeof(inum));
  printf("The size of int 23 is %3d bytes.\n"sizeof(snum));
  return 0;

}

  
 


 
  
  

 형수정자 - 타입을 수정하다

10진수 %d, 8진수%o, 16진수 %x를 아래소스를 보고 판단하자. 
  

#include <stdio.h>
int main()
{
  int number = 67; .// 일단 number를 67로 선언. 67의 각각 다른 진수로서 출력.
  
  //10진수, 8진수 , 16진수로 출력
  printf("The value of 67 in decimal is %3d.\n", number);
  printf("The value of 67 in octal is %3o.\n", number);
  printf("The value of 67 in hexa decimal is %3x.\n", number);

  // 8진수와 16진수를 10진수로 화면에 출력
  printf("The decimal value of 020 & 0x20 is %5d & %3d.\n"020,0x20);  
  return 0;
}

  

  

10진수 당연히 그대로

8진수 103

16진수 43

위의 마지막 프린트문에서는 8진수 20과 16진수 20을 각각의 10진수로 나타낸 프린트문. 바꾸고자하는 숫자앞에 숫자0을 붙이면, 8진수가 되고 0x는 16진수가 된다.

  
  
실수형.

실수형을 sizeof연산자를 써서 이해하기. 

 

 

#include <stdio.h>
int main()
{


printf("float %d\n", sizeof(float));
printf("double %d\n", sizeof(4.2)); //4.2는 double로 간주되어 8바이트



printf("long double %d\n", sizeof(long double));

return 0;
}

 

실수형 자료형인 double은 원래 sizeof를 써서 바이트 크기를 나타내면 위의 그림과 같이 8byte이다. 그러나 아래 그림과 같이 4.2뒤에 f를 붙여주면 얘기는 달라진다.

  
  
#include <stdio.h>
int main()
{  
  
  
  printf("float %d\n"sizeof(float));
  printf("double %d\n"sizeof(4.2f)); //4.2는 double로 간주되어 8바이트
                                       //   그러나 뒤에 f가 붙어서 4바이트.


  printf("long double %d\n"sizeof(long double));
  
  return 0;
}
 
  
  
  




#include <stdio.h>
int main()
{
  float fnumber = 45000.67;
  printf("%f\n", fnumber);
  printf("%9.4f\n", fnumber); // 9자리 소수포함하여 나타내고
  printf("%e\n",fnumber);     // 소수점 앞쪽으로 4칸이동.
  printf("[%3d]\n"7);
  printf("[%-3d]\n"7);
  
  return 0;
}

  
45000.671875가 45000.672로 표현되었다. 뒤에 875가 반올림 되었다는 소리인데, 9.4가 전체 9자리를 나타내고 소수점을 포함하여 4자리를 나타낸다. 45000.672

%e = 45000.671875에서 소수점을 ???(잘몰라서 나중에 올리겠음)

[%3d] = 오른쪽으로 3번째 위치 = [_ _ 7]

[-%3d] = 왼쪽으로 3번째 위치 = [7--]





  
  


 

 다음은 아래소스를 통해서 %d와 %u를 알아본다.


#include <stdio.h>
int main()
{
  unsigned int uiNumber;
  uiNumber = -ffffffff;
  printf("%d\n", uiNumber); // unsigned 인식못함.
  printf("%u\n", uiNumber); // %u를 사용하여 제대로 출력.
  return 0;
}

 

위의 예제에선 unsigned int로 자료가 저장 되었더라도 출력형식을 이에 맞춰 %u로 하지 않으면 잘못된 결과를 낼 수 있다는 것을 확인 할 수 있다.


%u는 unsigned int라는 뜻이다 %d가 -ffffffff를 인식하지 못하고 signed int 출력화면에 나타낸다.


 

  
  

  
  

 

 

TIP

short A; 변수를 선언했다 가정.

A = -1이라고 선언하면 short의 최대범위 숫자가 나온다. 이것은 저번에 배운 보수법과 부호비트를 이해하면 알 수 있다. 나머지 int, long, char또한 마찬가지이다.

 문자상  수 char, 형수정자%c 아래그림에서 -1을 썼다.

#include <stdio.h>
int main()
{
unsigned int uiNumber;
uiNumber = -1;
printf("%d\n", uiNumber); // unsigned 인식못함.
printf("%u\n", uiNumber); // %u를 사용하여 제대로 출력.
return 0;
}

 

 

 

 

 

 
  

 

 


 

  
  

  
  

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

char = 문자상수. 그러나 따지고 보면 정수. 그이유는 아래소스와 출력을 참고하자.



#include <stdio.h>
int main()
{
char cNumber;
cNumber = 'z'; //문자상수(숫자), z의 폰트번호 122
printf("%d\n", cNumber);
printf("%c\n", 122);
printf("%c%c%c\n", 122, 32 ,122);
return 0;
}

 출력화면은 없지만, 대강 출력화면에 나타나는 수는

122

z, ...., z가 나온다. 이것은 ,ASCII코드에서 z가 122이기 때문이다.

도스화면에서 alt키를 누른 상태로 122번을 입력하고 손을 떼면

실제로 z가 나온다. 이것 때문에 사실상 char는 정수라고 생각한다.

다시 말하면, 컴퓨터의 문자는 ASCII코드 숫자와 연결이 되어있다.

 

 

 아래그림은 문자 a 와 b를 출력하기 위한 프로그램다.

#include <stdio.h>
int main()
{
char cNumber;
cNumber = 'a';
printf("%d : %c\n", cNumber, cNumber);

cNumber = cNumber + 1;
printf("%d : %c\n", cNumber, cNumber);
}

 

아래 그림과 같이  이것을 이런식으로 반복해서 소스를 짜면 알파벳 a~ z까지 만들 수 있다.

필자는 잘못복사하여 오류가 나서 시간관계상 z까지 못하였다. ㅜㅜ

#include <stdio.h>
int main()
{
char cNumber;
cNumber = 'a';
printf("%d : %c\n", cNumber, cNumber);

cNumber = cNumber + 1;
printf("%d : %c\n", cNumber, cNumber);

cNumber = cNumber + 1;
printf("%d : %c\n", cNumber, cNumber);


printf("%d : %c\n", cNumber, cNumber);

cNumber = cNumber + 1;
printf("%d : %c\n", cNumber, cNumber);

cNumber = cNumber + 1;
printf("%d : %c\n", cNumber, cNumber);

cNmber = cNumber +1;
printf("%d : %c\n", cNumber, cNumber);

cNumber = cNumber + 1;
printf("%d : %c\n", cNumber, cNumber);

cNumber = cNumber + 1;
printf("%d : %c\n", cNumber, cNumber);


printf("%d : %c\n", cNumber, cNumber);

cNumber = cNumber + 1;
printf("%d : %c\n", cNumber, cNumber);

cNumber = cNumber + 1;
printf("%d : %c\n", cNumber, cNumber);


return 0;
}

 

posted by 송시혁

 

0 0 0 0 0 0 0 0 8비트 = 1바이트(byte)

0이라는 한 자리에 숫자0,1 두가지만 들어간다.(2진수)

따라서 8자리이므로 2의 8제곱 = 256

1바이트 = 8비트

여기에 들어가는 숫자의 가지수는 256가지

숫자는 0~255까지 들어간다.

*숫자 수

37~65 = 29가지

0 ~ 100 = 101가지

1 ~ 100 = 100가지

계산방법 65 - 37 +1= 29이 나온다. 아래 것도 동일하게 나온다.

 

 토큰

C언어 문장 하나하나를 나눌 수 있는 최소단위

ex) #include <stdio.h>

int main()

{

plrintf("~", );

return 0;

}

파란색 하나하나가 토큰이다. 참고로 printf("~",);에서 printf , ( , ", 내용, ", ), ; 이 하나하나 토큰 더 이상 나눌 수 없는 최소단위이다.

변수조건

1.영어 (처음글자), _(shift + -키)

2.함수이름 사용못함 - printf문등은 함수이름이라 사용못함.

3.예약어 금지(if, else....)

4.띄어쓰기 ex) int num ber; -> 보기와 같이 num ber처럼 띄어쓰기를 하면 안된다.

반드시 붙여서  int number;라고 선언해야 한다.

5.name_$ -> 변수는 숫자와 영어만 쓸 수 있다.

변수와 상수

number = 3;

number = 4;

여기서 3, 4는 변하지 않는 수 즉, 상수라고 한다. 위에서 number는 3을 지정하면 3이고, 4로 지정하면 4가 된다. 그래서 변할 수 있는 수이기 때문에 변수이다.

상수 = constant value

constant

다음에 예를 들어보겠다

3 = 4; 상수에 상수를 3과 4 둘 다 상수이다.

상수를 상수로 대입하는것은 C문법에서든, 우리가 알고 있는 수학에서든 있을 수 없는 일

4 = 4;

일반적인 생각은 4 = 4 틀리지 않다.

그러나 C에서는 이것 또한 받아들이지 않는다.

다음은 이것을 프로그램 해서 출력한 화면이다.

 

 

 

일부러 4 = 4; 를 짰다. 물론 프린트문을 쓰지 않았지만, 컴파일 하면 다음과 같은 에러가 발생한다.

 

 

 

 

에러 메시지를 해석해보자

위의 Microsoft ~    

      Copyright  ~

이것은 신경쓰지 말자!!! 광고이다. Microsoft사에서 ㅅㅂ 쓸데없는 것 땜에 어렵게 해놨네.

그리고 그림 참조. 그림에서 동그라미1번은 '=' 표시이다. 이것을 해석하면 = 양쪽 옆에 이상이 있다라고 에러를 표시하는 것이다. 위에서 4 = 4;문이 틀렸다. 그리고 다음 잘 보면 왼쪽이 틀렸다고 빨간글로 써놨다. 즉 4 =4; 왼쪽인 4가 잘못되었다. 이것으로 이 문장에서는 변수로 4는 쓸 수 없다.

그리고 left operand  - 왼쪽 연산자. 이것 또한 에러의 위치를 알려주는 뜻.

 

 

 

자 이번에는 정수형의 종류인 char, short, int에 대해서 알아보다.

알아보기 전에 저번에 정리한 컴퓨터의 양의 정수 ,음의 정수, 부호비트와 보수법의 관계에 대해 생각해보자.

 

 

 

 

 

이 네모가 1바이트. 즉 8비트형, 정수형 char는 1바이트형 바이트.

 

 

short는 2바이트 8비트가 2개.

 

 

 

 

int 4바이트가 되겠다. 8비트가 4개.

위의 그림에서 255는 그대로 출력이 되는것을 알 수 있다. 255는 8비트 최대의 숫자이다.

그러니깐 1111 1111을 10진수로 바꾸면 255 그래서 1바이트는 255가 출력되고 나머지도 마찬가지로 당연히 그대로 출력된다. 그러면 그것보다 훨씬 큰 300을 넣겠다.

 

 

short와 int부분은 그대로 300이다. 위의 계산기를 잘보라. 1 0010 1100은 자리수가 9자리이다. (300의 2진수) 아홉자리이기 때문에 8자리를 넘는 제일 앞부분은 1은  char에서는 인식을 못하고 0010 1100만 10진수로 바꾸어 44가 출력되어 나온다. 아래에 short나 int는 각각 2바이트 16자리 4바이트 32자리이기 때문에 그대로 출력된다.

아래그림은 16자리 최대값인 1111 1111 1111  1111을 나타낸거임.

 

 

위와 마찬가지로 1바이트 char는 최대값 1111 1111만 출력되어 255!

 

65535보다 1더 큰 65536으로 해본 결과이다.

이번에는 16자리수를 넘어 17자리수로 가기때문에 short문 또한 0이 된다.

 

 

 

마찬가지 뒤에 10만 출력되어 2가 나왔다.

 

이번부터는 unsigned를 정의 하지 않고 프로그램을 해보겠다!!1

여기서부터 진짜~~~~~~~ 헤갈린다.

 

                       0                            127  128                                  255

 

 8비트는 0~ 255까지 표현된다. 그러나 이것을 절반으로 쪼개어 왼쪽으로 음수로 옮긴다.

 

 

 

     0                       127   128                   255

                                                                                                

위의 빨간줄 부분을 왼쪽으로 옮긴다.

 

 

                 128         129  130  131                 255  0      1  2   3                           255

                (-128)     -127  -126  (-125)          (-1)

이렇게된다. 이 그림을 이해하자 8비트에서 255가 -1이다.

 

자 그럼 아래 그림을 비교해보자.

 

 

 

 

위의 언급했듯이 unsigned를 쓴것이다.

그렇다면, 쓰지 않으면, 아래와 같은 그림이 된다.

 

 

 

위그림에서 출력값이 다르다라는것을 알 수 있다.

이것은 8비트에서는 0~255가 숫자범위이다. 하지만 위의 수평선 그려놓은 것을 잘봐라. 128~ 255는 -로 취급한다. 즉, unsigned를 썼을 때는 그냥 양의 정수로 출력이 된다. 이 unsinged는 양의 정수만 허용한다고 봐야한다.

그러나 unsigned를 허용하지 않을 때는 수평선대로-까지 고려한다. 따라서 0~127이넘는 숫자가 나올경우는 -로 출력이 되는 것이다.

 

 

 

 

이번엔 32자리.

 

 

 

posted by 송시혁

 

이 프로그램을 분석하면,

첫째줄 "the"는 화면에 출력되며,

둘째줄인 first는 위의 그림에서는 띄우지 않았으나 괄호(" 다음에 한 칸 띄어서 작성한다. 그러니깐 (" first~ 이다. 출력을 하면

아래 그림과 같이 the first 라고 띄어져 나온다.

그리고 C program은 한 칸 아래에서 나오게 되는데 그 이유는 뒤에 있는 \n때문이다.

\n은 줄을 바꾸다라는 의미이다. 그래서  C program이라는 글자가 한칸 아래에서 출력이 된다.

그런데  다음 printf문에서 C program뒤에 \n이 붙이지 않았다. 하지만 4번째 줄에서 ("다음에, 그러니까 example. 앞에 \n을 붙였기 때문에 아래 문장에서 출력이 된다. 그래서 아래와 같은 출력이 나온다.

\n은 한 문장으로 취급해야 한다. \이것만 쓰면 이것도 같이 출력된다!!

참고

 // 주석문

주석문이란 문장을 설명할 때 쓰는 것, // 입력하고 다음에 쓰는 문장은 컴파일 되지 않는다.

C언어 교재에는 프로그램을 설명을 하기 때문에 주석문을 많이 볼 수 있다.

 

 

 

 

 

정수형 변수, %d,%x, %X를 다루는 프로그램.

 

 

이번에는 %d와 %x를 알아보겠다.

%d는 정수형을 받는 연산자이다. 연산자는 나중에 배우니 여기에서는 따로 설명하지 않겠다. 그냥 %d가 정수를 대신해서 받아서 화면에 볼 수 있게 나온다고 할 수 있다. 위의 그림에서 int number; 를 선언하였다. int는 정수형 변수이다. 여기서, 변수란 어떠한 값을 저장하는 메모리내에 저장장소라고 정의 되어있다.

int는 정수 integer의 약자이다. 이것을 선언해야 정수 값을 넣을 수 있다.

즉, int number;는 정수를 number에 넣겠다는 뜻이 된다. 당연히 int a, int test등....

여러가지 문자로 반환할 수 있다. 단, 조건이 있다. 위에서 사용하다시피 변수는 영어로 되어있다. 조건이 있기 때문이다.

변수조건

1. 영어

2.처음 글자가 '_' 나 영어가 되어야한다. 이 조건을 만족시키면 뒤에 숫자나 기호를 써도 된다.

예를 들어서 int 1;은 선언되지 않는다. 하지만, int _1;l이나 int a1등은 선언할 수 있다.

조건 2번이 그러한 말이다. 그러나 되도록이면 영어를 쓰는 것이 좋고 나중에 프로그램이 길어지면, 작성자 본인이 변수를 선언한 것이 어떤 것을 선언했는지 찾기 어려운 점이 많아 되도록이면, 알기 쉽게 단어를 사용한다. 예를 들어 합계 = sum,  int sum; 이런식으로 하는 것이 좋다.

3. 함수명은 사용 불가능.

 그 예로 printf문은 사용불가, 그 밖에 프로그램 소스시 다른 명령어와 중복되는 단어는 변수로 사용하지 않는 것이 좋다.

4. 예약어 사용 금지 (if, else...등)

그리고 number = 3; 오른쪽의 3을 number에 대입하겠다는 뜻이다.

그리고 2번째 줄을 보면 number대신에 13이라는 숫자를 넣었다. 필자는 int number =3; 선언문 때문에 혼돈하였다. 그러나 숫자를 써도 number와는 아무런 상관이 없다. 그대신에 정수형을 변환하는 연산자 반드시 %d는 있어야한다. 실수라면 당연히 실수형인 %f가 있어야 한다. 연산자는 아직 본격적으로 들어가지 않았으므로 다음에 자세히 정리하겠다.

 

%x는 헥스의 약자로서 16진수를 대신한다.

3번째 줄은 13을 16진수로 변환한 값이다. 그런데 그 다음줄에는 바로 대문자 D로 출력이 된다. %x는 소문자, %X는 대문자이기 때문에 출력도 대소문자에 맞게 나온다.

그 아래에 것도 숫자만 바꿨을 뿐 동일하게 출력된다.

 

 

 

 

 

다음 프로그램은  길이를 3으로 선언하여 정사각형 넓이를 계산한 값을 출력하는 프로그램이다.

 

 

 

마찬가지로 각각 length와 area를 정수형으로 선언한다.

그리고 길이를 3으로 대입시킨다.

area = 길이 * 길이(length * length)로 대입한다.

그러면 메모리에 int length, int area가 각각의 위치에 먼저 기억되고 다음 lengt에 3을 대입하고 area를 length * length 대입하게 된다. 그리고 나서 3을 대입하게 되며, 결국에는 9라는 값이 출력하게 된다.

 

 

 

 

 

다음은 원주율을 구하는 프로그램이다.

 

#define에 대해서 알아보자

#define문은 정의한다 라는 전처리 문이다. #include가 어떤 것을 포함하는 전처리 문이라면,

#defined은 어떤 수를 정의한다.

위의 #define PI 3.1416;은 PI는 3.1416이라고 완전히 못박아 놓은 것이다.

변수는 어떠한 값을 자유롭게 변할 수 있지만, 상수는 한 번 정하면 절대적이다.

예를들어 위에서 정의한 int number;는 number =3 ;이라고 대입시켜서 3이라고 할 수 있다.그러나  다음문장에 다시 number =4;라고 선언한 뒤, printf("~~", number);라고 명령문을 만들면 위에는 3이였으나, 지금 문장에는 4가 출력된다.

number =3;

printf("%d\n", number); -> 출력시 3

number =4;

printf("%d\n", number); -> 출력시 4

 

 

위의 프로그램을 잘보자. 변수 number =3;은 아래 printf문에 3을 출력한다.

그러나 아래에 다시 4라고 선언한뒤, 아래 printf문은 4라고 출력된다. 이렇듯 number는 상황에 따라 값을 주면, 출력을 달리 할 수 있다. 이것이 변수.

 

 아래그림 참고.

 

 

위의 그림에서 number = 3;선언뒤에 프린트문은 당연히 3이다. 그런데 나중에 number =4;라고 했는데 sum = 3 + 3;(결과값 6)만 출력이 되었다. 3이 넘버에 지정되고 섬에 계산되었는데 나중에 4라고 지정해도 8이 출력되지 않는다. 물론 프린트문 뒤에 sum 대신 number라고 쓰면, 4가 나온다.  하지만, sum은 그대로 6이다. 아래그림을 보자.

 

 

 

이 같은 경우는 넘버를 먼저 4로 지정하고 썸에 계산되어 8이 나왔다. 이처럼 변수 프로그램 작성시에는 무엇이 순서대로 메모리에 저장되는지 아는 것이 중요하다.

메모리에 변수가 선언되고 알맞은 위치에 저장된다.

그리고 3이 넘버에 저장되고 그 값을 갖는다.

다시 4를 선언하여 넘버에 저장된다.

마지막으로 그 4가 썸에 저장되어 비로서 8이 나온다.

위의 잘못된 예는 이 개념을 이해하지 못하여 6이 나온것이다.

 반대로 상수는 변하지 않는 값이다. #define PI 3.1416으로 선언하면 PI는 무조건 3.1416이다. PI를 PI =4;라고 선언해도 다른 수가 출력되지 않는다.  만약에 바꾸고 싶으면, #define PI 4.10으로 수정하면 프로그램 내에 PI는 4.10으로 된다. 이것은 프로그램을 구성시에 같은 숫자가 많이 들어갈 때 쓰면 용이하다. 암튼 이것이 상수와 변수의 차이이다.

 

float이라는 변수는 실수를 선언하는 실수형 변수이다. 프로그램을 보면 알겠지만 원주율 파이는 3.14XXXXX이므로 최종값이 소수점인 형태로 나올 수 밖에 없다. 그래서 실수형 변수인 float을 선언한다.

그리고 아래 프린트문은 위에 설명한 length와 area와  동일하다.

마지막 줄에 %7.2f는 원래 %f이다. 이것은 실수를 표현하는 것으로 %f 앞에 7.2가 붙었다.

이것은  실수를 전제 7자리까지 나타내고 그 중에 소수점 2째자리 까지만 표현하라는 의미이다.

 

 

 

 

 

아래 그림들을 비교해보자!!

 

 

위의 파일은 프로그램 소스이다.

 

 

이것은 어제 배운 순수C파일인 d.i파일이다. int main()위에 전처리문이 없어졌다는 것을 확인 할 수 있다. 즉 #define 또한 전처리문이다. 실제로 스샷위의 이상한 글자가 많이 적혀있다. 그러나 #include나 #define은 나타나지 않는다.

 

 

 

 

 

 

 

 

 

참고사항

C언어는 기본형식을 익히는것 또한 중요하다.

따라서 오늘 가장 기초적인 것을 했지만, 필자에게는 정말로 머리 아프다ㅜㅜ 형식을 익히기 위해 적겠음

#include <stdio.h> -> 전처리 include 에서 함수인 <stdio.h>를 가져온다. 실제로 C언어가 설치된 경로를 확인하면 include안에 <stdio.h>가 들어있는 것을 확인 할 수 있다. 전처리문을 가장 처음에 쓴다. 컴파일 4단계과정을 안다면, 쉽게 이해가능함.

그 다음은 함수 선언.

보통은 void main() 이나 int main()을 주로 쓴다. 이거 말고도 많은 함수가 있다. 전처리문 다음에 무조건 적이다. C 언어 새로운 버전 문법에서는 void보단 int가 많이 쓰인다.

다음 {

이 중괄호가 프로그램 작성 내용을 담는 시작의 괄호이다. 나중에 가장 밑에 }는 닫는 괄호.

어쨌든 { ~ }사이에 내용이 실제 프로그램 내용이 되겠다.

그리고 가장 많이 쓰는 프린트문

pritntf(" 내용\n", 변수);

위와 같이 프린트 명령어를 쓰고 (를 열어 "~"에 출력하고자 하는 내용을 적는다.

\n은 줄을 바꾸다. 출력시 보기가 좋다. 그리고 ,를 찍고 변수등을 뒤에 사용한다는 것을 알아두자. 2장에서 배울 연산자에서 다시 언급하겠음.

 

 

 

 

 

posted by 송시혁

C언어 기본 작성 방법

위에 보이는 경로에 내 문서- 수업(새 폴더 만들기) - C언어수업(새 폴더 만들기)- 날짜 (2013-03-05)

 

위의 경로를 복사하여 아래 그림과 같이 메모장 에 복사한다. 참고로 위의 main.c, main.exe, main.obj는 내가 프로그램을 완성시켜서 그런것이다. 처음 할 때는 없다!!

 

 

위에서 enter를 친다. 그렇게 되면 아래 그림처럼

 

 

 바로 생성한 파일의 경로에 저장할 수 있게 된다.

 

프로그램을 메모장에 작성한뒤 저장한다

 

main.c로 저장한다. 확장자 반드시 .c!!!!

 

 

 

아까 만들었던 폴더에 우클릭해서 프롬프트 실행한다. 아이콘에 우클릭 아님.

 

프롬프트에 cl main.c를 친다

잠시 기다리다가 글자가 나오다가 멈춘다

그리고 D:\내문서\C언어 수업\2013-03-15>라는 필자가 지정한 경로가 나오는데 여기에서 main이나 main.exe로 입력한다. tab키를 눌러도 된다!!

그러면 pritntf문에서 작성하였던 내용이 출력되는것을 확인 할 수 있다.

그리고 main.exe와 main.obj가 생성되는 것을 볼 수 있다. 참고로 위의 생성되어 있는 것은 먼저 실행해서 만들어 놓은 것을 스크린 샷 햇다. 처음부터 하려니 귀차니즘이 ㅎㅎ

 

자 이번엔 위의 그림에서 아이콘 3개를 보자!!! 그리고 아래에 추가된 아이콘들을 잘보자!!!

 

main.c와 main.asm파일이 추가 된것을 알 수 있다. 이 파일들을 만드는 특정한 명령어가 있다.

main.i= cl /P 파일명.c, cl 파일명.c /P

main.asm= cl /Fa 파일명.c, cl 파일명.c /FA

입력한다. 반드시 대소문자를 구분하며 띄어쓰기도 해야한다. 파일명이 main이므로 명령어 뒤에 main.c를 입력한다. 만약에 test.c라면 cl /P test.c라고 입력한다. 그러면 test.i라는 파일이 생성 될것이다.

그러면 위의 그림처럼 각각의 아이콘이 나온다.

처음에 보이지 않는 이유는 원래는 이 파일을 만든다. 그런데 컴파일 과정에서 이 두 개의 파일을 지우는데 대신에 temp라는 파일에 저장이 된다. 그러니깐 위의 경로상에서 보이지 않을 뿐이다. 위의 명령어로 파일을 생성한 것은 2개의 파일을 temp라는 파일에서 명령어로 강제로 복사하여 가져온 것이다.

 

 

자, 그럼 다음으로 이 두개의 파일을 열어 보겠다. 일단 main.i를 C프로그램으로 열어보겠다.

 

이렇게 뜬다. 스클롤을 내려서 가장 아래 부분으로 가면은

우리가 프로그램한 문장이 보인다. 그런데 #include <stdio.h>가 보이지 않는다. 위그림에서 보이는 빨간네모 위에 여러 글자가 보이는데 #include 가 전처리 되어 나온것이다. 그래서 .i를 순순 C파일이라고 한다.

그러면 main.asm은 메모장으로 열어보겠다

 

이런 화면이 나타난다. 위의 C프로그램으로 열었던 것보다 촘촘하게 글자가 붙어있다.이 asm파일은 순수 파일인 main.i를 어셈블리어로 바꾼 파일이다. 이 어셈블리를 완벽하게 다룬다면 C언어가 필요없다. 그러나 어셈블리를 모르므로....... 보기만 해도 머리가...

이것을 나중에 만든다던데 ㄷㄷ;

 

암튼 이제는 아래그림과 같이 main.c를 복사하여 사본파일을 뒤에 확장자 .dat로 바꾼다.

 

이것을 C언어 프로그램을 연결하던지 C언어 프로그램을 직접열고 드래그해서 끌어오면 다음과 같은 화면이 생성된다.

16진수 코드로 되어 있는 코드를 볼 수 있다. 제일 앞에 4D 5A를 마우스로 드래그 하면 오른쪽에 MZ로 해석이 된다. 이것은 main.exe 파일 고유의 000이다.

다음음 bmp파일과 jpg파일을 C언어로 연결한 모습이다. 당연히 확장자를 각각 .dat로 바꾼 뒤 연결한다.

 

bmp파일

 

 

 

jpg파일

 

이론 수업!!

ALU

CU

Register

Register에서 Alu로 명령을 하는데 이것을 프로그램이라고 부른다.

cpu안에 이 3대 구성요소가 존재하며, 이것을 통합하여 core라고 부른다

 

컴파일은 간단히 말해서 기계어 -> 컴퓨터 언어로 바꾸는 과정을 통틀어 컴

파일이라고 한다.

컴파일 과정을 살펴보자.

실행.exe <- 0101011101<- mov ax.bx <- ax=bx<- 프로그램.c

0101011101은 어셈블리어를 통합하여 기계어로 바꾸어 놓은 상태. 즉, 컴퓨터 언어로 바꾸어 놓은 상태이다.

mov ax.bx는 어셈블리어이다.

실행.exe는 기계어를 링크시켜서 만들어내 실행 파일. 우리 인간이 컴퓨터 화면으로 볼 수 있게 윈도우에 맞춰서 연결하는 것을 링크이며 이 프로그램을 링커라고 한다.

 

ax=bx 전처리된 순수한 파일.i이다. ax=bx, mov ax.bx, 0101011101은 다 똑같은 말이다. 그런데 그것을 순수 C파일, 어셈블리어, 목적파일인 기계어로 바꾸어진 형태로 서로가 달리 보인다. 여기서, 알 수 있는 사실은 우리가 0101011101처럼 기계어를 알면 C언어를 배울 필요가 없다. 그러나 0101011101을 다알기는 전문가가 아니면, 거의 불가능하므로 C언어를 통하혀 컴파일 하여 프로그램을 작성을 하는 것이다.

 

 

컴퓨터의 구조(미완성)

ppt 참고

 

컴퓨터 구성.ppt

 

posted by 송시혁

CPU 3대 구성요소

1.register

2.CU

3.ALU

*ALU+ = Arithmatic(산술)+ Logic(논리)+  Unit(단위)

*CU = Control(제어) + Unit(단위) 

 *register - 1. 메모리

                2. 제어(일부, CU의 일부기능)

# 전처리 언어 시작

처리 = process, 전처리 = preprocess

C언어 = 전처리 언어

#include = 포함하다(추가하다)

전처리 언어

<stdio.h> 빨간색 괄호는 경로(path)에 있는 stdio.h 함수

 

 

posted by 송시혁