초천재의블로그

제 13장 C언어의 핵심, 함수 - 3

 

 

 

● 변수의 범위 : 함수와 변수의 관계를 따 져보다.

 

 ▽  변수의 특성에 따른 분류
 
 - 지역변수 : 중괄호{ }  내에 선언된 변수(Local Varial)

 - 전역변수 : 함수내에 선언되지 않는 변수(Gloval Varial)

 - 정적변수 : 함수 내부, 외부 모두 선언가능(Static Varial)

 - 레지스터 변수 : 선언에 제한이 많이 따름(Register Varial)

 

 

 

● static변수

 - 함수내부 및 외부에 선언가능

 - 한번만 초기화 된다 : 전역변수의 특징을 가진다

 - 함수내부에서 선언될 경우 함수내에서만 접근 가능
   > 지역변수의 특징 static int a;

 

예제) ========================================================

 

#include <stdio.h>

 

void Fuc(void)
{                          // 한번만 초기화 되기때문에
 static int num = 0; // 2번째 호출부터 실행되지 않는다.
                          // num값은 0으로 한번만 초기화가 이루어진다.
 num++;   

 printf("%d \n", num);
}                       // 함수를 빠져나와도, num은
                        // 값을 유지하면서 소멸되지 않는다!
int main()
{
 int i;  

 for(i=0; i<5; i++)
  Fuc();

 return 0;
}

=============================================================

 

 

 

● register : cpu내의 가장가까운 기억장치(상당히 빠른 메모리)

 

 - 여유가 있는 메모리 공간은 아니다.(잘 사용하지 않는다)

 

 - regiter int b; // regiter 메모리공간에 변수를 선언한다.

 

 - 사용시, 많은 제약이 따른다

 

 

● 재귀 함수

 

 - 자기자신을 다시 호출하는 형태의 함수

 

 - 프로그램을 이용하기위해선 프로세서를 이해해야 한다.
   -> 컴퓨터 구조(H/W -> 운영체제)

   -> 운영체제 

 - 자기자신을 계속 호출하기때문에, 이해하기보다는

 

 - 코딩시 조금만 신경써서, 분석하며 작성하는게 좋다!

 

 - 하지만 스택오버플로우(메모리과다사용으로 인한 경고)를 조심한다.
 

예제 ) ==========================================================

 

#include <stdio.h>

 

void Print()
{
 printf("재귀함수 호출 \n");
 Print();                         // 자기자신을 다시 호출한다.
}                                  // 무한루프에 빠지게 된다.

int main()
{
 Print();
 return 0;
}

예제 )==========================================================

 

#include <stdio.h>

 

void Repeat(int n) // 함수선언 및 정의
{
 printf("재귀함수 호출\n");
 if(n==1)            // if문은 재귀함수를 빠져나가기 위한 조건
  return ;            // return문 용도 : 함수 빠져나오거나, 값을 반환할때 쓰임
 Repeat(n-1);    // n값은 1씩 감소하면서 호출해 나간다.
}                     // 결국 n값이 1이 되면 빠져나가게 되는 함수

int main()
{
 int a = 4;
 Repeat(a);      // 함수호출

 return 0;
}

// -> 핵심 :  무한 재귀호출을 위해서 탈출조건을 잘 구현해야함

※ 재귀함수의 대표적인 사례는 팩토리알 (factoral)계산
  n! = (n-1) * (n-2)......* 2 * 1
  5! = 5 * 4 * 3 * 2 * 1

예제 )==========================================================

 

#include <stdio.h>

int Fat(int n);

int main()
{
 int input;  

 printf("정수 하나 입력 : ");
 scanf("%d", &input);

 printf("%d! = %d \n", input, Fat(input));
 return 0;
}

int Fat(int n)
{

 if(n==0)                  // n값이 1이면 빠져나가게 한다.
  return 1;

 else
  return n*Fat(n-1); // Fat함수를 호출시 매개변수 값이
                             // 1씩 감소하면서 호출한다
}

제 11장 C언어의 핵심, 함수 - 1

 

 

 

● C언어로 만들어진 프로그램은 ?

    : 함수로 시작해서 함수로 끝나는 프로그래밍 언어

 

 - 중요도는 함수가 포인터가 상대적으로 높다.

 

 - 포인터는 활용하는데 정말 중요

 

 - 함수를 적절히 이용하는건 더 어렵게 걸린다.

 

 - 포인터를 얼마냐 잘 사용되느냐가 아닌

 

 - 함수를 어떻게 정하는건지 실력판단.

 

 - 좋은함수를 만들수 있어야한다.

 

 

 

