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

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;
}

'프로그래밍 > C,C++' 카테고리의 다른 글

포인터  (0) 2024.06.06
다양한 함수와 변수의 참조 범위  (0) 2024.05.30
문자열 처리  (0) 2024.05.28
인수 전달하는 함수  (0) 2024.05.28
인수 전달하지 않는 함수  (0) 2024.05.27

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

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 수식은 참이다. 

 

 

'프로그래밍 > C,C++' 카테고리의 다른 글

포인터 예제  (0) 2024.06.11
다양한 함수와 변수의 참조 범위  (0) 2024.05.30
문자열 처리  (0) 2024.05.28
인수 전달하는 함수  (0) 2024.05.28
인수 전달하지 않는 함수  (0) 2024.05.27

값에 의한 호출(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;
}

'프로그래밍 > C,C++' 카테고리의 다른 글

포인터 예제  (0) 2024.06.11
포인터  (0) 2024.06.06
문자열 처리  (0) 2024.05.28
인수 전달하는 함수  (0) 2024.05.28
인수 전달하지 않는 함수  (0) 2024.05.27

문자 선언

//문자 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;
}

'프로그래밍 > C,C++' 카테고리의 다른 글

포인터  (0) 2024.06.06
다양한 함수와 변수의 참조 범위  (0) 2024.05.30
인수 전달하는 함수  (0) 2024.05.28
인수 전달하지 않는 함수  (0) 2024.05.27
자료 배열 2 (9장)  (0) 2024.05.27

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

 

#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;
}

'프로그래밍 > C,C++' 카테고리의 다른 글

다양한 함수와 변수의 참조 범위  (0) 2024.05.30
문자열 처리  (0) 2024.05.28
인수 전달하지 않는 함수  (0) 2024.05.27
자료 배열 2 (9장)  (0) 2024.05.27
자료 배열 1 (8장)  (0) 2024.04.29

함수

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

평균, 순위, 합격자 수, 둘 중 큰 값, 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;
}

'프로그래밍 > C,C++' 카테고리의 다른 글

문자열 처리  (0) 2024.05.28
인수 전달하는 함수  (0) 2024.05.28
자료 배열 2 (9장)  (0) 2024.05.27
자료 배열 1 (8장)  (0) 2024.04.29
C,C++ - 제어문 (while, do~while문)  (0) 2024.04.08

예시로 먼저 학습하기

 

모든 값의 순위 저장하기

#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;
}

 

결과창

 

'프로그래밍 > C,C++' 카테고리의 다른 글

인수 전달하는 함수  (0) 2024.05.28
인수 전달하지 않는 함수  (0) 2024.05.27
자료 배열 1 (8장)  (0) 2024.04.29
C,C++ - 제어문 (while, do~while문)  (0) 2024.04.08
C,C++ - 반복문  (0) 2024.04.03

배열의 정의

같은 종류의 많은 자료를 하나의 이름으로 저장하는 연속된 기억장소

 

 

1차원 배열 예시

//선언//

double avg[1000];
int age[5];

 

//선언과 동시에 초기화//

int d[6] = { 31, 28, 31, 30, 31, 30 };
int sum[100] = { 0 }; // 첫 원소에는 0으로, 부족한 초깃값은 무조건 0으로 초기화//
int a[] = {1, 2, 3, 4, 5}

 

여기서 주의해야할 점이 있다.

int sum[100] = {1}

 

만약 위와 같이 입력이 된다면 어떻게 될까? {1}이라면 첫 원소는 1로, 부족한 값은 0으로 초기화한다.

 

또, int a[ ] 만 입력해도 오류가 뜨기에 조심해야한다.

반드시 int a[]  = {숫자, 숫자, 숫자, 숫자 ...} 의 형식으로 써야한다.

 

//원소 참소(사용)//

printf("%d, %d, %d, %d, %d, %d \n", d[0], d[1], d[2], d[3], d[4], d[5]);
scanf("%d", &d[4]);

 

위와 같이 원소를 참조할 때 사용하는 [ ] 안의 첨자는 해당 원소가 배열 시작 위치로부터 몇 개 뒤의 원소인지를 의미함.

 

 

 

 


 

 

 

