exestudiary

매개변수를 포인터로 선언하는 경우

1. 함수 간의 변수 공유를 통한 범용의 함수 정의 

> 함수와 함수 간의 지역변수를 공유하기 위하여 매개변수에 포인터를 사용한다. 

> 인수와 매개변수를 통하여 변수를 공유함으로써 코딩의 유연성(flexibilty)을 줄 수 있다.

> 매개변수를 통한 변수의 공유가 없다면 반환값을 사용하여 함수 간의 값을 전달을 해야하므로 자료형마다 값을 입력받는 수많은 함수를 만들어야한다. 또한 다양한 자료형을 한꺼번에 입력받기 위한 함수를 만들기는 매우 까다롭다.

2. 대량의 데이터를 함수 간의 공유

> 배열을 함수에 전달할 때 값의 복사 방식을 사용하면 복사본을 만들기 위한 주기억장치 할당으로 실행시간 및 주기억장치 낭비가 발생할 수 있다. 따라서 C언어에서는 기본적으로 배열의 시작 주소를 넘기는 방식을 사용한다. 

3. 동적 할당

> 프로그램에서는 배열 크기를 정할 때 최악의 경우를 대비하여 최대로 잡는다. 그러나 실제로 프로그램을 실행하는 동안 배열에 저장된 배열 원소 수가 예상보다 많이 작으면 이미 할당된 배열의 기억 공간 중 사용되지 않는 부분은 낭비된다. 이를 해결하기 위해 프로그램을 실행하면서 필요할 때마다 배열을 위한 기억 공간을 할당받고 필요 없어진 공간은 해제하는 동적 할당 방법을 사용할 수 있다. 이러한 동적 할당에 포인터가 사용된다. 

두 변수의 값을 바꾸는 함수 

#include <stdio.h>
#pragma warning(disable: 4996)
#pragma warning(disable: 6031)

void exchange_value(int *ref1, int *ref2);

int main()
{
	int v1 = 36, v2 = 98;

	printf("before exchange: v1 = %d, v2 = %d\n", v1, v2);
	exchange_value(&v1, &v2);
	printf("after exchange: v1 = %d, v2 = %d\n", v1, v2);

	return 0;
}

void exchange_value(int *ref1, int *ref2)
{
	int temp;

	temp = *ref1;
	*ref1 = *ref2;
	*ref2 = temp;
}

두 변수를 오름차순으로 정렬하기

#include <stdio.h>
#include <math.h>
#pragma warning(disable: 4996)
#pragma warning(disable: 6031)

void sort_value(int *ref1, int *ref2);

int main()
{
	int v1 = 36, v2 = 98;

	printf("v1? ");
	scanf("%d", &v1);
	printf("v2? ");
	scanf("%d", &v2);

	sort_value(&v1, &v2);
	printf("after exchange: v1 = %d, v2 = %d\n", v1, v2);

	return 0;
}

void sort_value(int *ref1, int *ref2)
{
	int temp;

	if (*ref1 > *ref2)
	{
		temp = *ref1;
		*ref1 = *ref2;
		*ref2 = temp;
	}
}

두 수의 몫과 나머지

#include <stdio.h>
#include <math.h>
#pragma warning(disable: 4996)
#pragma warning(disable: 6031)

void division(int *x, int *y, int a, int b);

int main()
{
	int n1 = 75, n2 = 8, quo, rem;

	division(&quo, &rem, n1, n2);
	printf("%d / %d = %d \n", n1, n2, quo);
	printf("%d %% %d = %d \n", n1, n2, rem);
}

void division(int *x, int *y, int a, int b)
{
	*x = a / b;
	*y = a % b;
}

지금까지의 데이터를 저장하기 위하여 변수를 선언한 것은 선언할 때 명시한 변수의 자료형의 크기에 따라 주기억장치를 할당받는 것이고 변수를 사용한다는 것은 변수에 할당된 영역에 값을 저장하거나 저장된 값을 읽어서 사용한다는 것을 의미한다.

int var;
var = 10;
printf("%d\n", var);

포인터는 주소를 저장하기 위한 변수다. 

포인터를 사용하는 이유는 값을 간접참조(우회적으로 참조)하기 위한 것이다.

예시를 보자. 아래 예시는 위의 예시와는 다르다.(위의 예에서 var을 직접 사용하지 않고 *ptr을 사용하여 간접 참조한다.)

int *ptr;
ptr = &var;
printf("%d\n", *ptr);

여기서 포인터 연산자(*)와 주소 연산자(&)의 의미를 배워보자.

포인터 

char *p_chr;
int *p_int;
double *p_dbl;

char *p_chr; >> p_chr이 가리키는 곳에 char형 값이 있다. 

char *p_int; >> p_int이 가리키는 곳에 int형 값이 있다. 

char *p_dbl; >> p_dbl이 가리키는 곳에 double형 값이 있다. 

주의!!

주소의 크기는 같으므로 포인터의 크기는 같다.

printf("문자형과 포인터의 크기: %d, %d\n", sizeof(char), sizeof p_chr);
printf("정수형과 포인터의 크기: %d, %d\n", sizeof(int), sizeof p_int);
printf("실수형과 포인터의 크기: %d, %d\n", sizeof(double), sizeof p_dbl);

// 문자형과 포인터의 크기: 1, 4
// 정수형과 포인터의 크기: 4, 4
// 실수형과 포인터의 크기: 8, 4

