함수, 변수 범위, 재귀

연산자 = 계산
조건문 = 선택
반복문 = 반복

함수 = 코드를 기능별로 묶은 것
매개변수 = 함수에 전달하는 값
return = 함수가 결과를 돌려주는 것
변수 범위 = 변수를 사용할 수 있는 구역
재귀 = 함수가 자기 자신을 다시 호출하는 것

result = a + b;

int add(int a, int b) {
    return a + b;
}

result = add(3, 5);

함수 = 입력을 받아서 일을 하고 결과를 돌려주는 코드 묶음

f(x) = x + 1

int f(int x) {
    return x + 1;
}

int main(void) {
    // 더하기 코드
    // 빼기 코드
    // 곱하기 코드
    // 나누기 코드
    // 출력 코드
}

int add(int a, int b) { ... }
int sub(int a, int b) { ... }
int mul(int a, int b) { ... }
int div(int a, int b) { ... }

반환형 함수이름(매개변수) {
    실행할 문장;
    return 반환값;
}

int add(int a, int b) {
    int result;
    result = a + b;
    return result;
}

int result;

result = add(3, 5);

1. add 함수에게 3과 5를 전달합니다.
2. add 함수 안에서 3 + 5를 계산합니다.
3. 결과 8을 return합니다.
4. result 변수에 8이 저장됩니다.

#include <stdio.h>

int add(int a, int b) {
    return a + b;
}

int main(void) {
    int result;

    result = add(3, 5);

    printf("%d", result);

    return 0;
}

8

int add(int a, int b) {
    return a + b;
}

void hello(void) {
    printf("Hello");
}

hello();

#include <stdio.h>

void hello(void) {
    printf("Hello");
}

int main(void) {
    hello();
    return 0;
}

Hello

void hello(void)

받는 값도 없고, 돌려주는 값도 없는 함수

매개변수
인수

int add(int a, int b) {
    return a + b;
}

result = add(3, 5);

인수 = 실제로 넣는 값
매개변수 = 그 값을 받는 함수 안의 변수

#include <stdio.h>

int square(int x) {
    return x * x;
}

int main(void) {
    int a = 4;
    int result;

    result = square(a);

    printf("%d", result);

    return 0;
}

1. main 함수 시작
2. a에 4 저장
3. square(a) 호출
4. a의 값 4가 square 함수의 x로 전달
5. x * x 계산, 즉 4 * 4 = 16
6. return 16
7. result에 16 저장
8. 16 출력

16

#include <stdio.h>

int main(void) {
    int result;
    result = add(3, 5);
    printf("%d", result);
    return 0;
}

int add(int a, int b) {
    return a + b;
}

int add(int a, int b);

#include <stdio.h>

int add(int a, int b);

int main(void) {
    int result;
    result = add(3, 5);
    printf("%d", result);
    return 0;
}

int add(int a, int b) {
    return a + b;
}

int add(int a, int b);

선언 = 예고편
정의 = 본편

int add(int a, int b) {
    return a + b;
}

return a + b;

int test(void) {
    return 10;
    return 20;
}

void printPositive(int x) {
    if (x <= 0) {
        return;
    }

    printf("%d", x);
}

void 함수의 return = 함수 종료

#include <stdio.h>

void change(int x) {
    x = 100;
}

int main(void) {
    int a = 10;

    change(a);

    printf("%d", a);

    return 0;
}

10

a의 값 10이 change 함수의 x로 복사됩니다.
change 함수 안에서 x를 100으로 바꿉니다.
하지만 x는 복사본입니다.
main의 a는 그대로 10입니다.

함수 안에서 매개변수를 바꿔도 원래 변수는 바뀌지 않습니다.

#include <stdio.h>

void change(int *p) {
    *p = 100;
}

int main(void) {
    int a = 10;

    change(&a);

    printf("%d", a);

    return 0;
}

100

값만 넘기면 원본 안 바뀜
주소를 넘기면 원본 바꿀 수 있음

printf("Hello");
scanf("%d", &a);

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

int main(void) {
    double x = sqrt(16.0);

    printf("%f", x);

    return 0;
}

4.000000

void test(void) {
    int x = 10;
    printf("%d", x);
}

void test(void) {
    int x = 10;
}

int main(void) {
    printf("%d", x); // 오류
    return 0;
}

지역변수 = 선언된 블록 안에서만 살아 있음

int main(void) {
    if (1) {
        int x = 10;
        printf("%d", x);
    }

    printf("%d", x); // 오류

    return 0;
}