반복문을 이용한 배열처리

다음과 같이 코드를 만들어서 배열 안에 들어있는 값을 출력할 수 있으나,

int mid[4] = { 45, 37, 48, 26 };

	printf("%d점 \n", mid[0]);
	printf("%d점 \n", mid[1]);
	printf("%d점 \n", mid[2]);
	printf("%d점 \n", mid[3]);

 

자료의 개수가 100, 1000개 넘어가는 대량의 경우에는 굉장히 비효율적인 코드가 되기에

앞으로 반복문을 사용하여 배열을 처리하고자 한다.

 

그리하여 위의 코드를 반복문을 사용하여 표현하면 다음과 같다.

for (i = 0; i < 4; i++)
{
    printf("%d점 \n", mid[i]);
}

 

 

 

매크로 상수 정의를 통한 효율적인 배열 처리

지금까지 사용한 #include<stdio.h>는 전처리기 지시자로 이는 프로그램에서 사용하는 라이브러리 함수에 필요한 헤더파일을 전처리기 지시자 자리에 포함하기 위한 것이다.

이와 비슷하게 앞으로 배열을 다루는 코딩에서는 #define 전처리기 지시자를 사용하여 배열의 크기(원소 개수)를 매크로 상수로 정의해서 사용하는 것이 필수적이다.

 

다음의 예시를 보자.

#include <stdio.h>
#define N 4

int main()
{
	int mid[N] = { 45, 37, 48, 26 }, i;


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

	return 0;
}

 

여기서 stdio.h 밑에 define N  4로 코드가 적혀있는데 이것이 의미하는 것이 밑에 int main() 안에 있는 코드에서 사용되는 N은 무조건 4로 입력된다는 얘기이다. 그 말은 만약 배열의 크기가 4에서 10으로 바뀐다면 그저 #define N 4를 #define N 10으로 고쳐주면 된다는 얘기이다. 

 

매크로 상수 이름은 모두 대문자를 사용하는 것이 관습이다.

 

# 주의! 매크로 상수는 C명령문이 아니므로 끝에 ;을 넣지 않는다!!!

 

 

 

예시를 통해서 학습하기

 

1월 ~ 12월 열두 달 중 31일까지 있는 달만 출력하기 (조건에 맞는 원소만 출력하기)

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

int main()
{
	int days[N] = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 }, i;
	printf("31일까지 있는 달은");

	for (i = 0; i < N; i++)
	{
		if (days[i] == 31)
			printf(" %d월", i + 1);
	}
	
	printf("입니다.");

	return 0;
}

 

 

수강생 20명의 학년별 인원수 구하기(조건에 맞는 원소 개수 구하기)

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

int main()
{
	int year[N] = { 1, 2, 2, 3, 4, 2, 3, 1, 3, 4, 2, 3, 3, 2, 3, 4, 3, 2, 2, 3 };
	int cnt1, cnt2, cnt3, cnt4, i;

	cnt1 = cnt2 = cnt3 = cnt4 = 0;
	for (i = 0; i < N; i++)
	{
		switch (year[i])
		{
			case 1: ++cnt1; break;
			case 2: ++cnt2; break;
			case 3: ++cnt3; break;
			case 4: ++cnt4; break;
		}
	}


	printf("%d학년: %d명\n", 1, cnt1);
	printf("%d학년: %d명\n", 2, cnt2);
	printf("%d학년: %d명\n", 3, cnt3);
	printf("%d학년: %d명\n", 4, cnt4);

	return 0;
}

 

 

배열의 평균과 중앙값 구하기 (직장인 11명의 평균 급여와 중앙값 구하기)

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

int main()
{
	int pay[N] = { 1500, 675, 400, 375, 320, 315, 270, 235, 200, 170, 150 };
	int sum, mid, i;
	double median, avg_pay;

	sum = 0;
	for (i = 0; i < N; i++)
	{
		sum += pay[i];
	}
	
	avg_pay = (double) sum / 11;
	
	mid = N / 2;
	if (N % 2 == 0)
	{
		median = (pay[mid - 1] + pay[mid]) / 2.0;
	}
	else
	{
		median = pay[mid];
	}

	printf("평균    급여: %.1lf만원\n", avg_pay);
	printf("중앙값  급여: %.1lf만원", median);

	return 0;
}

 

 