>> 포인터의 크기는 모두 4바이트(32비트 컴파일러일 경우)로 같다. 이유는 주소를 표현하는 크기는 같기 때문이다. 

>> 예를 들자면 건물의 크기는 다양하지만, 주소의 길이는 비슷한 것과 같은 이치이다. 

주소연산자 (&)

int amt, *p_amt;

amt = 100;
p_amt = &amt;

일반 변수 amt를 선언하고 포인터 연산자 *와 연산자 &를 사용하여 amt 변수의 시작주소를 p_amt에 저장하는 예시이다.

밑에 그림은 어떻게 흐름이 이어나가는건지 그림으로 나타낸 것이다. 

amt의 시작주소가 1004인데 그거를 p_amt = &amt를 통해서 amt의 시작주소를 p_amt에 저장한다.

포인터 연산자 (*)

지금 현재 p_amt에는 amt의 시작주소인 1004가 저장되어 있는 것이다. 

그렇다면 p_amt가 아닌 p_amt가 가리키는 곳을 참조하고 싶을 때는 포인터 연산자 (*)를 사용해야한다.

포인터는 자료의 시작주소만을 저장하고 있고 포인터의 자료형 크기에 따라 마지막 주소가 결정된다.

즉 p_amt는 정수형 포인터이고 4바이트를 참조하므로 시작주소는 1004번지이고 끝 주소는 1007번지가 된다.

*p_amt는 1004-1007번지의 값을 읽어오는 수식으로 p_amt로 amt를 간접참조한다. 

따라서 amt == *p_amt 수식은 참이다. 

값에 의한 호출(call-by-value)

f_sum() 함수를 호출할 때 a값이 전달되어 begin에 저장되며, b 값이 전달되어 end에 저장된다.

#include <stdio.h>
#pragma warning(disable: 4996)
#pragma warning(disable: 6031)

int f_sum(int begin, int end);

int main()
{
	int a, b, sum;    //지역변수

	printf("a ~ b까지의 합 구하기 \n");
	printf("a는? ");
	scanf("%d", &a);
	printf("b는? ");
	scanf("%d", &b);

	sum = f_sum(a, b); //함수호출

	printf("\n%d ~ %d의 합은 %d", a, b, sum);

	return 0;
}

int f_sum(int begin, int end)
{
	int i, sum;

	sum = 0;
	for (i = begin; i <= end; i++)
	{
		sum += i;
	}

	return sum;
}

f_sum()함수에서 main()의 인수 a를 전달받은 begin 변수는 a와 같은 값을 가진다. 

f_sum()함수에서 return sum; 직전에 begin = begin * 2;를 실행하여 begin 값을 변경하면 main()의 a값도 변할까? 

a와 begin은 서로 다른 함수에서 선언하여 다른 기억장소를 사용하기 때문에 a는 변하지 않는다. 

f_sum() 함수를 int f_sum(int a, int b)로 정의하여도 매개변수 a는 동명이인에 해당하므로 다른 기억장소를 사용한다. 

이 방식은 호출된 함수에서 자신을 호출한 함수의 인수를 절대로 변경할 수 없으므로 함수를 호출할 때 마음 놓고 자신의 정보를 전달할 수 있다. 이 '함수 간 독립성 보장'이라는 특징 때문에 함수 호출 시 기본적으로 사용하는 인수 전달 방식이 '값에 의한 호출'이다.

이해를 돕기 위한 예시

내 노트를 복사 >>> 각자 내용이 같은 노트를 갖게 된다.

코드 예시

#include <stdio.h>
#pragma warning(disable: 4996)
#pragma warning(disable: 6031)
#define N 5

int f_even(int no);

int main()
{
	int i, marble[N] = { 5, 4, 2, 3, 7 };

	for (i = 0; i < N; i++)
	{
		if (f_even(marble[i]) == 1)
		{
			printf("%d: 홀수\n", marble[i]);
		}

		else
		{
			printf("%d: 짝수\n", marble[i]);
		}
	}

	return 0;
}

int f_even(int no)
{
	if (no % 2 != 0)
	{
		return 1;
	}

	else
	{
		return 0;
	}
}

주소에 의한 호출(call-by-value)

배열 전체를 함수에 전달할 때는 주소에 의한 호출 방식만 사용한다.

원소가 천 개인 배열 전체를 값에 의한 호출 방식으로 전달한다고 가정해보자.

인수인 배열의 원소 개수만큼 값을 저장할 매개변수의 기억장소가 필요하고, 배열 원소 순서대로 매개변수에 값을 저장하는데 시간이 걸린다. 

배열은 대량의 자료를 저장하는 데 사용하므로 이 배열을 값에 의한 호출로 전달한다면 추가적 기억장소와 값 복사로 인한 자원 낭비가 데이터 양에 비례하여 커진다. 

그래서 배열은 원본을 공유하는 주소에 의한 호출 방식을 사용한다. 

#include <stdio.h>
#pragma warning(disable: 4996)
#pragma warning(disable: 6031)
#define N 5

int f_tot(int ary[N]);

int main()
{
	int kor[N] = { 45, 34, 43, 33, 48 };

	printf("총계: %d \n", f_tot(kor));

	return 0;
}

int f_tot(int ary[N])
{
	int i, sum;

	sum = 0;
	for (i = 0; i < N; i++)
	{
		sum += ary[i];
	}

	return sum;
}

배열 인수: 차원과 상관없이 배열명만 사용 

>> 배열명은 배열 시작 주소이므로 결국 주소를 전달하는 방식 