{ } 안에서 만든 변수는 보통 그 { } 안에서만 사용 가능

#include <stdio.h>

int global = 10;

void printGlobal(void) {
    printf("%d\n", global);
}

int main(void) {
    printGlobal();
    printf("%d", global);

    return 0;
}

10
10

전역변수 = 함수 바깥에 선언되어 여러 함수에서 사용 가능

#include <stdio.h>

int x = 100;

int main(void) {
    int x = 10;

    printf("%d", x);

    return 0;
}

10

가까운 지역변수가 우선

#include <stdio.h>

void count(void) {
    static int x = 0;
    x++;
    printf("%d ", x);
}

int main(void) {
    count();
    count();
    count();

    return 0;
}

1 2 3

첫 번째 count 호출: x = 0 → x++ → 1 출력
두 번째 count 호출: x는 이전 값 1 유지 → x++ → 2 출력
세 번째 count 호출: x는 이전 값 2 유지 → x++ → 3 출력

static 지역변수 = 범위는 지역변수처럼 함수 안, 수명은 프로그램 끝까지

#include <stdio.h>

int sSum(int count) {
    static int sTotal = 0;
    sTotal += count;
    return sTotal;
}

int main(void) {
    int count;
    int sTotal = 0;

    for (count = 1; count <= 10; count++) {
        sTotal = sSum(count);
    }

    printf("%d", sTotal);

    return 0;
}

55

register int i;

register 변수 = 빠른 접근을 위해 레지스터 사용을 요청하는 변수

int score = 100;

extern int score;

score라는 전역변수가 다른 파일 어딘가에 정의되어 있습니다.
나는 그것을 사용하겠습니다.

extern = 다른 파일의 전역변수를 참조할 때 사용

지역변수 = 안에서만
전역변수 = 밖에서 선언, 여러 함수에서
static = 값 유지
extern = 다른 파일 변수 참조
register = 빠른 저장 요청

void hello(void) {
    hello();
}

반환형 함수이름(매개변수) {
    if (종료 조건) {
        return 값;
    }

    return 자기자신(더 작은 문제);
}

5! = 5 × 4 × 3 × 2 × 1 = 120

n! = n × (n-1) × (n-2) × ... × 1

0! = 1
1! = 1

factorial(n) = n × factorial(n-1)
factorial(1) = 1

int factorial(int n) {
    if (n <= 1) {
        return 1;
    }

    return n * factorial(n - 1);
}

printf("%d", factorial(5));

factorial(5)
= 5 * factorial(4)
= 5 * 4 * factorial(3)
= 5 * 4 * 3 * factorial(2)
= 5 * 4 * 3 * 2 * factorial(1)
= 5 * 4 * 3 * 2 * 1
= 120

120

내려감: 5 → 4 → 3 → 2 → 1
올라옴: 1 → 2 → 6 → 24 → 120

factorial(5)
factorial(4)
factorial(3)
factorial(2)
factorial(1)

factorial(1) 종료
factorial(2) 종료
factorial(3) 종료
factorial(4) 종료
factorial(5) 종료

sum(n) = n + sum(n-1)
sum(1) = 1

int sum(int n) {
    if (n == 1) {
        return 1;
    }

    return n + sum(n - 1);
}

printf("%d", sum(5));

sum(5)
= 5 + sum(4)
= 5 + 4 + sum(3)
= 5 + 4 + 3 + sum(2)
= 5 + 4 + 3 + 2 + sum(1)
= 5 + 4 + 3 + 2 + 1
= 15

15

int rSum(int value) {
    int sum = 0;

    if (value != 10)
        sum += rSum(value + 1);
    else
        sum += value;

    return sum;
}

rSum(0);

if (value != 10)
    sum += rSum(value + 1);
else
    sum += value;

현재 value를 더하지 않습니다.

sum += value;

rSum(0) = rSum(1)
rSum(1) = rSum(2)
rSum(2) = rSum(3)
...
rSum(9) = rSum(10)
rSum(10) = 10

10

int rSum(int value) {
    if (value == 10) {
        return 10;
    }

    return value + rSum(value + 1);
}

rSum(0) = 0 + rSum(1)
rSum(1) = 1 + rSum(2)
...
rSum(10) = 10

0 + 1 + 2 + ... + 10 = 55

sum += rSum(value + 1);

int sumLoop(int n) {
    int i;
    int sum = 0;

    for (i = 1; i <= n; i++) {
        sum += i;
    }

    return sum;
}