판매가 5개 중 최저가 구하기

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

int main()
{
	int i, min, cost[N] = { 9500, 9350, 9450, 9100, 9300 };

	printf("5곳의 판매가: ");

	min = cost[0];
	for (i = 1; i < N; ++i)
	{
		printf("%d ", cost[i]);
		
		if (cost[i] < min)
		{
			min = cost[i];
		}
	}

	printf("최저가: %d", min);

	return 0;
}

 

 

수험번호를 입력하여 합격 여부 확인하기

int main()
{
	int i, input_no;
	int pass_no[N] = { 3011, 2011, 4012, 2014, 3017, 4004, 3004, 2007, 4026, 3019 };

	printf("확인할 수험번호 입력 : ");
	scanf("%d", &input_no);

	for (i = 0; i < N; i++)
	{
		if (pass_no[i] == input_no)
		{
			break;
		}
	}

	if (i < N)
	{
		printf("%d번은 합격입니다.", input_no);
	}

	else
	{
		printf("%d번은 불합격입니다.", input_no);
	}

	return 0;
}

 

 

배열에서 많이 하는 실수

잘못된 예 이유와 해결
int mid[5];
mid = {94, 53, 31, 56, 97};
int mid[5] =  {94, 53, 31, 56, 97}; 선언과 동시에 초기화!

for 문을 이용하여 각 원소의 값을 입력받거나 대입문 5개를 사용해 해결 가능하다. 
printf("%d점 \n", mid); 반복문을 사용하여 mid[0] ~ mid[4]까지 각 원소 출력을 반복해야한다.

for (i = 0; i < 5; i++)
{
    printf("%d점 \n", mid[i])';
}
int i, a[ ] = {92, 89, 73};

for (i = 1; i <= 3; i++)
    printf("%d점 ", a[i]);
결과가 이상하게 나온다.
배열 원소 첨자는 항상 0부터 시작!!
그렇기에 for(i = 0; i < 3; i++)으로 수정해야한다. 

'프로그래밍 > C,C++' 카테고리의 다른 글

인수 전달하지 않는 함수  (0) 2024.05.27
자료 배열 2 (9장)  (0) 2024.05.27
C,C++ - 제어문 (while, do~while문)  (0) 2024.04.08
C,C++ - 반복문  (0) 2024.04.03
C,C++ -switch문  (1) 2024.04.03

while문은 조건식의 값이 참이면 문장을 반복 수행하고 거짓이면 반복을 중단한다.

 

 

while문 기본형식

 

while(조건식)

    반복할 문장;

 

 

조건식은 참, 거짓으로 계산되는 수식으로 관계 연산자나 논리 연산자를 사용한 수식이 일반적이다.

 

 

예시

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

int main()
{
	int i, sum = 0;

	i = 1;
	while (i <= 10)
	{
		sum = sum + i;
		i = i + 1;
	}
	printf("1부터 %d까지의 합은 %d입니다.", i-1, sum);

	return 0;
}

 

cf) while문을 시작할 때 처음부터 조건식의 값이 거짓일 경우에는 본체가 한번도 실행되지 않을 수 있다. 

 

 

while문으로 무한루프 만들기

while문으로 무한루프를 만들려면 조건식에 항상 참인 값을 사용.

0이 아닌 값은 모두 참이지만 보통은 while(1)처럼 1을 사용한다.

위의 while문은 다음과 같인 변형될 수 있다.

무한 루프를 빠져나오기 위해서는 for문과 마찬가지로 탈출조건 필요(break)

while(1)
{
    if (i > 10) break;
    sum += i;
    mult *= i;
    i++;
}

 

 

무조건 한 번은 반복하기 do~while문

 

do

{

    반복할 문장;

} while (조건식);

 

do는 무조건 뒤에 {}(중괄호)가 필요하다.

i = 1;
do{
   printf("***\n")
} while (i <= 100);

 