배열 매개변수 선언: 전달되는 배열의 차원에 맞게 배열 선언 

주의

- 배열은 함수 간에 같은 기억장소를 공유하므로 호출된 함수 f_tot()에서 ary배열 원소를 변경하면 main()의 kor 배열 원소가 변경된다.  >> 함수에서 배열 내용을 변경한 후 배열을 반환할 필요가 없다.

- 매개변수 배열 선언 시 

 1차원 배열이라면 int ary[N] 대신 int ary[ ]처럼 원소수 생략 가능

 2차원 배열이라면 int b[5][7]대신 int b[ ][7]처럼 행 개수 생략 가능

- f_tot() 함수는 원소 개수가 N개일 때만 사용할 수 있다. 원소 개수와 상관없이 총계를 구하는 함수는 나중에 배울 예정.

배열을 전달하여 모든 원소를 두 배로 변경하기 

#include <stdio.h>
#pragma warning(disable: 4996)
#pragma warning(disable: 6031)
#define N 5

void f_double(int ary[N]);

int main()
{
	int i, kor[N] = { 45, 34, 43, 33, 48 };

	f_double(kor);

	for (i = 0; i < N; i++)
	{
		printf("%4d", kor[i]);
	}

	return 0;
}

void f_double(int ary[N])
{
	int i;

	for (i = 0; i < N; i++)
	{
		ary[i] *= 2;
	}
}

예시

노트 원본을 빌려주므로 노트는 공유하는 한 권만 있게 되는 경우

함수 호출 시 결과를 저장할 빈 배열을 추가로 전달하기

#include <stdio.h>
#pragma warning(disable: 4996)
#pragma warning(disable: 6031)
#define N 5

void f_twice(int a[N], int a_twice[N]);
void f_print(int ary[N]);

int main()
{
	int i, kor[N] = {45, 34, 43, 33, 48};
	int kor_twice[N];

	f_twice(kor, kor_twice);
	f_print(kor);
	f_print(kor_twice);
}

void f_twice(int a[N], int a_twice[N])
{
	int i;

	for (i = 0; i < N; i++)
	{
		a_twice[i] = a[i] * 2;
	}
}

void f_print(int ary[N])
{
	int i;

	for (i = 0; i < N; i++)
	{
		printf("%d ", ary[i]);
	}

	printf("\n");
}

void형 함수면 return; 생략가능

#include <stdio.h>
#pragma warning(disable: 4996)
#pragma warning(disable: 6031)

double get_average(int ary[], int n);

int main()
{
	int a[4] = { 92, 80, 75, 93 };
	int b[3] = { 88, 57, 81 };

	printf("a 평균: %5.1f \n", get_average(a, sizeof(a) / sizeof(a[0])));
	printf("b 평균: %5.1f \n", get_average(b, sizeof(b) / sizeof(b[0])));

	return 0;
}

double get_average(int ary[], int n)
{
	int i, sum;

	sum = 0;
	for (i = 0; i < n; i++)
	{
		sum += ary[i];
	}

	return (double) sum / n;
}

문자 선언

//문자 1개
char alpha = 'C';

// 문자열 1개
char id[5] = "Nabi";

Nabi는 4글자인데 id[5]로 5글자를 저장하겠다고 코드를 작성하면

'N' 'a' 'b' 'i' '\0'로 저장이 된다. 

// 문자열 3개
char fr[3][6] = {"Jaeil", 
		"Doori", 
                "Gosu"}

마찬가지로 행의 길이가 6글자로 저장된다고 했는데 5글자, 4글자로 문자열이 저장되어있다.

이 같은 경우에도 \0이 남는 자리에 저장이 된다. 

원소 호출

원소 호출을 할 때는 2차원 배열을 호출할 때 하는 것처럼 하면 된다. 

문자열 단위의 입출력

문자열의 시작주소

char형 1차원 배열일 때

배열명: 문자열 시작 주소

// 문자열 1개
char id[5] = "Nabi";

id: 문자열 시작 주소 (포인터)

char형 2차원 배열일 때

배열명[행첨자] : 해당 행 문자열 시작 주소

// 문자열 3개
char fr[3][6] = {"Jaeil", 
		"Doori", 
                "Gosu"}

- fr[0] : 1번째 문자열 시작 주소

- fr[1] : 2번째 문자열 시작 주소

- fr[2] : 3번째 문자열 시작 주소

기억!!

배열명은 배열 시작 주소이며 배열 시작 위치를 가리킨다!

단순 문자열을 출력하기 위한 형식 

문자열 입력

scanf("%s", 문자열 저장 시작 주소);

• 키보드에서 입력되는 문자열을 지정한 주소의 기억장소부터 차례대로 저장함.
• 배열에 남는 공간이 있어야 입력 문자열 뒤에 널 문자가 저장됨.
• ex) scanf("%s", id); , scanf("%s", fr[2])  (+&가 없다!)

문자열 출력

printf("%s", 문자열이 저장된 시작 주소);

• 시작 주소로부터 저장된 문자를 연속으로 출력하되 널 문자를 만나면 출력을 끝냄.
• ex) printf("%s", id);, printf("%s", fr[2])

주의!

문자열 시작 주소와 %를 이용한 문자열 출력은 널 문자('\0')를 만나야 출력이 끝난다. 

다음 sur 배열은 배열 원소 수가 문자열의 길이 즉, 실제 문자 개수와 똑같다.