● main()함수 다시보기

 

int main (void)
{

 // 함수몸체

}

1. 함수는 이름이 필요하다

 

(void)  : 입력의 형태

 

 (int)   : 출력의 형태(반환 혹은 리턴형)

 

{    }  : 함수의 몸체(함수의 기능)

 

 

2, 함수를 정의하는 이유

 

  - 모듈화(기능별로 분리)에 의한 프로그램의 질 향상

 

  - 유지 보수, 확장의 용이성
    ex) 프로그램을 바꿀때, 기능별로 순차적으로 수정이 가능

 

 - 문제를 분리하고,전체를 정복하라 (Divide and Conquer)

 

  - 체계적인 프로그래밍 가능

 

  - 코드 읽기의 효율성

 

 

3. 함수의 형태
 
int Sum(int a, int b) // int형을 return 할 Sum 이라는 이름의 함수
{                          // 변수 a, b로 받아준다.
 int sum = a+b;       // 연산값을 sum에 대입

 return sum;         // return : sum을 반환해라, 던져줘라
}

 

예제 ===============================================

 

#include <stdio.h>

 

int Sum(int a, int b) // 여기에 a = 10, b = 20
{
 int result = a+b;

 return result;            // result를 던진다.(뱉어낸다)
}

 

int main()
{
 int val;

 val = Sum(10, 20);// 뱉어낸 값을 받아서 val에 보관
 printf("val = %d \n", val);

 return 0;
}

 

// 함수가 리턴값은 어디로 넘어가는가?

// 리터형 함수는 어떤것들이 있는가?

 

 

4 다양한 형태의 함수

 

int Sum(int val)     // 전달인자, 리턴값 둘다 있다.
void Sum(int val)  // 전달인자는 있지만 리턴값이 없다.
int Sum()              // 전달인자는 없고, 리턴값은 있다.
void Sum(void)    // 전달인자, 리턴값 둘다 없다.

 

 

5. 함수 선언의 필요성

 

 - 컴파일러의 특성상, 함수는 호출되기전에 정의되야 한다.

 

 - 호출할 함수정의는 main함수 이전에 무조건 선언이 되야 한다.

 

 - 호출할 함수원형을 선언후, main()함수 밑에 선언도 가능

 

 - 컴파일은 위에서 아래의 순서대로 읽기때문에, 컴파일이 호출할 함수를 읽어야 한다.

예제 ===============================================

 

#include <stdio.h>

 

int Add(int a, int b);        // 더하기 함수선언
int Minus(int a1, int b1); // 빼기 함수선언
int Input();                    // 입력하는 함수선언
void Print(int k, int k1);  // 출력하는 함수선언
void Title();                  // 프로그램제목 함수선언

//-------------------------------------- 까지 함수 선언부분

int main()
{
 int num1, num2;
 int sum1, sum2;

 

 Title();                                // 제목함수호출

 

 num1 = Input();                    // Input함수를 호출하여, 결과값을 num1에 반환
 num2 = Input();                    // Input함수를 호출하여, 결과값을 num2에 반환

 

 sum1 = Add(num1, num2);    // Add(더하기)함수 호출하여 결과값을  sum1에 반환
 sum2 = Minus(num1, num2); // Minus(빼기)함수 호출하여 결과값을 sum2에 반환

 

 Print(sum1, sum2);              // 출력함수 호출

 return 0;                            // 0을 리턴한다.
}

//-------------------------------------- 부터 함수 정의부분

void Title()                         // Title 함수정의부분
{
 printf("  ▲                               ▲\n");
 printf("■ 함수를 이용한 프로그램 예제입니다 ■\n");
 printf("  ●                               ●\n");
}

 

int Add(int a, int b)             // Add 함수정의부분
{
 int result = a + b;
 return result;
}

 

int Minus(int a1, int b1)      // Minus 함수정의부분
{
 int result1 = a1 - b1;
 return result1;
}

 

int Input()                        // Input 함수정의부분
{
 int val;
 printf("값을 입력하세요 : ");
 scanf("%d", &val);

 return val;
}

 

void Print(int k, int k1)     // Print 함수정의부분
{
 printf("더한 결과 : %d \n", k);
 printf("빼기 결과 : %d \n", k1);
}

 