이게 유용한 이유는

코드는 제어문이 많을수록 가독성과 디버깅에 좋지 않기 때문이다.

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

int main()
{
	while (1)
	{
		printf("양수를 입력하세요. ");
		scanf("%d", &n);
		if (n > 0)
			break;
	}
}

 

이것보다

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

int main()
{
	do
	{
		printf("양수를 입력하세요.");
		scnaf("%d", &n);
		
		if (n > 0)
			break;
	} while (n <= 0);
}

 

이게 더 좋은 코드 왜냐면 제어문이 전자는 2개이고 후자는 1개이기에 

 

 

continue문

반복문을 실행하다가 continue문을 만나게 되면 continue 다음에 있는 문장은 수행하지 않고 루프의 시작이나 끝부분으로 이동한다. 즉, for문이나 while문과 같은 반복문에서 continue를 만나면 for이나 while의 시작부분으로 돌아가 조건식부터 다시 검사하게 되며, do~while문에서 continue를 만나면 do~while문의 끝에 있는 조건식을 검사하고 루프를 반복한다. 

 

 

오늘 내용 총 복습할 수 있는 예시

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

int main()
{
	int n, cnt, sum;

	sum = 0;
	cnt = 1;
	
	while (cnt <= 5)
	{
		printf("양의 정수를 입력하세요. ");
		scanf("%d", &n);

		if (n >= 0)
		{
			printf("%d번째: 지금까지의 합 %d + %d = ", cnt, sum, n);
			sum = sum + n;
			cnt = cnt + 1;
			printf("%d\n\n", sum);
		}

	}
}

'프로그래밍 > C,C++' 카테고리의 다른 글

자료 배열 2 (9장)  (0) 2024.05.27
자료 배열 1 (8장)  (0) 2024.04.29
C,C++ - 반복문  (0) 2024.04.03
C,C++ -switch문  (1) 2024.04.03
C,C++ - 제어문(if)  (0) 2024.04.03

반복문

 

기본형식

for (i = 1; i <= 5; ++i)
{
	printf("(%d %d) \n", i, i+1);
}


for (i = 1; i <= 9; i += 2)
{
	printf("(%d %d) \n", i, i + 1);
}

for (i = 50; i > 0; i = i - 10)
{
	printf("%d\n", i);
}

for (i = 1; i <= 4; ++i)
{
	printf("%d / %d = %.2lf\n", i, i + 1, (double)i / i + 1);
}

 

 

예시

n 팩토리얼 구하기(for 문)

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

int main()
{
	int i, n, fac;

	printf("n! 구하기, n은(0≤n≤10)? ");
	scanf("%d", &n);

	fac = 1;
	for (i = 1; i <= n; ++i)
	{
		fac = fac * i;
	}
	printf("%d! = %d", n, fac);

	return 0;
}

 

 

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

int main()
{
	int i, n;

	printf("2~9 중 얼마? ");
	scanf("%d", &n);

	printf("\n");

	for (i = 0; i < n; ++i)
	{
		printf("C프로그래밍 언어\n");
	}

	printf("\n");

	for (i = 1; i <= n; ++i)
	{
		printf("(%d) ", i);
	}

	printf("\n\n");

	for (i = 100; i <= n * 100; i += 100)
	{
		printf("%d, ", i);
	}
	printf("끝");

	return 0;
}

 

 

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

int main()
{
	int n, i, sum;

	printf("1~n 중 홀수의 합 구하기\n");
	printf("n 입력: ");
	scanf("%d", &n);

	sum = 0;
	for (i = 1; i <= 10; i = i + 2)
	{
		sum += i;
	}
	printf("\n");
	printf("홀수의 합은 %d", sum);

	return 0;
}

 

 

 

'프로그래밍 > C,C++' 카테고리의 다른 글

자료 배열 1 (8장)  (0) 2024.04.29
C,C++ - 제어문 (while, do~while문)  (0) 2024.04.08
C,C++ -switch문  (1) 2024.04.03
C,C++ - 제어문(if)  (0) 2024.04.03
C,C++ - 다양한 연산  (0) 2024.04.03

+ Recent posts