그러므로 널 문자가 저장되지 않기에 이상한 결과가 나올 수 있다.

참고로, 비주얼 스튜디오에서 위의 코드를 '*.c'와 같이 C언어 소스 파일로 저장하면 실행이 된다.

하지만 C++언어는 배열에 널 문자가 들어갈 공간이 없으면 오류가 되어 실행 자체가 되지 않는다.

문자열 처리 함수

strcpy() - 문자열 복사

strcmp() - 두 문자열의 크기를 비교

공백이 있는 문자열 입력

예시1

#include <stdio.h>
#include <string.h>
#pragma warning(disable: 4996)
#pragma warning(disable: 6031)

int main()
{
	char grade, name[10], reply[10];
	char correct[10] = "로딩중";

	printf("받고 싶은 C언어 등급은? ");
	scanf("%s", &grade);

	printf("\n%c를 받기 위해 노력 중이군요!", grade);

	printf("\n이름은? ");
	scanf("%s", &name);

	printf("%s님 반갑습니다!", name);

	printf("\n문제: 세상에서 가장 느린 중학교는? ");
	scanf("%s", &reply);

	if (strcmp(reply, correct) == 0)
	{
		printf("맞았습니다!");
	}

	else
	{
		printf("틀렸습니다! 정답은 %s!\n", correct);
	}

	return 0;
}

예시2

#include <stdio.h>
#include <string.h>
#pragma warning(disable: 4996)
#pragma warning(disable: 6031)
#define N 5

int main()
{
	char std[N][10] = { "최고수", "진재일", "강인", "나태희", "유명인" };

	int i, quiz[N] = { 10, 9, 8, 7, 9 };

	for (i = 0; i < N; i++)
	{
		printf("%s   %d\n", std[i], quiz[i]);
	}

	return 0;
}

예시3

#include <stdio.h>
#include <string.h>
#pragma warning(disable: 4996)
#pragma warning(disable: 6031)
#define N 5

int main()
{
	char std[N][6] = { "itsme", "ace", "iam", "myid", "snow"};
	char input[6];
	int i;

	printf("아이디는? ");
	scanf("%s", &input);

	for (i = 0; i < N; i++)
	{
		if (strcmp(input,std[i]) == 0)
		{
			printf("%s님 반갑습니다.", input);
			break;
		}
	}

	if (i == N)
	{
		printf("없는 아이디입니다.");
	}


	return 0;
}

인수 전달이 있는 함수의 정의와 호출을 예시를 통해 바로 이해해보자.

#include <stdio.h>
#include <stdlib.h>
#pragma warning(disable: 4996)
#pragma warning(disable: 6031)

void f_line(char ch, int n);   // 함수 원형 선언

int main()                    // main 함수 정의
{ 
	int length = 10;          // main 함수의 지역 변수 선언 

	f_line('>', 5);         // '>'를 5개 출력하도록 함수 호출 
	f_line('-', length);
	f_line('<', length + 5);

	return 0;
}

void f_line(char ch, int n)    
{
	int i;

	for (i = 0; i < n; i++)
	{
		printf("%c", ch);
	}
	printf("\n");

	return;
}

여기서 보면 void f_line(char ch, int n)을 확인할 수 있을 것이다. 

이게 어찌보면 가장 중요한데 함수의 원형 선언을 할 때도 이렇게 매개변수를 설정해줘야 하고

밑에서 함수를 구성할 때도 꼭 들어가야하는 것이다. 

주의

• 매개변수는 함수의 지역 변수이며, 호출되면 함수 헤더에서 바로 인수를 저장하는 데 사용되므로 ( ) 안에서 선언해야한다.
• 매개변수는 무조건 개별적으로 선언해야한다. (int a, b는 오류!!!, >> int a, int b로 해야한다.)
• 인수와 매개변수는 개수, 자료형, 순서가 같아야한다.
• 함수 안에서 선언한 지역 변수는 함수 안에서만 유효하므로 인수와 매개변수의 이름은 서로 연관이 없다.

       >> 인수명과 매개변수명이 같아도 서로 다른 기억장소를 사용하는 다른 변수 즉, 동명이인에 해당한다. 

       >> 서로 다른 함수들은 서로의 정보를 알 수 없다. (라고 생각!)

인수 전달과 반환값이 있는 함수의 정의와 호출

#include <stdio.h>
#pragma warning(disable: 4996)
#pragma warning(disable: 6031)

int f_smaller(int n1, int n2);

int main()
{
	int s1, s2, s3, min;

	printf("점수1 점수2 점수3? ");
	scanf("%d %d %d", &s1, &s2, &s3);

	min = f_smaller(s1, s2);
	min = f_smaller(min, s3);

	printf("%d, %d, %d 중 가장 낮은 점수는 %d", s1, s2, s3, min);

	return 0;
}

int f_smaller(int n1, int n2)
{
	int min;

	if (n1 > n2)
	{
		min = n2;
	}

	else
	{
		min = n1;
	}

	return min;
}

begin ~ end까지의 합을 반환하는 함수

#include <stdio.h>
#include <stdlib.h>
#pragma warning(disable: 4996)
#pragma warning(disable: 6031)

int get_sum(int begin, int end);

int main()
{
	int a, b;

	printf("[1] a ~ b 합 구하기\n");

	printf("a는? ");
	scanf("%d", &a);


	printf("b는? ");
	scanf("%d", &b);

	printf("\n%d~%d 합: %d", a, b, get_sum(a, b));

	printf("\n\n[2] a*2 ~ b*2 합 구하기\n");
	printf("\n%d~%d 합: %d", a*2, b*2, get_sum(a*2, b*2));

	return 0;
}