// 위(main함수 위)에는 함수를 선언한부분

// 밑(mani함수 밑)에는 선언한 함수를 정의한 부분이다

 

예제 ===============================================

// 함수 선언의 의미

#include <stdio.h>

 

int Large_Num(int a, int b); // 함수 선언부분

 

int main()
{
 int a = 10;
 int b = 12;

 int c = 3;
 int d = 2;

 

 printf("%d 와 %d중 큰 수는 %d \n", a, b, Large_Num(a, b));
 printf("%d 와 %d중 큰 수는 %d \n", c, d, Large_Num(c, d));

 

// printf의 인자값을 반환값이 존재하는 함수가 올수 있다

 

 return 0;
}

 

int Large_Num(int a, int b)  // 함수정의 부분, main 함수내의  변수 a,b와는 별개인 변수다
{
 if(a > b)
  return a;

 else
  return b;
}

 

// Tip !

// 한 함수내의 { } 안에 선언된 변수의 이름은 그 안에서만 효력이 발생한다.

// 다른 함수에 똑같은 이름의 변수가 있더라도, 영향을 받지 않지만,

// 프로그램의 가독성 및 혼란성을 피하기 위해서, 다른 변수를 넣어주는것이 좋다.

ex)

in Add()

{

int a;

}

 

int Add_1()

{

int a;

}

 

이둘의 a값은 컴파일의 혼란을 야기 시키지 않는다. 이름만 같을뿐, 서로 다른변수다.

 

 

 

int i = 2;          // i는 2부터 시작하니,
int j = 0;       

while(i<10)  // i가 10보다 작을때까지, 즉 9까지
{

j = 1;
while(j<10) // j는 10보다 작을때까지, 즉 9까지
{

printf("%d * %d = %d ", i, j , i*j); 
j++;

}

i++;  

int total = 0;
int val = 0;

do
{

printf("숫자 입력 ( 0 : quit) :");
scanf("%d", &val);
total+=val;

}
while(val!=0);
printf("Total : %d ", total);

system("PAUSE");
return 0;

int val ;
int i = 1;

printf("출력하고자 하는 구구단, 몇 단? :");
scanf("%d", &val);

do
{

printf("%d * %d = %d ", val, i, val*i);
i++;

}
while(i<10);

return 0;

int total = 0;
int i, n;

printf("0부터 n까지의 덧셈, n은? ");
scanf("%d", &n);

for(i=0; i<=n; i++) // i는 0부터시작해서 입력한 수 n보다 같거나 작을때까지
{                            // i는 1씩 증가

total += i;

}
printf("0부터 %d까지의 덧셈결과는 : %d", n, total);

system("PAUSE");
return 0;

float total = 0.0;
float input = 0.0;
int count = 0;

for(;input >=0.0;) // 이건 초기문, 증감문이 없다.

                       //  단, input값이 0.0보다 클때 라는 조건만 있따.
{

total += input; // 아
printf("양의 실수 입력(minus to quit) :");
scanf("%f", &input);
count++;

}

printf("지금까지의 평균 : %f ", total/count-1); // count는 한번더 +1을 하므로 -1을 해줌
return 0;

int i, j;

for(i=0; i<3; i++)
{

printf("현재 i 는 %d *** ", i);

for(j=0; j<2;j++)
{

printf("현재 j는 %d ", j);

}
i++;

}
system("PAUSE");
return 0;

● & : 비트단위 연산 AND
          ex) a & b

 : 오른쪽 왼쪽 둘다 true 일때 1을 반환
   -> 1 & 1 일때만 1을 반환

ex) 0 & 1 ==> 0
     0 & 0 ==> 0
     1 & 1 ==> 1

EX) ========================================

#include <stdio.h>

int main()
{
    int a = 5;   // 0000 0101
    int b = 20;  // 0001 0100

    int c = a & b;

    printf("AND 연산결과 : %d \n", c); // 결과 4
    system("PAUSE");

    return 0;
}

● | : 비트단위 연산 OR
   ex) a | b

 : 오른쪽 왼쪽 하나라도 true 일때 1을 반환
   -> 0 & 1 일때만 1을 반환

ex) 0 | 1 ==> 1
     0 | 0 ==> 0
     1 | 1 ==> 1

EX) ========================================

#include <stdio.h>