int sumRec(int n) {
    if (n == 1) {
        return 1;
    }

    return n + sumRec(n - 1);
}

void f(void) {
    f();
}

int factorial(int n) {
    return n * factorial(n - 1);
}

int factorial(int n) {
    if (n <= 1) {
        return 1;
    }

    return n * factorial(n - 1);
}

재귀에는 종료 조건이 있어야 합니다.
문제가 점점 작아져야 합니다.

int f(int n) {
    int x = n;
    return x;
}

int sum(int n) {
    if (n == 1) {
        return 1;
    }

    return n + sum(n - 1);
}

sum(5)의 n = 5
sum(4)의 n = 4
sum(3)의 n = 3

main.c
math_utils.c
math_utils.h

// math_utils.h
int add(int a, int b);
int sub(int a, int b);

// math_utils.c
int add(int a, int b) {
    return a + b;
}

int sub(int a, int b) {
    return a - b;
}

#include <stdio.h>
#include "math_utils.h"

int main(void) {
    printf("%d", add(3, 5));
    return 0;
}

헤더파일 = 선언 중심
소스파일 = 정의 중심

#define DEBUG

#ifdef DEBUG
    printf("debug mode");
#endif

#ifndef MATH_UTILS_H
#define MATH_UTILS_H

int add(int a, int b);

#endif

조건부 컴파일 = 컴파일 전에 조건에 따라 코드를 포함하거나 제외하는 기능

result = add(3, 5);

3 → a
5 → b

return a + b;

if (n == 1) return 1;

#include <stdio.h>

int add(int a, int b) {
    return a + b;
}

int main(void) {
    int x = 2;
    int y = 3;

    printf("%d", add(x, y));

    return 0;
}

x = 2
y = 3
add(x, y) 호출
a = 2, b = 3
return 2 + 3 = 5

5

#include <stdio.h>

void change(int x) {
    x = 20;
}

int main(void) {
    int a = 10;

    change(a);

    printf("%d", a);

    return 0;
}

a의 값 10이 x로 복사됩니다.
change 안에서 x는 20이 됩니다.
하지만 main의 a는 바뀌지 않습니다.

10

C는 기본적으로 값에 의한 전달

#include <stdio.h>

void count(void) {
    static int x = 0;
    x++;
    printf("%d", x);
}

int main(void) {
    count();
    count();
    count();

    return 0;
}

첫 호출: x = 1 출력
둘째 호출: x = 2 출력
셋째 호출: x = 3 출력

123

#include <stdio.h>

int f(int n) {
    if (n == 1) {
        return 1;
    }

    return n + f(n - 1);
}

int main(void) {
    printf("%d", f(4));
    return 0;
}

f(4) = 4 + f(3)
f(3) = 3 + f(2)
f(2) = 2 + f(1)
f(1) = 1

f(4) = 4 + 3 + 2 + 1 = 10

10

void hello(void) {
    printf("Hello");
}

hello();

return 10;
return 20;

void change(int x) {
    x = 100;
}

void f(void) {
    int x = 10;
}

int x = 100;

int main(void) {
    int x = 10;
    printf("%d", x);
}

static int x = 0;

int f(int n) {
    return f(n - 1);
}

sum += rSum(value + 1);

return value + rSum(value + 1);

반환형 함수이름(매개변수) {
    문장;
    return 값;
}

int add(int a, int b) {
    return a + b;
}

result = add(3, 5);

int add(int a, int b);

함수에 값의 복사본이 전달됩니다.
원본 변수는 바뀌지 않습니다.

함수나 블록 안에서만 사용 가능

함수 바깥에 선언, 여러 함수에서 사용 가능

함수가 끝나도 값 유지

함수가 자기 자신을 호출
반드시 종료 조건 필요

함수 = 코드 묶음
scope = 변수 사용 구역
static = 값 유지
재귀 = 자기 자신 호출

int add(int a, int b) {
    return a + b;
}

int add(int a, int b) {
    return a + b;
}

int main(void) {
    printf("%d", add(2, 5));
    return 0;
}

void change(int x) {
    x = 100;
}

int main(void) {
    int a = 10;
    change(a);
    printf("%d", a);
    return 0;
}

void count(void) {
    static int x = 0;
    x++;
    printf("%d", x);
}

int main(void) {
    count();
    count();
    count();
    return 0;
}

int f(int n) {
    if (n == 1) {
        return 1;
    }

    return n + f(n - 1);
}

int main(void) {
    printf("%d", f(4));
    return 0;
}

함수가 자기 자신을 다시 호출하는 것