int get_sum(int begin, int end)
{
	int sum, i;

	sum = 0;
	for (i = begin; i <= end; i++)
	{
		sum += i;
	}

	return sum;
}

함수

특정한 일을 수행하는 코드 블록

평균, 순위, 합격자 수, 둘 중 큰 값, 90점 이상 점수 개수와 같이 특정 값 한 개를 많이 구하는 데 많이 사용한다.

종류가 2개가 있는데 반환값이 있는 함수와 반환값이 없는 함수로 나뉜다.

#include <math.h>가 필요한 수학 함수 

#include <stdlib.h>가 필요한 범용 함수

함수의 원형 선언 

함수의 원형 선언이 필요한 경우의 예시가 있고 그렇지 않은 예시가 있다.

보통 함수의 원형 선언이 필요한 경우를 권장하는 편이다.

줄 출력하기 예시를 통해 알아보자.

함수의 원형 선언이 필요한 경우 

#include <stdio.h>
#pragma warning(disable: 4996)
#pragma warning(disable: 6031)

void f_line();

int main()
{
	printf("줄 출력하기\n");

	f_line();
	f_line();

	return 0;
}

void f_line()
{
	int i;

	for (i = 0; i < 20; i++)
	{
		printf("=");
	}
	printf("\n");

	return;
}

함수의 원형 선언이 필요하지 않은 경우 

프로그램의 전체의 흐름은 main() 함수에 있으므로 main() 함수 정의를 맨 위에 두는 것이 바람직하며, 함수 원형을 main() 함수 위에 모두 모으면 이 프로그램에 포함된 함수로 어떤 것들이 있는지 쉽게 파악할 수 있으며, 함수를 호출할 때 해당 함수의 원형을 빠르게 찾아 참고하여 함수를 정확하게 호출할 수 있기 때문이다. 

#include <stdio.h>
#pragma warning(disable: 4996)
#pragma warning(disable: 6031)

void f_line()
{
	int i;

	for (i = 0; i < 20; i++)
	{
		printf("=");
	}
	printf("\n");

	return;
}

int main()
{
	printf("줄 출력하기\n");

	f_line();
	f_line();

	return 0;
}

주사위 눈의 수 맞히기, 숫자 암기, 구구단 게임

#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
#include <time.h>
#include <Windows.h>

#pragma warning(disable: 4996)
#pragma warning(disable: 6031)

void game_die();
void game_memory();
void game_99();

int main()
{
	int game;

	printf("어떤 게임을 할까요(1. 주사위  2. 숫자 암기  3. 구구단)? ");
	scanf("%d", &game);

	srand(time(NULL));

	switch (game)
	{
		case 1: game_die(); break;
		case 2: game_memory(); break;
		case 3: game_99(); break;
		default: printf("잘못 입력했습니다.");
	}

	return 0;
}


void game_die()
{
	int num, die_spot;

	die_spot = rand() % 6 + 1;

	printf("\n주사위를 던졌습니다. 얼마일까요(1 ~ 6)?");
	scanf("%d", &num);

	die_spot == num ? printf("\n%d인지 어떻게 알았죠? 찍기 왕이군요!", die_spot) :
		printf("\n%d인데 아쉽군요!\n", die_spot);
}


void game_memory()
{
	int n1, n2, n3, r1, r2, r3;

	n1 = rand() % 900 + 100;
	n2 = rand() % 900 + 100;
	n3 = rand() % 900 + 100;

	printf("\n화면에 나타난 값 3개 암기하기!!\n");
	printf("아무 키나 누르면 시작해요. ");
	getch(); system("cls");

	printf("\n%4d %4d %4d \n", n1, n2, n3);

	Sleep(2000); system("cls");

	printf("무슨 값(차례대로 빈칸으로 구분)? ");
	scanf("%d %d %d", &r1, &r2, &r3);

	(n1 == r1) && (n2 == r2) && (n3 == r3) ?
		printf("\n암기력 짱! \n") : 
		printf("\n아쉽게도 틀렸네요~ \n");

	return;
}

void game_99()
{
	int n1, n2, reply; 

	printf("구구단 게임입니다.\n");

	n1 = rand() % 8 + 2;
	n2 = rand() % 8 + 2;

	printf("%d * %d = ?", n1, n2);
	scanf("%d", &reply);

	reply != n1 * n2 ?
		printf("%d인데 틀렸습니다! ㅋㅋ  \n", n1 * n2) :
		printf("맞았습니다. ^^ \n");

	return;
}

예시로 먼저 학습하기

모든 값의 순위 저장하기

#include <stdio.h>
#pragma warning(disable: 4996)
#pragma warning(disable: 6031)
#define NUM_OF_SCORE 5

int main()
{
	int scores[NUM_OF_SCORE] = { 97, 85, 89, 72, 96 };
	int ranks[NUM_OF_SCORE] = { 0 }, i, target;

	for (target = 0; target < NUM_OF_SCORE; target++)
	{
		ranks[target] = 1;
		for (i = 0; i < NUM_OF_SCORE; i++)
		{
			if (scores[target] < scores[i])
			{
				ranks[target]++;
			}
		}
	}

	for (target = 0; target < NUM_OF_SCORE; target++)
	{
		printf("%d번째: ", target + 1);
		printf("%d점의 순위: ", scores[target]);
		printf("%d위\n", ranks[target]);
	}

	return 0;
}