int main()
{
    int a = 5;   // 0000 0101
    int b = 20;  // 0001 0100

    int c = a | b;

    printf("OR 연산결과 : %d \n", c); // 결과 21
    system("PAUSE");

    return 0;
}


● ^ : 비트단위 연산 XOR
   ex) a ^ b

 : 두값이 서로 다를때 1을 반환
   -> 0 & 1 일때만 1을 반환

ex) 0 | 1 ==> 1
     0 | 0 ==> 0
     1 | 1 ==> 0

EX) ========================================

#include <stdio.h>

int main()
{
    int a = 5;   // 0000 0101
    int b = 20;  // 0001 0100

    int c = a ^ b ;

    printf("XOR 연산결과 : %d \n", c); // 결과 17
    system("PAUSE");

    return 0;
}

● ~ : 비트단위 연산 NOT
   ex) ~ a

 : 값을 반대로 나타낸다.
   -> 0은 1로, 1은 0으로 바뀐다.

ex) ~0  ==> 1
     ~1  ==> 0

EX) ========================================

#include <stdio.h>

int main()
{
    int a = 20;  // 0001 0100
   
    int c = ~a ; // 1110 1011

    printf("NOT 연산결과 : %d \n", c); // 결과 -21
    system("PAUSE");

    return 0;
}


● << : 비트단위 연산 왼쪽 쉬프트 연산

   ex)  a << b -> a의 비트들을 b칸씩 왼쪽으로 이동
         8 << 2 -> 8의 비트들을 왼쪽으로 2칸 이동

 : 8의 2인수 형태 : 0000 1000
   -> 1을 왼쪽으로 두칸 이동 : 0010 0000 ; 32

  ※ 부호비트 까지 밀려나기때문에 주의한다!

EX) ========================================


#include <stdio.h>

int main()
{
    int a = 8;


    int c = a << 2; // c = 32

    printf("%d의 << %d 만큼 비트연산한 결과 : %d \n", a, 2, c);
    system("PAUSE");

    return 0;
}

● >> : 비트단위 연산 오른쪽 쉬프트 연산

   ex)  a >> b -> a의 비트들을 b칸씩 왼쪽으로 이동
         8 >> 2 -> 8의 비트들을 오른쪽으로 2칸 이동

#include <stdio.h>

int main()
{
    int a = -8;


    int c = a >> 2; // c = -2

    printf("%d의 >> %d 만큼 비트연산한 결과 : %d \n", a, 2, c);
    system("PAUSE");

    return 0;
}



● 자료형(data type) ; 자료를 나타내는 형(type)

 - 선언할 변수의 특징을 나타내는 문자(키워드)

 - 1. 정수냐? 실수냐?에 대해서 나타냄
   > 미리 선언을 하는것

 - 2. 메모리를 몇 byte 할당받아서 나타낼건지?
   > 저장할 데이타의 메모리공간 할당



● 기본자료형

 - 기본적으로 제공이 되는 자료형
    ex) int, float, double, long형



● 사용자 정의 자료형

 - 사용자가 정의하는 자료형

 - ex) 구조체, 공용체, 클래스(C++)



● 기본자료형의 종류

 char       1 byte   
 short      2 byte
 int        4 byte
 (64비트 운영체제 : 8byte)

 long       4 byte
 float
 double
 long doulbe



● ANSI( 표준화된 문법제정) 99년도에 표준된 데이타표현

 - int가 4byte면 long은 4byte 이거나 그 이상이 되어야 함

 - 명확하지 않음 ;long(표준화되지 않았다고..)

 - long은 시스템에 따라 차이가 남(크기 : int <= long)
 
 - long double도 마찬가지로 인식을 한다.(long double >= double)



● n비트로 표현할수 있는 데이타 수

 = 2(n승);
  ex) 1byte : 2(8승) = 256가지의 데이타 표현 -> char형



● 자료형이 다양한 이유? ;

 -=> 데이타 표현방식이 다르기때문
   - 정/실수형 데이타를 표현하는 방식

 -=> 메모리 공간을 적절히 사용하기 위해서



● 자료형 선택의 기준

 - 정수형 데이터를 처리하는 경우
  --> 컴은 int 형 연산을 가장 빠르게 한다.

ex) 1000의 수를 char 형에 넣지 못한다
     => char 형은 최대 256까지 표현가능
     => int 형이 적절(2의32승)


● sizeof 연산자
 - 피연산자 메모리 크기를 반환
 
#include <stdio.h>

int main()
{
    int number = 5;
    printf("int 자료형의 크기 : %d \n", sizeof(number));
    printf("sizeof(int) ; %d \n", sizeof(int));
   
    system("PAUSE");
    return 0;
}

// 자료형 이름 (int) 는 괄호를 꼭 해줘야 한다. sizeof( int )
// 자료형 변수이름은 '()'괄호 생략 가능
// 그냥 괄호사용하는게 헷갈리지 않고 좋다.



● 자료형 선택

 - 정수형 데이타를 처리하는 경우
 
 - int가 내부적으로 연산을 가장 빠르게 한다.(정수표현)

 - char형 : 문자를 표현하기위한 자료형

 - float 형 : 소수이하 6자리까지 오차없이 처리 가능

 - double 형 : 소수이하 15자리까지 오차없이 처리 가능
   -> 정밀도가 얼마나 유지되나?

 => double에 대한 정밀도를 추구함!!   float은 정밀도 낮음


#include <stdio.h>

int main()
{
    float byun;
    float area;

    printf("정삼각형의 변입력 : ");
    scanf("%f", &byun);

    area = (byun * byun)/2;
    printf("정삼각형 넓이 : %f \n", area);
   
    system("PAUSE");
    return 0;
}
 
★ 메모리나 속도도 중요하지만 코딩시,
   프로그램은 얼마나 읽기 쉽게 작성을 하느냐?
   얼마나 코드를 유연성있게 작성을 하는가?   ★

상수는 일반적으로 대문자로 나타내어준다(관례)
초기화는 선언과 동시에 무조건 해주어야한다.



● unsinged 가 붙어서 달라지는 표현

 - 기본자료형앞에 unsinged 를 붙여주면  무조건 데이타가 양수가 된다.
   > 음수의 데이타표현 범위가 양수로 바뀌게 되
   > 양수의 데이타 표현을 기본자료형의 두배로 표현 가능

 - 하지만 데이타 크기 자체는 변함 잆다.
  ex) unsigned char;
      unsigned int ;

 - 단, 실수형 자료에는 적용 되지 않음.



● ASCII 코드를 이용한 문자표현
 
 - 컴퓨터는 내부적인 시스템은 2진수만 인식

 - 컴퓨터 자체는 문자, 그림, 소리 자료를 숫자로 변환해서

 - 2진수로 변환시켜서 저장

ex) A : 65, B : 66 C : 67
  => 컴퓨터와 사람과의 약속(컴퓨터는 문자를 이해못함)
  => ASCII 코드(ANSI : 미국표준협회에 의해 정의)
  => 아스키코드표 참고하세요


● ASCII코드 범위 : 0~127 이하
                    char 형 변수로 처리 가능!

문자의 표현 : (' ') 를 통해 표현
컴퓨터가 아스키코드값을 확인해서 문자를 숫자로 저장.

ex) char as = 'A';  // A 아스키 코드값 65
      char a = 'a'    // a 아스키 코드값 97 

#include <stdio.h>

int main()
{
    char A = 'A';
    char B = 'B';
    char C = 'C';
    char D = 68;

    printf("%d \n", A);
    printf("%d \n", B);
    printf("%d \n", C);
    printf("%d \n", D);
    printf("%c \n", D);
   
    system("PAUSE");
    return 0;
}             



● 리터럴(literal) 상수

 - 이름을 지니지 않는 상수
   ex) 일반숫자

int number = 1 + 2;

해석하자면...

 // 1과 2를 메모리상에 올리고
 // cpu가 메모리공간에 올라간, 1, 2를 불러들려 계산하고
 // 메모리공간에 등록한  number 에다가 연산결과를 저장한다.

char c = 'A'        // 문자상수
int  in = 10         // 정수상수
double  dou = 3.14; // 실수상수

float f = 3.14 // float f = 3.14f

3.14는 double 형(8byte)
float(4바이트) <= (8byte) // 메모리 손실 가능성

접미사를 이용한 상수의 표현
unsinged int
long
....



● 심볼릭(Symblic) 상수 ; 이름을 지니는 상수

const 를 이용한 상수화

ex) cosnt int MIN = 200; // const 키워드 사용
    MIN = 100; // 불가

    const in MAX;  // 변수자체가 쓰레기 값으로 초기화
    MAX = 100; // 불가