여기서는 순위를 매겨야하기에 ranks[NUM_OF_SCORE] = {0}을 생각해낼 수 있어야 하는 거 같다.

이걸을 먼저 선언하고 초기화할 수 있어야 똑바로 순위를 매겨서 출력을 할 수 있기 때문이다. 

2차원 배열에 저장하기 

2차원 배열 선언 및 참조

2차원 배열 선언

int scores[3][5];
double rates[10][15];

2차원 배열 초기화

int scores[3][5] = {{97, 85, 89, 72, 96}, {96, 94, 90, 88, 89}, {80, 85, 79, 70, 82}}

int scores[][5] = {{97, 85, 89, 72, 96}, {96, 94, 90, 88, 89}, {80, 85, 79, 70, 82}}

2차원 배열에서는 초기화 값이 있을 때 행수만 생략이 가능하다. 권장하지 않는다. 

또 다음과 같이 단일 중괄호를 사용하여 초기화할 수 있으나 권장하지 않는다.

int scores[3][5] = {97, 85, 89, 72, 96, 96, 94, 90, 88, 89, 80, 85, 79, 70, 82}

주의! 

기본변수는 선언 후 필요할 때마다 변수의 값을 대입 연산자를 사용하여 수정할 수 있으나 

배열은 선언 이후에 중괄호를 사용하여 변경할 수 없다. 

즉 아래와 같이 사용해서는 안된다!!!!

int scores[3][5]

scores = {{97, 85, 89, 72, 96}, {96, 94, 90, 88, 89}, {80, 85, 79, 70, 82}}
scores[3][5] = {{97, 85, 89, 72, 96}, {96, 94, 90, 88, 89}, {80, 85, 79, 70, 82}}

// scores 또는 scores[3][5]에 대입연산자를 사용하여 일괄적으로 할당할 수 없다!

2차원 배열 원소 참조

int scores[3][5] = {{97, 85, 89, 72, 96}, {96, 94, 90, 88, 89}, {80, 85, 79, 70, 82}}

//원소 참조//
scores[0][0] // 97로 나옴.//

2차원 배열 입력 및 출력

#include <stdio.h>
#pragma warning(disable: 4996)
#pragma warning(disable: 6031)
#define NUM_OF_STD 3
#define NUM_OF_SBJ 5

int main()
{
	int scores[NUM_OF_STD][NUM_OF_SBJ], i, j;

	for (i = 0; i < NUM_OF_STD; i++)
	{
		printf("%d번째 학생의 %d과목 성적입력: ", i + 1, NUM_OF_SBJ);
		for (j = 0; j < NUM_OF_SBJ; j++)
		{
			scanf("%d", &scores[i][j]); //항상 주의! "%d  "을 하면 안된다!!//
		}
		
	}

	for (i = 0; i < NUM_OF_STD; i++)
	{
		printf("%d번째 학생의 성적: ", i + 1);

		for (j = 0; j < NUM_OF_SBJ; j++)
		{
			printf("%5d", scores[i][j]);
		}
	}

	return 0;
}

과목 합계 및 평균

#include <stdio.h>

#define NUM_OF_STD 3
#define NUM_OF_SBJ 5
int main()
{
	int scores[NUM_OF_STD][NUM_OF_SBJ] = {
				{97, 85, 89, 72, 96},
				{96, 94, 90, 88, 89},
				{80, 85, 79, 70, 82}
	};
	int std, sbj, total;
	int std_tot; //한 학생의 성적 합계를 저장하기 위한 변수

	printf("번호  국어  영어  수학  물리  과학  총점   평균\n");
	printf("==============================================\n");

	//성적 출력하고 합계 구하기
	total = 0;
	for (std = 0; std < NUM_OF_STD; std++) {
		printf("%d번 [", std + 1);
		std_tot = 0;  //성적의 합계를 초기화
		for (sbj = 0; sbj < NUM_OF_SBJ; sbj++) {
			std_tot += scores[std][sbj]; //성적을 누적
			total += scores[std][sbj];
			printf("%5d ", scores[std][sbj]);
		}
		//tot, NUM_OF_SBJ가 정수이므로 (double)로 형변환하여 평균 구하기
		printf(" ] %5d %5.1f\n", std_tot, (double)std_tot / (double)NUM_OF_SBJ);
	}
	printf("==============================================\n");


	printf("전체 총점 %5d점\n", total);
	printf("평균 %.1lf점", (double)total / (NUM_OF_SBJ * NUM_OF_STD));

	return 0;
}

보너스

#include <stdio.h>
#pragma warning(disable: 4996)
#pragma warning(disable: 6031)

#define NUM_OF_STD 3
#define NUM_OF_SBJ 5
int main()
{
	int std, sbj, sum_sbj;
	int scores[NUM_OF_STD][NUM_OF_SBJ];
	int tot_sbj, total = 0;
	double avg_sbj;

	for (std = 0; std < NUM_OF_STD; std++)
	{
		printf("std %d: ", std + 1);
		for (sbj = 0; sbj < NUM_OF_SBJ; sbj++)
		{
			scanf("%d", &scores[std][sbj]);
		}
	}

	printf("\n");

	for (std = 0; std < NUM_OF_STD; std++)
	{
		sum_sbj = 0;
		printf("std %d: ", std + 1);
		for (sbj = 0; sbj < NUM_OF_SBJ; sbj++)
		{
			printf("%5d", scores[std][sbj]);
			sum_sbj += scores[std][sbj];
		}
		
		printf("|%5d|%5.1lf\n", sum_sbj, (double) sum_sbj / NUM_OF_SBJ);
	}


	printf("tot: ");
	for (sbj = 0; sbj < NUM_OF_SBJ; sbj++)
	{
		tot_sbj = 0;
		for (std = 0; std < NUM_OF_STD; std++)
		{
			tot_sbj += scores[std][sbj];
		}
		total += tot_sbj;
		printf("%5d", tot_sbj);
	}
	printf("|%5d|%5.1lf\n", total, (double)total / (NUM_OF_SBJ * NUM_OF_STD));
	
	printf("avg: ");
	for (sbj = 0; sbj < NUM_OF_SBJ; sbj++)
	{
		tot_sbj = 0;
		for (std = 0; std < NUM_OF_STD; std++)
		{
			tot_sbj += scores[std][sbj];
			avg_sbj = (double)tot_sbj / NUM_OF_STD;
		}
		printf("%5.1lf", avg_sbj);
	}

	return 0;
}

다중선형회귀

변수 Y를 X₁,....,Xp로 설명하는 다중선형회귀 모형

회귀계수의 추정

손실분량 

최소제곱법

data("stackloss")
m1 = lm(stack.loss ~ ., data = stackloss); m1

여기서 . 의 의미는 stack.loss를 제외한 모든 변수를 덧셈으로 연결한다는 뜻.

후버의 M-추정법

m2 = rlm(stack.loss ~ ., data = stackloss); m2

LMS

m3 = lqs(stack.loss ~ ., data = stackloss, method = "lms"); m3

LTS

m4 = lqs(stack.loss ~ ., data = stackloss, method = "lts"); m4

최소제곱 추정 방법 

• 개체에서 발생하는 잔차에 제곱을 취하여 합을 구하는 방식 
• 큰 절대값 잔차가 발생하지 않도록 회귀직선을 움직임. 
• 한 개의 특이점이 회귀직선의 결정에 막중한 영향력을 가짐.

후버의 M-추정 

최소제곱 추정은 함수

으로 정의할 떄

를 최소화

그런데 이 추정치가 안정적이지 못한 이유는 함수가 z²에 비례하는 형태이기 때문 

따라서 다음의 변형을 고려한다.

|z| < c에서는 원래의 함수와 같지만 그 밖에서는 원래 함수보다 천천히 증가한다.

이를 반영한 후버의 M-추정량은 

로 얻어진다.

여기서 σ를 모르기 때문에 (다음 페이지의) MAD로 추정해 사용한다.

MAD (median of absolute deviations)

를 가정하고 σ에 대한 로버스트 추정량으로 IQR / 1.35 를 사용한다.

MAD는 또 다른 로버스트 추정량으로

라 정의한다.

목적함수  l ₀  (z)  vs.   l ₁ (z)

ell.0 = function(z){z^2}
ell.1 = function(z){c = 1.345; ifelse(abs(z) < c, z^2, c*(2*abs(z) - c))}
z = seq(-6, 6, 0.1)
y.0 = ell.0(z)
y.1 = ell.1(z)
par(mfrow = c(1,2), pty = 's', mar = c(5, 3, 1, 3))
plot(y.0 ~ z, type = "l", lwd = 2, ylim = c(0, 30),
     ylab = expression(paste("\u2113")[0](z)))
plot(y.1 ~ z, type = "l", lwd = 2, ylim = c(0, 30),
     ylab = expression(paste("\u2113")[1](z)))
par(new = T)
plot(y.0 ~ z, type = "l", lwd = 2, lty = "dotted", ylim = c(0, 30), ylab = "")

코드해석: 

1. ell.0과 ell.1은 앞에서 봤던 l ₀, l ₁의 목적함수를 뜻한다. 

2. ell.1에서 ifelse는 첫 번째 조건을 만족하면 z² 을 하고 아니면 c * (2 * abs(z) - c)를 한다.

코드결과:

LMS/ LTS 추정 

> 자료점을

라 하고, 잔차를 

라 할 때, 최소제곱법은 

을 풀어 회귀직선을 얻는다.

LMS

> 반면에 LMS (Least Median of Squares) 회귀는 로버스트성의 관점에서 이 목적식을 

으로 개량한다.

> 최소제곱법은 Least Squares지만 Least Mean of Squares으로 간주 가능하다.

> LS는 선형대수적 풀이가 가능하지만 LMS는 몬테카를로 반복시행으로 해를 찾는다.

LTS

> LTS (Least Trimmed Squares; 최소절삭제곱) 회귀는

을 풀어서 회귀직선을 얻는다.

> q는 잔차제곱에 대한 순서통계량

에서의 순서

> default는 n의 50%정도에 해당하는 [n/2] + [(p+1)/2]

> n의 75% 정도에 맞추면 추정치의 정확도가 높아진다는 연구결과가 있다. 

비교1

library(MASS)
m0 = lm(y ~ x)  # 최소제곱추정 
m1 = rlm(y ~ x)  # 후버의 M-추정
m2 = lqs(y ~ x, method = "lms") # lms
m3 = lqs(y ~ x, method = "lts") # lts 
par(mfrow = c(1,1), mar = c(5, 3, 1, 3), pty = 's')
plot(y ~ x, ylim = c(-10, 10), cex = 2, pch = 19, col = 'darkgreen')
abline(m.truth$coefficients, lty = "dotted", lwd = 2)
abline(m0$coefficients, col = "darkcyan", lwd = 2)
abline(m1$coefficients, col = "darkblue", lwd = 2)
abline(m2$coefficients, col = "darkred", lwd = 2)
abline(m3$coefficients, col = "orange", lwd = 2)

여기서 보면 최소제곱추정 (lm)은 이상치에 민감해서 이상치쪽으로 방향이 따라간다는 걸 알 수 있다. 

lms, lts, 후버의 m-추정 모두 경향을 잘 따라가고 있다. 

다른 예를 통해서 조금 더 자세하게 살펴보자.

비교2 

1. X: 1,2,3,... , 10으로 고정

2. Y: Y = 2.5 + 0.5X + ε, ε ~ N(0,1)으로 생성 

3. 열번 째 자료점은 (100, -100)으로 수정 

• x = 100은 '특이한' 설명변수 값
• x = 100이 정상적인 값이라 했을 때도 y = -100은 특이값 ('회귀' 특이점)

set.seed(1234567)
x = seq(1:10)
y = 2.5 + 0.5*x + rnorm(10, 0, 1)
x[10] = 100
y[10] = -100

par(mar = C(5,3,1,3), pty = 's')
plot(y ~ x, ylim = c(-100, 10), cex = 1, pch = 19, col = 'darkgreen')
abline(m.truth$coefficients, lty = 'dotted', lwd = 2)

후버의 M-추정 vs. LMS

m1 = rlm(y ~ x)  # 후버의 M-추정
m2 = lqs(y ~ x, method = "lms") # lms
par(mar = c(5,3,1,3), pty = 's', mfrow = c(1,2))
plot(y ~ x, ylim = c(-100, 10), cex = 1, pch = 19, col = 'darkgreen')
abline(m.truth$coefficients, lty = 'dotted', lwd = 2)
abline(m1$coefficients, col = 'darkblue', lwd = 2)
abline(m2$coefficients, col = 'darkred', lwd = 2)

plot(y ~ x, ylim = c(-100, 10), cex = 1, pch = 19, col = 'darkgreen')
abline(m.truth$coefficients, lty = 'dotted', lwd = 2)
abline(m1$coefficients, col = 'darkblue', lwd = 5)
abline(m2$coefficients, col = 'darkred', lwd = 5)

LMS가 후버의 M-추정에 비해 더 경향을 잘 따라간다. 

LTS default vs. LTS quantile = 8

m2a = lqs(y ~ x, method = "lts")
m2b = lqs(y ~ x, method = "lts", quantile = 8)
par(mar = c(5,3,1,3), pty = 's')
plot(y ~ x, xlim = c(0, 10), ylim = c(0, 10), cex = 2, pch = 19, col = "darkgreen")
abline(m.truth$coefficients, lty = 'dotted', lwd = 2)
abline(m1$coefficients, col = 'darkcyan', lwd = 5)
abline(m2$coefficients, col = 'purple', lwd = 5)

누가 더 경향을 더 잘 따라간다고 할 수는 없다. 

 ACF(자기상관 함수 - 왼쪽) 플롯은 시계열 데이터의 현재 값과 과거 값 사이의 상관 관계를 시간 지연에 따라 보여준다.

PACF(부분 자기상관 함수 - 오른쪽)플롯은 시간 지연 간의 상관 관계를 보여준다. 이는 다른 지연의 영향을 배제한 후의 상관 관계를 나타낸다. 

ACF 그래프는 라그(lag) 증가함에 따라 상관계수가 천천히 감소하는 패턴을 보여준다.

일반적으로 이런 패턴은 데이터에 계절성이나 추세와 같은 비정상적인 성분이 포함되어 있을 수 있음을 나타낸다.

그러나 이 경우, ADF 테스트를 통해 데이터가 정상 시계열임을 확인했기에 ACF 그래프에서 나타나는 느린 감소나 주기적 패턴에도 불구하고, 우리는 이 데이터를 정상적인 시계열로 간주하고 ARIMA 모델링에 사용할 것이다.

이로 인해 비정상 시계열로 보일 수 있는 신호가 있더라도, 이미 검증된 데이터의 정상성을 신뢰하고 해당 데이터로 모델링을 진행할 것이다. 

PACF 그래프에서 신뢰구간 안으로 처음으로 들어가는 라그(lag)는 인덱스 9번이다. 

이는 해당 지점까지의 부분 자기상관계수는 통계적으로 유의미하다고 해석할 수 있으며, 이는 ARIMA 모델에서 자기회귀(AR)부분의 p 매개변수를 결정할 때의 정보를 제공한다.

첫 번째 라그 이후 상관계수가 점차 감소하는 것은 이전 시점의 데이터가 현재값에 영향을 미칠 수 있음을 나타내지만, 9번째 라그 이후에는 이러한 영향이 통계적으로 유의하지 않게 되어 추가적인 AR 구성 요소가 필요하지 않을 수 있음을 의미한다. 

이 정보를 기반으로, ARIMA 모델링 시 p를 최대 8로 설정할 수 있으며, 이는 시계열 데이터의 현재값이 과거 8개의 시점에 영향을 받을 수 있다는 가정 하에 모델을 구축하는 것이다. 

이후 모델 선택 과정에서 AIC와 같은 정보 기준을 통해 더 낮은 p값이 더 적합한 모델을 제공하는지 평가할 수 있다.