수업자료
기본세팅
세팅
오른쪽 마우스에서 속성 Alt + Enter
속성 페이지 -> C/C++ -> 일반 -> SDL검사 -> 아니요(/sdl-)
속성 페이지 -> C/C++ -> 전처리기 전처리 -> 정의에 추가
_DEBUG;_CONSOLE;%(PreprocessorDefinitions); _CRT_SECURE_NO_WARNINGS
끝에 ;(세미콜론) 꼭넣어주기
또는
#define _CRT_SECURE_NO_WARNINGS
#pragma warning(disable:4996)
■ 1월 14일 - 1일차
C언어의 기본
프로그래밍 언어
컴퓨터 시스템에서 구동하는 소프트웨어를
만들기 위해 사용하는 형식 언어
프로그래밍 언어 : 컴퓨터와 사람의 의사소통 수단
프로그래머의 명령을 처리하기 위해 필요함
C언어와 컴파일러
기계어 : 컴퓨터가 이해하는 명령
컴파일러 : C언어로 작성된 명령을 기계어로 번역
사용자 -> 컴파일러 -> 컴퓨터
C언어의 특징
(1) C언어는 절차지향언어
정해진 순서에 따라 실행
순서 = 코드의 진행 순서
(2) 프로그램 이식성이 좋다
컴퓨터의 CPU종류에 영향 받지 않는다.
운영체계에 큰 영향을 받지 않는다.
(3) 저급언어이다.
컴퓨터입장에서는 저급언어가 이해하기 수월하며
컴파일러에 의해 번역 및 전달이 간결하다
저급언어는 컴퓨터(기계)에 친화적
고급언어는 사용자에 친화적
Visual Studio 설치
(1) 구글에서 비주얼 스튜디오 검색
(2) 커뮤니티 2019 다운로드
(3) C++를 사용한 데스크톱 개발
(4) 설치 완료
프로젝트 생성
(1) 새 프로젝트 만들기
(2) 빈프로젝트, 프로젝트 이름 작성
(3) 프로젝트에서 솔루션 탐색기 소스파일에서 오른쪽 클릭
(4) 추가 - 새항목(Ctrl+Shift+A) - C++ 파일
(5) 이름 .c로 수정 // .cpp만들지 않기
솔루션 탐색기
보기 - 솔루션 탐색기 (Ctrl+Alt+L)
소스 파일 미실행
오른쪽 마우스 속성 - 일반 빌드에서 제외 예
아니면 프로젝트를 새로만들어도 됨
단축키
Ctrl + D 줄복사
Ctrl + L 줄삭제
Alt + 방향키 줄이동
Ctrl + Shift + / 주석처리
Ctrl + F7 컴파일 (빌드-컴파일)
F5 디버깅시작
C언어의 기초
#include <stdio.h> : 기본을 포함
int main(void){} main 함수로 {} 중괄호 안에가 실행
return : 데이터 반환 기본적으로 프로그램 종료
;(세미콜론) : 명령어 문장의 끝을 표시함
#include <stdio.h>
int main(void) {
printf("hello");
return 0;
}
// 출력 //
hello
주석
사용자 메모라고 인식하면 편함
// 한줄주석
/* */ 여러줄 주석
#include <stdio.h>
/*
수업시작
작성자 : 김영원
문자열 출력
*/
int main(void) {
printf("hello"); //hello 출력
// 메인 함수의 마지막 줄 return
return 0;
}변수
변수
메모리 공간에 붙여진 이름
이름을 붙여주면 그 이름을 통해 공간에 접근가능
변수의 선언 및 초기화
자료형 변수명 = 값
자료형 : 값의 유형 (정수,실수,문자 등)
변수명 : 변수가 들어간 곳의 이름
값 : 자료형에 맞게 작성된 값
자료형 변수명1 = 값; // 변수명1에 값을 넣어 선언과 동시 초기화
자료형 변수명2; // 변수명2 선언
변수명2 = 1; // 변수명2 초기화
변수명2 = 2; // 변수명2 값을 1에서 2로 변경
변수명 규칙
변수명의 이름은 알파벳 대소문자, 숫자, 언더바
변수의 이름은 숫자 시작 불가, 공백 포함 불가
이미 기능이 있는 키워드로 넣을수 없다
C는 대소문자 구분함
#include <stdio.h>
int main(void) {
int num = 1;
int Num = 1;
int num2 = 2;
int num2_val = 3;
// int hello boy = 1; //공백포함
// int hi# = 1; //
// int 2num = 1;
// int int = 1;
return 0;
}
변수의 출력 기본
printf("형식문자",변수명) : 변수의 값이 출력
형식문자 %d = 정수, %f = 실수, %c = 문자
형식문자가 틀리면 C언어에서는 무조건 오류
\n 한줄을 띄어줌
#include <stdio.h>
int main(void) {
int num1 = 1;
int num2 = 2;
printf("num1 = %d\n", num1);
printf("num2 = %d\n", num2);
return 0;
}
// 출력 //
num1 = 1
num2 = 2
자료형
자료형 : 데이터를 표현하는 방법
메모리 공간의 크기와 데이터의 형태를 정의 할 필요있음
자료형의 종류
자료형바이트비트저장 가능한 값의 범위
| 정수형 | |||
| short | 2 | 16 | -32,768 ~ 32,767 |
| int | 4 | 32 | -2,147,483,648 ~ 2,147,483,647(20억) |
| long | 4 | 32 | -2,147,483,648 ~ 2,147,483,647 |
| long long | 8 | 64 | -2^63 ~ 2^63-1(900경) |
| 실수형 | |||
| float | 4 | 32 | 1.175 e-38 ~ 3.40 e+38 |
| double | 8 | 64 | 2.225 e-308 ~ 1.7976 e+38 |
| long double | 8 이상 | ||
| 문자형 | |||
| char | 1 | 8 | -128 ~ 127(아스키코드) |
int와 long의 차이점
레지스터 : CPU내의 임시 기억장소로
int형은 CPU가 가장 효율적으로 다룰 수 있는 정수형으로 정의
32비트 운영체제에서는 int는 32비트 (4바이트)
64비트 운영체제에서는 int는 64비트 (8바이트)
long은 4바이트로 고정
size of 연산자
바이트 단위로 정수를 반환한다.
int num = 10;
size of(num) = 4;
#include <stdio.h>
int main(void) {
printf("100 = %d\n", sizeof(100));
printf("3.14 = % d\n", sizeof(3.14));
return 0;
}
// 출력 //
100 = 4
3.14 = 8
문자의 표현
아스키 코드에 맞게 문자표현
#include <stdio.h>
int main(void) {
int a = 65; // 대문자 A
int b = 49; // 숫자1
int c = 97; // 소문자 a
char d = 'b';
printf("%c \n", a);
printf("%c \n", b);
printf("%c \n", c);
printf("%c \n", d);
printf("%d \n", d);
return 0;
}
// 출력 //
1
a
b
98
정수 실수
#include <stdio.h>
int main(void) {
int a = 1;
float b = 1.3;
double c = 3.1;
long d = 100l;
printf("%d\n", a);
printf("%f\n", b);
printf("%f\n", c);
printf("%d\n", d);
return 0;
}
// 출력 //
1
1.300000
3.100000
100
상수
리터럴(L) 상수
값 자체로 고정된 상수
심볼릭 상수
상수에 이름을 붙여줌
const int a 1;
매크로상수
컴파일시 가장 먼저 매크로 상수를 처리
#define a = 10
#include <stdio.h>
#define a 1
int main(void) {
int b = 10;
const float c = 3.14;
b = 100;
// c = 1.25; // 상수는 값을 변화시킬수 없다
printf("%d\n", a);
printf("%d\n", b);
printf("%f\n", c);
return 0;
}
// 출력 //
1
100
3.140000
자료형의 변환
double a = 10; 10.0으로 변환
int a = 5.123; 5로변환
short a = 200; 200으로 변환 (Short로 변환)
#include <stdio.h>
int main(void) {
double a = 1;
int b = 2.14;
short c = 40000;
printf("%f\n", a);
printf("%d\n", b);
printf("%d\n", c);
return 0;
}
// 출력 //
1.000000
2
-25536기본 입출력
print 함수
제어문자
\n : 한줄 띄기, \t : 1탭 띄우기
' : 작은 따옴표, |" : 큰따옴표
? : 물음표, \ : 백슬래시
형식문자
%d : 정수, %o : 8진수, %x : 16진수
%f : 10진수 방식의 실수, %e 지수방식의 실수
%c : 값에 따라 대응 char, short, int
%s : 문자열, %p : 주소값, %% : %출력
기본 출력
#include <stdio.h>
int main(void) {
printf("i love c \n");
printf("우리나라 \\ \" \" \? 만세\n");
printf("안녕하세요\n제이름은\n누구입니다.\n\n");
int a = 20;
float b = 30.1;
printf("int a = %d\n", a);
printf("int a = %o\n", a);
printf("int a = %x\n", a);
printf("int b = %f\n", b);
printf("int b = %e\n", b);
return 0;
}
// 출력 //
i love c
우리나라 \ " " ? 만세
안녕하세요
제이름은
누구입니다.
int a = 20
int a = 24
int a = 14
int b = 30.100000
int b = 3.010000e+01
형식문자 출력
#include <stdio.h>
int main(void) {
int a = 123;
float b = 12.19231;
char c = 'c';
printf("%5d%d\n%%", a, a);
printf("%-5d%d\n", a, a);
printf("%10f다음%.2f\n", b, b);
printf("%5f다음%10.1f", b, b);
return 0;
}
// 출력 //
123123
%123 123
12.192310다음12.19
12.192310다음 12.2
연습문제 1
안녕하세요
저는
학생입니다.
printf("안녕하세요\n저는\n학생입니다.");
연습문제 2
int a = 30, b = 172
제 나이는 30세
키는 172cm입니다.
int a = 30, b = 172;
printf("제 나이는 %d세\n키는 %dcm입니다.",a,b);
연습문제 3
float a = 3.14159265
파이의 소수점 4째 자리 값 = 3.1416
float a = 3.14159265;
printf("파이의 소수점 4째 자리 값 = %.4f",a);
연습문제 4
"따옴표"
printf("\"따옴표\"");
연습문제 5
int a = 13
지금 지갑에 130,000원 있습니다.
int a = 13;
printf("지금 지갑에 %d0,000원 있습니다.",a);
연습문제 6
int a = 12345
int b = 120
두가지숫자(2칸공백)120,12345(2칸공백)입니다.
%연산자 사용 스페이스바 사용금지
int a = 12345;
int b = 120;
printf("두가지숫자%5d,%-7d입니다.",b,a);
연습문제 7
float a = 12.345
숫자(2칸공백)12.35,(2칸공백)12.345
float a = 12.345;
printf("숫자%7.2f,%8.3f",a,a);
연습문제 8
int a = 10
int b = 1000
a의 값은 = 10
b의 값은 = 1000
int a = 10;
int b = 1000;
printf("a의 값은 = %4d\nb의 값은 = %d",a,b);
맞춰서 떨어진다
int a = 10;
int b = 1000;
printf("a의 값은 = %6d\nb의 값은 = %6d",a,b);
연습문제 9
int a = 144
10진수 = 144
8진수 = 220
16진수 = 90
int a = 144;
printf("10진수 = %d\n8진수 = %o\n16진수 = %x",a,a,a);
scanf 함수
데이터 입력에 사용된다.
기본사용법
int num // 입력될 데이터가 저장될 메모리 공간, 즉 변수
scanf("%d",&num) // 키보드 입력된 정수를 저장 &엠버센드)
#include <stdio.h>
int main(void) {
char a;
int b;
float c;
printf("문자 입력 >> ");
scanf("%c", &a);
printf("정수 입력 >> ");
scanf("%d", &b);
printf("소수 입력 >> ");
scanf("%f", &c);
printf("%c, %d, %.2f",a,b,c);
return 0;
}
// 출력 //
문자 입력 >> as // 잘못입력시 에러
정수 입력 >> 소수 입력 >> a, -858993460, -107374176.00
연속된 입력
#include <stdio.h>
int main(void) {
char a1, a2, a3;
printf("3개 문자 입력 >> ");
scanf("%c %c %c", &a1, &a2, &a3);
printf("%c, %c, %c\n",a1,a2,a3);
int b1, b2, b3;
printf("3개 정수 입력 \n");
scanf("%d %d %d", &b1, &b2, &b3);
printf("%d, %d, %d\n", b1, b2, b3);
return 0;
}
// 출력 //
입력한 값이 출력
scanf 함수의 형변환
#include <stdio.h>
int main(void) {
int a1, a2, a3;
printf("세개의 정수 입력 : ");
scanf("%o %x %d", &a1, &a2, &a3);
printf("입력된 수 %d %d %d", a1, a2, a3);
return 0;
}
// 출력 //
세개의 정수 입력 : 11
11
11
입력된 수 9 17 11
응용문제 1
결과를 예측해보자
#include <stdio.h>
int main(void) {
printf("%10.3f\n", 152.49861);
printf("yoy\tcan\tmake\tit\n");
printf("\"Everybody say \'hello\'!\"");
return 0;
}
// 출력 //
152.499
yoy can make it
"Everybody say 'hello'!"
응용문제 2
별로 삼각형 만들기
#include <stdio.h>
int main(void) {
printf(" *\n ***\n *****\n*******\n");
return 0;
}
// 출력 //
*
***
*****
*******
응용문제 3
3.1435 입력 출력은 3
#include <stdio.h>
int main(void) {
int a;
printf("값을 입력하세요 : ");
scanf("%d", &a);
printf("입력값 : %d", a);
return 0;
}
// 출력 //
값을 입력하세요 : 3.1435
입력값 : 3
기본연산자
산술 연산자
연산자의미사용방법
| + | 더하기 | c = a+b |
| - | 빼기 | c = a-b |
| * | 곱하기 | c = a * b |
| / | 나누기 | c = a/b |
| % | 나머지 | c = a%b |
#include <stdio.h>
int main(void) {
int a1 = 7, a2 = 3;
printf("%d + %d = %d\n", a1, a2, a1 + a2);
printf("%d - %d = %d\n", a1, a2, a1 - a2);
printf("%d * %d = %d\n", a1, a2, a1 * a2);
printf("%d / %d = %d\n", a1, a2, a1 / a2);
printf("%d %% %d = %d\n", a1, a2, a1 % a2);
return 0;
}
// 출력 //
7 + 3 = 10
7 - 3 = 4
7 * 3 = 21
7 / 3 = 2
7 % 3 = 1
연습문제 1
정수 2개를 받아 더해주는 식 작성
정수1 >> 5
정수2 >> 3
5 + 3 = 8
int main(void) {
int a, b;
printf("정수1 >> ");
scanf("%d",&a);
printf("정수2 >> ");
scanf("%d",&b);
printf("%d + %d = %d", a,b,a+b);
return 0;
}
연습문제 2
정수 2개를 한번에 받아서 곱하기 작성
정수2개 입력 >> 3 5
3 x 5 = 15
int main(void) {
int a, b;
printf("정수2개 입력 >> ");
scanf("%d %d",&a, &b);
printf("%d x %d = %d", a,b,a*b);
return 0;
}
연습문제 3
정수 두개를 받아 몫과 나머지를 출력
정수2개 입력 >> 12 5
12 / 5 = 몫 2, 나머지 2
int main(void) {
int a, b;
printf("정수2개 입력 >> ");
scanf("%d %d",&a, &b);
printf("%d / %d = 몫 %d, 나머지 %d", a,b,a/b,a%b);
return 0;
}
연습문제 5
실수를 입력받아 정수부만 출력하시오
실수입력 >> 12.52
12
int main(void) {
float a;
printf("실수입력 >> ");
scanf("%f",&a);
printf("%d", (int)a);
return 0;
}
■ 1월 15일 - 2일차
연습문제 6
실수를 입력 받아 실수부분만 출력하시오
소수점 5자리
실수입력 >> 27.523
0.52300
int main(void) {
float a;
printf("실수입력 >> ");
scanf("%f", &a);
printf("%f", a-(int)a);
return 0;
}
연습문제 7
정수를 입력받아 1의자리를 출력
정수입력 >> 153
3
int main(void) {
int a;
printf("정수입력 >> ");
scanf("%d", &a);
printf("%d", a%10);
return 0;
}
연습문제 8
정수를 입력받아 10의 자리를 출력
정수입력 >> 123548
4
int main(void) {
int a;
printf("정수입력 >> ");
scanf("%d", &a);
printf("%d", a/10%10);
return 0;
}
연습문제 9
정수를 입력 받아 100의 자리 출력
정수입력 >> 123578
5
int main(void) {
int a;
printf("정수입력 >> ");
scanf("%d", &a);
printf("%d", a/100%10);
return 0;
}
연습문제 10
연필 1다스는 12개 입니다.
숫자를 입력을 받아 몇다스에 나머지가 몇인지 확인
연필 입력 >> 25
연필 2다스 1개
int a;
printf("연필 입력 >> ");
scanf("%d",&a);
printf("연필 %d다스 %d개", a/12,a%12);
return 0;
연습문제 11
초를 입력받아서
분과 초로 출력하기
초입력 >> 125
2분 5초
int main(void) {
int a;
printf("초입력 >> ");
scanf("%d", &a);
printf("%d분 %d초", a/60,a%60);
return 0;
}
연습문제 12
시간을 입력받아
일과 시간으로 나타내기
시간 입력 >> 80
3일 8시간
int main(void) {
int a;
printf("시간 입력 >> ");
scanf("%d", &a);
printf("%d일 %d시간", a/24,a%24);
return 0;
}
연습문제 13
정수 일을 입력받아
년과 일로 나타내기
일 입력 >> 2000
5년 175일
int main(void) {
int a;
printf("일 입력 >> ");
scanf("%d", &a);
printf("%d년 %d일", a/365,a%365);
return 0;
}
연습문제 14
정수를 입력받아 짝이면 0
홀이면 1을 출력하기
정수 >> 9
1
int main(void) {
int a;
printf("정수 >> ");
scanf("%d", &a);
printf("%d", a%2);
return 0;
}
대입 연산자
연산자예설명풀어쓴 형식
| = | a=1 | a에 1을 대입 | |
| += | a+=2 | a에 a더하기 2를 저장 | a = a + 2 |
| -= | a-=3 | a에 a빼기 3을 저장 | a = a - 3 |
| * = | a*=4 | a에 a 곱하기 4를 저장 | a = a * 4 |
| /= | a/=5 | a에 a 나누기 5의 몫을 저장 | a = a / 5 |
| %= | a%=6 | a에 a 나누기 6의 나머지 | a = a % 6 |
#include <stdio.h>
int main(void) {
int a1 = 3, a2 = 4;
a1 += 3; //a1 = a1 + 3
a2 *= 4; //a2 = a2 * 4
printf("a1 += 3 = %d\n", a1);
printf("a2 *= 4 = %d", a2);
return 0;
}
// 출력 //
a1 += 3 = 6
a2 *= 4 = 16
연습문제 1
대입연산자 사용
정수를 입력받아 5를 더한값을 출력
정수 입력 >> 20
25
int main(void) {
int a;
printf("정수 입력 >> ");
scanf("%d", &a);
printf("%d",a+=5);
return 0;
}
연습문제 2
대입연산자만 사용
정수를 입력받아 5로 나눈 나머지를 출력
정수 입력 >> 23
3
int main(void) {
int a;
printf("정수 입력 >> ");
scanf("%d", &a);
printf("%d",a%=5);
return 0;
}
연습문제 3
대입연산자만 사용
두수를 입력 받아 곱한 값 출력
정수 입력 >> 8 10
80
int main(void) {
int a,b;
printf("정수 입력 >> ");
scanf("%d %d", &a,&b);
printf("%d",a*=b);
return 0;
}
비교 연산자
둘을 비교하여 맞으면(1) 틀리면(0)
종류연산자사용법설명
| 같다 | == | a==b | a와 b가 같다. |
| 작다 | < | a<b | a가 b보다 작다 |
| 작거나 같다 | <= | a<=b | a가 b보다 작거나 같다. |
| 크다 | > | a>b | a가 b보다 크다 |
| 크거나 같다 | >= | a>=b | a가 b보다 크거나 같다 |
| 같지 않다 | != | a!= | a와 b가 같지 않다. |
#include <stdio.h>
int main(void) {
int a1 = 10, a2 = 11;
printf("a1 == a2 = %d\n", a1==a2);
printf("a1 > a2 = %d\n", a1>a2);
printf("a1 < a2 = %d\n", a1<a2);
printf("a1 >= a2 = %d\n", a1>=a2);
printf("a1 <= a2 = %d\n", a1<=a2);
printf("a1 != a2 = %d\n", a1!=a2);
return 0;
}
// 출력 //
a1 == a2 = 0
a1 > a2 = 0
a1 < a2 = 1
a1 >= a2 = 0
a1 <= a2 = 1
a1 != a2 = 1
연습문제 1
두수를 입력하여
먼저 작성한 수가 크면 1 출력
정수 입력 >> 11 8
1
int main(void) {
int a,b;
printf("정수 입력 >> ");
scanf("%d %d", &a,&b);
printf("%d",a>b);
return 0;
}
연습문제 2
두수를 입력하여
앞의 숫자의 제곱이
앞과 뒤의 숫자의 곱보다 크면 1
정수 입력 >> 9 8
1
int main(void) {
int a,b;
printf("정수 입력 >> ");
scanf("%d %d", &a,&b);
printf("%d",a*a>a*b);
return 0;
}
연습문제 3
두수를 입력하여
각각 3으로 나눈 나머지중
앞이 크면 1출력
정수 입력 >> 8 31
1
int main(void) {
int a,b;
printf("정수 입력 >> ");
scanf("%d %d", &a,&b);
printf("%d",a%3>b%3);
return 0;
}
증감연산자
연산자의미사용법설명
| ++ | 증가 연산자 | ++a, a++ | 변수a에 1을 더하여 a에 저장 |
| -- | 감소 연산자 | --a, a-- | 변수a에 1을 빼서 a에 저장 |
#include <stdio.h>
int main(void) {
int a = 10, b = 11;
printf("a : %d\n", a);
printf("a : %d\n", a++);
printf("a : %d\n", a);
printf("\n");
printf("b : %d\n", b);
printf("b : %d\n", ++b);
printf("b : %d\n", b);
return 0;
}
// 출력 //
a : 10
a : 10
a : 11
b : 11
b : 12
b : 12
연산자 우선순위
1 증감연산자 (++,--)
2 부호연산자 (+1, -1)
3 곱셈,나눗셈,나머지 (*,/,%)
4 덧셈, 뺄셈 (+,-)
5 대소비교 (<,>,<=,>=)
6 등가비교 (==,!=)
7 대입연산 (=, +=, -=) / 오른쪽에서 왼쪽
중요한것은 ()로써 우선순위를 먼저 정해주는게 필요
int main(void) {
int n1 = 3, n2 = 6;
int r = n1++ + n2 * 2;
printf("연산결과 = %d\n", r);
printf("n1 = %d", n1);
return 0;
}
// 출력 //
연산결과 = 15;
n1 = 4;
6*2 = 12
3+12 = 15
3 ++ = 4
연습문제 1-1
아래 내용은 어떻게 출력될지
상상해 보세요
int main(void) {
int a = 3;
int b = 6;
printf("%d",a++);
printf("%d",a++);
printf("%d",a++);
return 0;
}
// 출력 //
3
4
5
연습문제 1-2
아래 내용은 어떻게 출력될지
상상해 보세요
int main(void) {
int a = 3;
int b = 6;
printf("%d\n",a++);
printf("%d\n", a + b);
return 0;
}
// 출력 //
3
10
연습문제 1-3
아래 내용은 어떻게 출력될지
상상해 보세요
int main(void) {
int a = 3;
int b = 6;
printf("%d\n",--a);
printf("%d\n",a + b);
return 0;
}
// 출력 //
2
8
응용문제 1
실행결과 예상하기
int main(void) {
int n = 10;
n++;
printf("%d\n", n);
printf("%d\n", n+3);
printf("%d\n", ++n);
printf("%d\n", n++);
printf("%d\n", n);
return 0;
}
// 출력 //
11
14
12
12
13
응용문제 2
모두 1이 출력할 수 있도록 빈칸을 채워 봅시다
int main(void) {
int n = 27;
printf("%d\n", n 10);
printf("%d\n", n!=5);
printf("%d\n", n>=27);
printf("%d\n", n 27);
printf("%d\n", n 30);
printf("%d\n", n <=27);
return 0;
}
답
int main(void) {
int n = 27;
printf("%d\n", n>10);
printf("%d\n", n!=5);
printf("%d\n", n>=27);
printf("%d\n", n==27);
printf("%d\n", n<30);
printf("%d\n", n<=27);
return 0;
}
삼항 조건 연산자
형태 조건 ? 결과 1: 결과2
조건 : 참 또는 거짓을 반환하는 식 또는 값
결과1 : 참일경우 반환할 결과
결과2 : 거짓일경우 반환할 결과
int main(void) {
int a, r;
printf("정수 입력 >> ");
scanf("%d", &a);
r = a > 0 ? a : a * -1;
printf("절대값 = %d\n", r);
return 0;
}
// 출력 //
정수 입력 >> -10
절대값 = 10
비트 단위 연산자
연산자의미기능
| & | and | 대응하는 비트가 모두 1이면 1을 반환 아니면 0반환 |
| | | or | 대응하는 비트값중 하나라도 1이면 1을 반환 아니면 0반환 |
| ^ | xor | 대응하는 비트값이 서로 다르면 1 아니면 0반환 |
| ~ | not | 비트의 값이 1이면 0으로, 0이면 1로 반전시킨 결과를 반환 |
설명 &
0000 0001 (1)
0000 0111 (7)
0000 0001 (1)
printf("%d", 1 & 7); // 1
0000 0011 (3)
0000 0111 (7)
0000 0011 (3)
printf("%d", 3 & 7); // 3
0000 0011 (3)
0000 0110 (6)
0000 0010 (2)
printf("%d", 3 & 6); // 2
0000 0100 (8)
0000 0010 (4)
0000 0000 (0)
printf("%d", 8 & 4); // 0
설명 |
0000 1001 (9)
0000 0110 (6)
0000 1111 (15)
printf("%d", 9 | 6); //15
0000 1001 (9)
0000 0011 (3)
0000 1011 (11)
printf("%d", 9 | 3); //11
0001 1110 (20)
0000 1011 (11)
0001 1111 (31)
printf("%d", 20 | 11); //31
설명 ^
0000 0011 (3)
0000 0101 (5)
0000 0110 (6)
printf("%d", 3 ^ 5); // 6
0000 1111 (15)
0000 1001 (9)
0000 0110 (6)
printf("%d", 15 ^ 9); // 6
0000 1010 (10)
0000 0101 (5)
0000 1111 (15)
printf("%d", 10 ^ 5);
설명 ~
0000 0010 (2)
1111 1101
0000 0011 (3)
1111 1101 (-3)
printf("%d", ~2); // -3
시프트 연산자
연산자의미기능
| << | 왼쪽 시프트 | 왼쪽으로 n만큼 이동 |
| >> | 오른쪽 시프트 | 오른쪽으로 n만큼 이동 |
<< 왼쪽 시프트
2<<2
0000 0010 (2)
0000 1000 (8)
3<<1
0000 0011 (3)
0000 0110 (6)
3<<4
0000 0011 (3)
0011 0000 (48)
오른쪽 시프트
16>>1
0001 0000 (16)
0000 1000 (8)
32 >> 2
0010 0000 (32)
0000 1000 (8)
응용문제
응용문제 1
20살 이상이면 1250원 20살 미만이면 800원
삼항조건 연산자 사용
나이를 입력하세요 : 20
당신의 나이는 20이며, 요금은 1250입니다.
int main(void) {
int a, m;
printf("나이를 입력하세요 : ");
scanf("%d", &a);
m = a >= 20 ? 1250 : 800;
printf("당신의 나이는 %d이며, 요금은 %d입니다.", a, m);
return 0;
}
// 출력 //
나이를 입력하세요 : 20
당신의 나이는 20이며, 요금은 1250입니다.
응용문제 2
사용자로부터 나이와 키를 입력받아 나이가 12살 이상이고 키가 120cm 이상일 때만
놀이기구의 탑승을 허용하는 프로그램을 작성해 보세요
예
나이를 입력하세요 : 15
키를 입력하세요 : 160
놀이기구에 탑승할 수 있습니다.
나이를 입력하세요 : 11
키를 입력하세요 : 115
놀이기구에 탑승할 수 없습니다.
int main(void) {
int a, h;
printf("나이를 입력하세요 : ");
scanf_s("%d", &a);
printf("키를 입력하세요 : ");
scanf_s("%d", &h);
a >= 12 && h >= 120 ? printf("놀이기구에 탑승할 수 있습니다.\n") : printf("놀이기구에 탑승하실 수 없습니다.\n");
return 0;
}
응용문제 3
프로그램 실행 결과를 예상해 보세요
int main(void) {
int a = 3, b = 24;
printf("%d\n", a << 3); //24
printf("%d\n", b >> 3); //3
// 0000 0011 -> 0001 1000
// 0001 1000 -> 0000 0011
return 0;
}
종합문제
종합문제 1
두개의 정수를 입력받아 논리 연산과 비트연산을 하는 프로그램 작성
결과가 어떻게 나오는지 설명
n1 : 10
n2 : 3
결과
10 && 3 = 1
10 || 3 = 1
10 & 3 = 2
10 | 3 = 11
답
0이 아니면 모두 참
0000 1010 (10)
0000 0011 (3)
& 0000 0010 (2)
| 0000 1011 (11)
int main(void) {
int n1, n2;
printf("n1 : ");
scanf("%d",&n1);
printf("n2 : ");
scanf("%d",&n2);
printf("%d && %d = %d\n", n1, n2, n1 && n2);
printf("%d || %d = %d\n", n1, n2, n1 || n2);
printf("%d & %d = %d\n", n1, n2, n1 & n2);
printf("%d | %d = %d\n", n1, n2, n1 | n2);
return 0;
}
// 출력 //
n1 : 0
n2 : 1
0 && 1 = 0
0 || 1 = 1
0 & 1 = 0
0 | 1 = 1
종합문제 2
10진수 정수를 입력받고
이를 8진수와 16진수중 어떤것으로 출력할 지
입력받은 후 그 형태로 출력하는 프로그램 작성
10진수 정수 입력 : 10
몇 진수로 출력할 까요? 8진수는 1 입력, 16진수는 2 입력 : 1
결과 : 12
10진수 정수 입력 : 10
몇 진수로 출력할 까요? 8진수는 1 입력, 16진수는 2 입력 : 2
결과 : a
int main(void) {
int a, b;
printf("10진수 정수 입력 : ");
scanf("%d", &a);
printf("몇 진수로 출력할 까요? 8진수는 1 입력, 16진수는 2 입력 : ");
scanf("%d", &b);
b == 1 ? printf("결과 : %o", a) : printf("결과 : %x", a);
return 0;
}
종합문제 3
바구니에 복숭아 10개 담고
복숭아가 남으면 바구니를 1개 더 추가
복숭아의 개수를 입력 받아 바구니 수를 구하여
출력하는 프로그램 작성
int main(void) {
int a, b;
printf("복숭아의 개수는 : ");
scanf("%d", &a);
b = a % 10 == 0 ? a / 10 : a / 10 + 1;
printf("필요한 바구니의 수 : %d", b);
return 0;
}
// 출력 //
복숭아의 개수는 : 21
필요한 바구니의 수 : 3
종합문제 4
실수를 입력받은 다음
해당 데이터의 정수영역 중
가장 오른쪽 숫자를 출력하는 프로그램 작성
num : 126.12
6
int main(void) {
float a;
printf("num : ");
scanf("%f", &a);
printf("%d", (int)a % 10);
return 0;
}
// 출력 //
num : 126.12
6
종합문제 5
사용자로부터 초를 받아
시, 분, 초 형태로 출력하는 프로그램 작성
초를 입력하세요 : 3665
1시간 1분 5초
int main(void) {
int a;
printf("초를 입력하세요 : ");
scanf("%d",&a);
printf("%d시간 %d분 %d초", a/3600, (a/60)%60, a%60);
return 0;
}
// 출력 //
초를 입력하세요 : 3665
1시간 1분 5초
hour = x / 3600;
min = (x / 60) % 60; 또는 x%3600/60
sec = x % 60;
조건문
제어문
제어문 : 프로그램의 흐름을 제어하는 역활
조건문 : 주어진 조건의 결과에 따라 구문의 실행여부를 결정함
프로그램의 흐름을 바꾸는 구문
반복문 : 프로그램에서 똑같은 명령을 일정 횟수 만큼 반복하여 수행
제하하는 명령문으로 대부분의 코드는 반복적인 혀애가 많아 많이 사용됨
프로그램의 흐름을 설계하는 것으로 기초적인 사용법 외
숙련도도 중요하다. 프로그래밍 설계 능력은
코딩능력 및 모든 언어에서의 능력자체를 전체적으로
향상시키는 기본이다.
if문
조건에 따라 코드의 실행여부를 결정하는 문으로
사용방법은 다음과 같음
기본형태
if(조건){
조건을 만족할 경우 실행하는 내용 1
조건을 만족할 경우 실행하는 내용 2
}
삽입된 문장이 하나일 경우
if(조건) 조건을 만족할 경우 실행 할 문장;
기본예시
#include <stdio.h>
int main(void) {
int a = 5;
if (a > 0) printf("양수 입니다.\n");
if (a > 3) {
printf("a = 3보다 큰수입니다.\n");
printf("현재 a의 값은 %d입니다.", a);
}
return 0;
}
// 출력 //
양수 입니다.
a = 3보다 큰수입니다.
현재 a의 값은 5입니다.
기본예제 1
3보다 작은지, 3인지, 3보다 큰지를 비교하는
조건문 작성
int main(void) {
int a = 3;
if (a < 3) printf("a는 3보다 작습니다.\n");
if (a == 3) printf("a는 3입니다.\n");
if (a > 3) printf("a는 3보다 큽니다.\n");
return 0;
}
// 출력 //
a는 3입니다.
설명
첫번째 조건을 비교해보고 아니면 다음줄로 넘어감
두번째 조건을 비교해보고 맞아서 출력 다음으로 넘어감
세번째 조건을 비교해보고 아니면 다음줄로 넘어감
연습문제 1
변수 a가 양수인지를 판단.
맞으면 a는 양수입니다.
종료시 연산이 종료됩니다.
int main(void) {
int a = 3;
if (a < 0) {
printf("a는 양수입니다.\n");
}
printf("연산이 종료되었습니다.\n");
return 0;
}
// 출력 //
a는 양수입니다.
연산이 종료되었습니다.
연습문제 2
변수 a + 10이 10보다작으면
a는 음수입니다.
종료시 연산이 종료됩니다.
int main(void) {
int a = -1;
if (a+10 < 10) {
printf("a는 음수입니다.\n");
}
printf("연산이 종료되었습니다.\n");
return 0;
}
// 출력 //
a는 음수입니다.
연산이 종료되었습니다.
연습문제 3
변수 a * 2가 10보다 크면
a = 5보다 큰 수로 그 수를 10으로 곱하면 a(%d)입니다.
#include <stdio.h>
int main(void) {
int a = 6;
if (a*2 > 10) {
printf("a = 5보다 큰 수로 그 수를 10으로 곱하면 %d입니다.\n",a*10);
}
printf("연산이 종료되었습니다.\n");
return 0;
}
// 출력 //
a = 5보다 큰 수로 그 수를 10으로 곱하면 60입니다.
연산이 종료되었습니다.
연습문제 4
변수 a와 b를 비교하여
a가 크면 a(%d)가 b(%d)보다 큽니다. 출력
int main(void) {
int a = 8;
int b = 5;
if (a > b) {
printf("%d가 %d보다 큽니다.\n",a,b);
}
return 0;
}
// 출력 //
6이 5보다 큽니다.
연습문제 5-1
정수를 입력하세요 프린트 되고
변수 a에 정수를 입력하여
짝수인지를 확인하고 짝수이면
a(%d)는 짝수 입니다. 출력
int main(void) {
int a;
scanf("%d", &a);
if (a%2 ==0) {
printf("%d는 짝수입니다.\n",a);
}
return 0;
}
// 출력 //
정수를 입력하세요 >> 6
6는 짝수입니다.
연습문제 5-2
a가 짝수면 a는 짝수 입니다.
홀수면 a는 홀수 입니다를 출력
if문 두개
int main(void) {
int a;
printf("정수를 입력하세요 >> ");
scanf("%d", &a);
if (a%2 ==0) {
printf("%d는 짝수입니다.\n",a);
}
if (a % 2 != 0) {
printf("%d는 홀수입니다.\n", a);
}
return 0;
}
// 출력 //
정수를 입력하세요 >> 3
3는 홀수입니다.
연습문제 6
정수 두개를 입력하세요 출력
정수두개를 입력받아
둘을 비교하고
a가 크면 a-b가실행
b가 크면 b-a가실행
같으면 a-b가 실행
출력은
a와 b의 차이는 (%d)C입니다.
int main(void) {
int a, b;
printf("정수를 두개 입력하세요 >> ");
scanf("%d%d", &a,&b);
if (a>=b) {
printf("a와 b의 차이는 %d입니다.\n",a-b);
}
if (a<b) {
printf("a와 b의 차이는 %d입니다.\n",b-a);
}
return 0;
}
// 출력 //
정수를 두개 입력하세요 >> 5 11
a와 b의 차이는 6입니다.
간단히 변형
int main(void) {
int a, b, c;
printf("정수를 두개 입력하세요 >> ");
scanf("%d%d", &a,&b);
if (a>=b) {
c = a - b;
}
if (a<b) {
c = b - a;
}
printf("a와 b의 차이는 %d입니다.\n", c);
return 0;
}
중첩 if문
if문 안에 if문 작성하는 것
if(조건1){
조건1이 맞음
if(조건2){
조건1이 맞고 조건2가 맞음
}
}
else if(조건3){
조건1이 아니고 조건3이 맞음
}
else if 는 조건1에 대한 else if임
추가적으로 조건2의 if에
else if가 들어가면
조건1은 맞고 조건2가 아니면서
else if의 조건이 맞아야함
기본예제
int main(void) {
int num1 = 5, num2 = 8;
if (num2 > 5) {
if (num1 == 5) {
printf("첫번째 if 상태\n");
}
}
if (num2 < 5) {
if (num1 == 5) {
printf("두번째 if 상태\n");
}
}
else {
printf("두번째 if문 else\n");
}
return 0;
}
// 출력 //
첫번째 if 상태
두번째 if문 else
기본
int main(void) {
int a;
printf("정수 입력 >> ");
scanf("%d", &a);
if (a % 2 == 0) {
if (a < 10) {
printf("a는 10보다 작은 짝수");
}
else {
printf("a는 10보다 큰 짝수");
}
}
else {
if (a < 10) {
printf("a는 10보다 작은 홀수");
}
else {
printf("a는 10보다 큰 홀수");
}
}
return 0;
}
// 출력 //
정수 입력 >> 9
a는 10보다 작은 홀수
연습문제 1
1월, 3월, 5월, 7월, 8월, 10월, 12월 = 31일
4월, 6월, 9월, 11월 = 30일
2월 = 28일 (참고 4년에 한번 윤달로 29일)
월을 입력받아 일자를 출력
예시)
월을 입력하세요 >> 3
3월은 31일까지 있습니다.
힌트
7월 이하는 홀수가 31일 짝수가 30일
7월 초과는 짝수가 31일 홀수가 30일
31일은 7월 이하 이면서 홀수, 7월 초과 이면서 짝수
30일은 7월 이하 이면서 짝수, 7월 초과 이면서 홀수
2월은 28일
int main(void) {
int m,d;
printf("월 입력 >> ");
scanf("%d", &m);
if (m == 2) {
d = 28;
}
else if (m <= 7) {
if (m % 2 == 0) {
d = 30;
}
else {
d = 31;
}
}
else {
if (m % 2 == 0) {
d = 31;
}
else {
d = 30;
}
}
printf("%d월은 %d일 까지 있습니다.", m, d);
return 0;
}
// 출력 //
월 입력 >> 10
10월은 31일 까지 있습니다.
간단히 변경
int main(void) {
int m;
int d = 30;
printf("월 입력 >> ");
scanf("%d", &m);
if (m == 2) {
d = 28;
}
else if (m <= 7) {
if (m % 2 != 0) {
d = 31;
}
}
else {
if (m % 2 == 0) {
d = 31;
}
}
printf("%d월은 %d일 까지 있습니다.", m, d);
return 0;
}
변형2
int main(void) {
int m;
int d = 30;
printf("월 입력 >> ");
scanf("%d", &m);
if (m == 2) {
d = 28;
}
else if ((m <= 7 && m % 2 != 0) || (m > 7 && m % 2 == 0)) {
d = 31;
}
printf("%d월은 %d일 까지 있습니다.", m, d);
return 0;
}
■ 1월 15일 - 3일차
연습문제 2
세가지 점수를 받아
평균 60이상, 각과목별 40이상이 합격
두가지모두 만족해야함.
int main(void) {
int a=100, b=100, c=39;
float avg = (a + b + c) / (float)3;
if (avg>=60) {
if (a >= 40 && b >= 40 && c >= 40) {
printf("합격");
}
else {
printf("if 불합격");
}
}
else {
printf("불합격");
}
return 0;
}
// 출력 //
if 불합격
변경
int main(void) {
int a=60, b=60, c=60;
float avg = (a + b + c) / (float)3;
if (avg>=60 && (a >= 40 && b >= 40 && c >= 40)) {
printf("합격");
}
else {
printf("불합격");
}
return 0;
}
switch문
다양한 조건을 검사할 수 있게 만들어 놓은 것으로
하나의 변수나 수식에 대한 다양한 조건을 검사할 때
사용함.
기본형태
switch(표현식){
case 1:
표현식의 결과가 1일경우 실행
break;
case 2:
표현식의 결과가 2일경우 실행
break;
case 3:
표현식의 결과가 3일경우 실행
break;
default:
어떤 케이스에도 해당되지 않을 경우 실행
break;
}
기본예제
int main(void) {
int num = 1;
switch (num){
case 1:
printf("1\n");
break;
case 2:
printf("2\n");
break;
case 3:
printf("3\n");
break;
default:
printf("기타\n");
break;
}
printf("종료\n");
return 0;
}
// 출력 //
1
종료
순서를 변경했을때
아무 차이는 없다.
int main(void) {
int num = 1;
switch (num) {
case 3:
printf("3\n");
break;
case 2:
printf("2\n");
break;
case 1:
printf("1\n");
break;
default:
printf("기타\n");
break;
}
printf("종료\n");
return 0;
}
// 출력 //
1
종료
break 안넣었을 경우
int main(void) {
int num = 1;
switch (num) {
case 1:
printf("1\n");
case 2:
printf("2\n");
case 3:
printf("3\n");
default:
printf("기타\n");
}
printf("종료\n");
return 0;
}
// 출력 //
1
2
3
기타
종료
조건을 넣었을때
int main(void) {
int num = 1;
switch (num<10){
case 0:
printf("10보다 작지 않다\n");
break;
case 1:
printf("10보다 작다\n");
break;
default:
printf("기타\n");
break;
}
printf("종료\n");
return 0;
}
// 출력 //
10보다 작다
종료
활용(break 와 순서)
int main(void) {
int num = 5;
switch (num) {
case 1:
case 3:
case 5:
case 7:
case 9:
printf("홀수\n");
break;
case 2:
case 4:
case 6:
case 8:
printf("짝수\n");
break;
default:
printf("범위 벗어남\n");
break;
}
printf("종료\n");
return 0;
}
// 출력 //
홀수
종료
설명
num이 1이면 case 1을 만족하여
break가 없기 때문에 1,3,5,7,9에 있는 모든 것을 실행한다.
여기서는 마지막 홀수만 실행하면 되기때문에
실행할 내용을 지우고 마지막 case에서 홀수만 실행하고
break로 switch문을 빠져나감
연습문제 1
숫자를 입력받아
홀짝 구분 출력
int main(void) {
int a;
printf("숫자 입력 : ");
scanf("%d", &a);
switch (a%2==0) {
case 1:
printf("짝수");
break;
case 0:
printf("홀수");
break;
}
printf("종료\n");
return 0;
}
연습문제 2
1년 동안 읽은 책 입력
10권 미만 노력하세요
20권 미만 책을 즐기시네요
30권 미만 사랑하시네요
그외 다독왕입니다.
int main(void) {
int a;
printf("숫자 입력 : ");
scanf("%d", &a);
switch (a/10) {
case 0:
printf("노력");
break;
case 1:
printf("즐김");
break;
case 2:
printf("사랑");
break;
default:
printf("다독왕");
}
return 0;
}
응용문제 1
프로그램을 실행결과 예상
int main(void) {
int a = 3;
if (a == 2) {
printf("1 상태");
}
else if (a > 2 && a < 4) {
printf("2 상태");
}
else if (a == 3) {
printf("3 상태");
}
else {
printf("4 상태");
}
return 0;
}
// 출력 //
2 상태
응용문제 2
정수를 입력받아 홀짝 출력
예 정수를 입력하세요 : 3
입력한 정수는 홀수 입니다.
int main(void) {
int a;
printf("정수를 입력하세요 : ");
scanf("%d", &a);
if (a % 2 == 0) {
printf("입력한 정수는 짝수 입니다.");
}
else {
printf("입력한 정수는 홀수 입니다.");
}
return 0;
}
응용문제 3
지하철요금을 얼마 지불해야하는지 작성하세요
영유아및 노인 (6미만,65이상) 무료
어린이(6이상 13미만) 500
청소년(13이상,19미만) 900
일반 (19이상, 65미만) 1250
int main(void) {
int a, m;
printf("나이 입력 : ");
scanf("%d", &a);
if (a < 6 || a >= 65) {
m = 0;
}
else if (a < 13) {
m = 500;
}
else if (a < 19) {
m = 900;
}
else {
m = 1250;
}
printf("지하철 요금 %d원", m);
return 0;
}
응용문제 4
짱구의 중간고사 성적표
평균 점수를 구하고 학점을 출력
switch문 사용
학점 90이상 A
80이상 B
70이상 C
60이상 D
그외 F
int main(void) {
int s1=88, s2=90, s3=58, s4=81, s5=72;
double avg = (s1 + s2 + s3 + s4 + s5) / (float)5;
printf("평균 = %.2f 학점", avg);
switch ((int)avg / 10) {
case 10:
case 9:
printf("A");
break;
case 8:
printf("B");
break;
case 7:
printf("C");
break;
case 6:
printf("D");
break;
default:
printf("F");
}
return 0;
}
반복문
while문
~하는동안 즉 주어진 조건을 만족하는
동안에 특정한 문장들을 반복 실행
기본형태
while(조건){ 조건식에는 조건부분만 들어가야함
반복실행해야 하는 실행문
}
기본예제
int main(void) {
int i = 0;
while (i < 3) {
printf("숫자 %d", i);
i++;
}
return 0;
}
// 출력 //
숫자 0
숫자 1
숫자 2
연습문제1
*을 5개 출력하시오
int main(void) {
int i = 0;
while (i < 5) {
printf("*");
i++;
}
return 0;
}
// 출력 //
*****
연습문제2
1~5까지의 수를 출력하시오
int main(void) {
int i = 1;
while (i <= 5) {
printf("%d\n",i);
i++;
}
return 0;
}
// 출력 //
1
2
3
4
5
while문 안쪽에서 사용시 주의사항
int main(void) {
int i = 1;
while (i <= 5) {
int a = 0; // 계속 반복해서 0이됨!!
a += i;
printf("a = %d, i = %d\n",a,i);
i++;
}
return 0;
}
// 출력 //
a = 1, i = 1
a = 2, i = 2
a = 3, i = 3
a = 4, i = 4
a = 5, i = 5
1~5까지의 숫자 더하기 확인
int main(void) {
int i = 1;
int a = 0;
while (i <= 5) {
a += i;
printf("a = %d, i = %d\n",a,i);
i++;
}
printf("\na = %d, i = %d\n", a, i);
return 0;
}
// 출력 //
a = 1, i = 1
a = 3, i = 2
a = 6, i = 3
a = 10, i = 4
a = 15, i = 5
a = 15, i = 6
기본예제
입력된 숫자를 확인해서
정리해주는 예제임
int main(void) {
int i = 0;
while (i != -1) {
printf("숫자입력 -1종료 >> ");
scanf("%d", &i);
if (i == -1) {
printf("종료");
}
else{
printf("%d 입력\n", i);
}
}
return 0;
}
// 출력 //
숫자입력 -1종료 >> 5
5 입력
숫자입력 -1종료 >> 2
2 입력
숫자입력 -1종료 >> 1
1 입력
숫자입력 -1종료 >> -1
종료
무한루프
무한루프시 종료시키면 됨
Ctrl+C멈춤
조건이 항상 참이어서 에러
int main(void) {
int i = 0;
while (i < 3) {
printf("출력\n");
}
return 0;
}
조건을 계속 증가시켰지만 반복문안에서
값을 변경함에 따른 문제
int main(void) {
int i = 0;
while (i < 3) {
i = 0;
printf("출력\n");
i++;
}
return 0;
}
while문 밖과 안에서 동일한 변수명 선언
아무런 문제 없음 while문 안에있는
변수는 밖에 있는 변수와 다른것으로 인지
int main(void) {
int i = 0;
while (i < 3) {
int i = 10;
printf("출력 %d \n", ++i);
}
return 0;
}
의도적 무한루프문
int main(void) {
int i = 0;
while (1) {
printf("출력 %d \n", ++i);
}
return 0;
}
무한루프 기본예제
int main(void) {
int i;
while (1) {
printf("무한반복 숫자입력 : ");
scanf("%d", &i);
printf("% d 입력 \n", i);
}
return 0;
}
for문
for문 안에 반복되고 빠져서는 안되는
부분에 대해 작성해서 넣음
초기식 : 반복의 조건 검사를 사용하는 변수의 선언 및 초기화
조건식 : 반복의 조건을 검사하는 식
증감식 반복의 조건 검사시에 사용되는 변수의 증감
for(초기식;조건식;증감식){
반복문
}
기본 ++i와 i++차이가 없음
int main(void) {
for (int i = 1; i <= 3; i++) {
printf("%d \n", i);
}
return 0;
}
// 출력 //
1
2
3
밖에서 선언하면 초기식 작성 안해도됨
int main(void) {
int i = 1;
for (; i <= 3; i++) {
printf("%d \n", i);
}
return 0;
}
증감식 안에 넣으면 작성안해도됨
int main(void) {
int i = 1;
for (; i <= 3;) {
printf("%d \n", i++);
}
return 0;
}
증감식 다르게 작성해도됨
int main(void) {
int i = 1;
for (; i <= 3;i+=2) {
printf("%d \n", i); //1,3출력
}
return 0;
}
연습문제 1
0 ~ 4까지 출력하시오
int main(void) {
for (int i = 0; i < 5; i++) {
printf("%d \n", i);
}
return 0;
}
// 출력 //
0
1
2
3
4
연습문제 2
4 ~ 0까지 출력하시오
int main(void) {
for (int i = 4; i > -1; i--) {
printf("%d \n", i);
}
return 0;
}
// 출력 //
4
3
2
1
0
연습문제 3
한자리수의 2의 배수를 출력하시오
int main(void) {
for (int i = 2; i < 10; i+=2) {
printf("2의배수 %d \n", i);
}
return 0;
}
// 출력 //
2의배수 2
2의배수 4
2의배수 6
2의배수 8
연습문제 4
1~10까지의 합을 구하시오
int main(void) {
int a = 0;
for (int i = 1; i <= 10; i++) {
printf("%d까지의 합 : %d \n", i,a+=i);
}
return 0;
}
// 출력 //
1까지의 합 : 1
2까지의 합 : 3
3까지의 합 : 6
4까지의 합 : 10
5까지의 합 : 15
6까지의 합 : 21
7까지의 합 : 28
8까지의 합 : 36
9까지의 합 : 45
10까지의 합 : 55
이중 for문
int main(void) {
for (int i = 1; i <= 3; i++) {
for (int j = 1; j <= 4;j++) {
printf("i = %d, j = %d \n", i,j);
}
printf("\n -- 내부 for문 종료 -- \n\n");
}
return 0;
}
// 출력 //
i = 1, j = 1
i = 1, j = 2
i = 1, j = 3
i = 1, j = 4
-- 내부 for문 종료 --
i = 2, j = 1
i = 2, j = 2
i = 2, j = 3
i = 2, j = 4
-- 내부 for문 종료 --
i = 3, j = 1
i = 3, j = 2
i = 3, j = 3
i = 3, j = 4
-- 내부 for문 종료 --
연습문제 1
1과 2를 3줄에 걸쳐서
이중for문 사용하여 작성
int main(void) {
for (int i = 1; i <= 3; i++) {
for (int j = 1; j <= 2;j++) {
printf("j = %d ",j);
}
printf("\n");
}
return 0;
}
// 출력 //
j = 1 j = 2
j = 1 j = 2
j = 1 j = 2
연습문제 2-1
1일차 1교시 1일차 2교시 1일차 3교시
2일차 1교시 2일차 2교시 2일차 3교시
3일차 1교시
4일차 1교시
5일차 1교시
int main(void) {
for (int i = 1; i <= 5; i++) {
for (int j = 1; j <= 3;j++) {
printf("%d일차 %d교시 \t",i,j);
}
printf("\n");
}
return 0;
}
// 출력 //
1일차 1교시 1일차 2교시 1일차 3교시
2일차 1교시 2일차 2교시 2일차 3교시
3일차 1교시 3일차 2교시 3일차 3교시
4일차 1교시 4일차 2교시 4일차 3교시
5일차 1교시 5일차 2교시 5일차 3교시
연습문제 2-2
1일차 1교시 1일차 2교시 1일차 3교시
2일차 4교시 2일차 5교시 2일차 6교시
3일차 7교시 3일차 8교시 3일차 9교시
int main(void) {
int j = 1;
for (int i = 1; i <= 5; i++) {
for (; j <= i*3;j++) {
printf("%d일차 %d교시 \t",i,j);
}
printf("\n");
}
return 0;
}
// 출력 //
1일차 1교시 1일차 2교시 1일차 3교시
2일차 4교시 2일차 5교시 2일차 6교시
3일차 7교시 3일차 8교시 3일차 9교시
4일차 10교시 4일차 11교시 4일차 12교시
5일차 13교시 5일차 14교시 5일차 15교시
연습문제 2-3
2일차 1교시 …2교시 …3교시
4일차 4교시 …
6일차 …
int main(void) {
int j = 1;
int n = 1;
for (int i = 2; i <= 6; i+=2) {
for (; j <= n*3;j++) {
printf("%d일차 %d교시 \t",i,j);
}
printf("\n");
n++;
}
return 0;
}
// 출력 //
2일차 1교시 2일차 2교시 2일차 3교시
4일차 4교시 4일차 5교시 4일차 6교시
6일차 7교시 6일차 8교시 6일차 9교시
다른방법
int main(void) {
int a = 0;
for (int i = 2; i <= 6; i+=2) {
for (int j = 1; j <= 3;j++) {
printf("%d일차 %d교시 \t",i,a+=1);
}
printf("\n");
}
return 0;
}
연습문제 2-4
2일차 3교시 … 6교시 … 9교시
4일차 12교시
6일차 21교시
int main(void) {
int a = 0;
for (int i = 2; i <= 6; i+=2) {
for (int j = 1; j <= 3;j++) {
printf("%d일차 %d교시 \t",i,a+=3);
}
printf("\n");
}
return 0;
}
// 출력 //
2일차 3교시 2일차 6교시 2일차 9교시
4일차 12교시 4일차 15교시 4일차 18교시
6일차 21교시 6일차 24교시 6일차 27교시
연습문제 3-1
구구단
int main(void) {
for (int i = 2; i <= 9; i++) {
for (int j = 1; j <= 9;j++) {
printf("%dx%d=%2d ", i, j, i * j);
}
printf("\n");
}
return 0;
}
// 출력 //
2x1= 2 2x2= 4 2x3= 6 2x4= 8 2x5=10 2x6=12 2x7=14 2x8=16 2x9=18
3x1= 3 3x2= 6 3x3= 9 3x4=12 3x5=15 3x6=18 3x7=21 3x8=24 3x9=27
4x1= 4 4x2= 8 4x3=12 4x4=16 4x5=20 4x6=24 4x7=28 4x8=32 4x9=36
5x1= 5 5x2=10 5x3=15 5x4=20 5x5=25 5x6=30 5x7=35 5x8=40 5x9=45
6x1= 6 6x2=12 6x3=18 6x4=24 6x5=30 6x6=36 6x7=42 6x8=48 6x9=54
7x1= 7 7x2=14 7x3=21 7x4=28 7x5=35 7x6=42 7x7=49 7x8=56 7x9=63
8x1= 8 8x2=16 8x3=24 8x4=32 8x5=40 8x6=48 8x7=56 8x8=64 8x9=72
9x1= 9 9x2=18 9x3=27 9x4=36 9x5=45 9x6=54 9x7=63 9x8=72 9x9=81
연습문제 4-1
* 5 x 5 상자 만들기
int main(void) {
for (int i = 1; i <= 5; i++) {
for (int j = 1; j <= 5; j++) {
printf("*");
}
printf("\n");
}
return 0;
}
// 출력 //
*****
*****
*****
*****
*****
연습문제 4-2
삼각형
int main(void) {
for (int i = 1; i <= 5; i++) {
for (int j = 1; j <= i; j++) {
printf("*");
}
printf("\n");
}
return 0;
}
// 출력 //
*
**
***
****
*****
연습문제 4-3
역삼각형
int main(void) {
for (int i = 5; i >= 1; i--) {
for (int j = 1; j <= i; j++) {
printf("*");
}
printf("\n");
}
return 0;
}
// 출력 //
*****
****
***
**
*
연습문제 4-3
정삼각형
int main(void) {
for (int i = 1; i <= 5; i++) {
for (int j = 5; j >= i; j--) {
printf(" ");
}
for (int j = 1; j <= 2*(i-1)+1; j++) {
printf("*");
}
printf("\n");
}
return 0;
}
// 출력 //
*
***
*****
*******
*********
다른방식
int main(void) {
int a = 1;
for (int i = 1; i <= 5; i++) {
for (int j = 5; j >= i; j--) {
printf(" ");
}
for (int j = 1; j <= a; j++) {
printf("*");
}
a += 2;
printf("\n");
}
return 0;
}
연습문제 4-4
다이아몬드
#include <stdio.h>
int main(void) {
int a = 1;
for (int i = 1; i <= 5; i++) {
for (int j = 5; j >= i; j--) {
printf(" ");
}
for (int j = 1; j <= a; j++) {
printf("*");
}
a += 2;
printf("\n");
}
a -= 4; // a가 2개 더 커져 있고 다음줄 부터는 2개를 줄여야하기 때문
for (int i = 4; i >= 1; i--) { // 5째줄까지 극에 왔다가 4째줄 부터
for (int j = 5; j >= i; j--) {
printf(" ");
}
for (int j = 1; j <= a; j++) {
printf("*");
}
a -= 2;
printf("\n");
}
return 0;
}
// 출력 //
*
***
*****
*******
*********
*******
*****
***
*
다른 스타일
#include<stdio.h>
int main(void) {
for (int i = 0; i < 10; i++) {
for (int j = 0; j < 9 - i; j++) {
printf(" ");
}
for (int j = 0; j < 2*i+1; j++) {
printf("*");
}
printf("\n");
}
for (int i = 8; i >= 0; i--) {
for (int j = 0; j < 9 - i; j++) {
printf(" ");
}
for (int j = 0; j < 2 * i + 1; j++) {
printf("*");
}
printf("\n");
}
return 0;
}
다른 스타일
#include<stdio.h>
int main(void) {
for (int i = 0; i<5; i++) {
for (int j = 0; j<4-i; j++) {
printf(" ");
}
for (int k = 0; k < i * 2 + 1; k++) {
printf("*");
}
printf("\n");
}
for (int i = 3; i >= 0; i--) {
for (int j = 0; j < 4 - i; j++) {
printf(" ");
}
for (int k = 0; k < i * 2 + 1; k++) {
printf("*");
}
printf("\n");
}
return 0;
}
종합문제 5
피보타치 수열
1 1 2 3 5 8 13 21
입력받은 후 입력받은 정수의 개수만큼 출력
int main(void) {
int a = 0, b = 1, c, n;
printf("정수 입력 >> ");
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
printf("%d ", b);
c = b;
b += a;
a = c;
}
return 0;
}
// 출력 //
정수 입력 >> 10
1 1 2 3 5 8 13 21 34 55
연습문제
숫자를 자리수에 맞게 출력
예시 145243
1의 자리수 = 3
10의 자리수 = 4
100의 자리수 = 2
1000의 자리수 = 5
10000의 자리수 = 4
100000의 자리수 = 1
1의자리
int main(void) {
int a ;
printf("정수입력 : ");
scanf("%d", &a);
for (int i = a; i > 0; i = i / 10) {
printf("%d \n", i%10);
}
return 0;
}
// 출력 //
정수입력 : 45687
7
8
6
5
4
■ 1월 19일 - 4일차
배열
배열의이해
배열 : 다수의 데이터를 저장하고
처리하기 위해 사용하는 데이터 표현방법
동일한 타입의 여러개의 데이터를 묶음으로 관리
배열을 생성하면 인덱스 값이 붙어서 데이터를 관리.
인덱스 값 - 각 요소(저장공간)에 자동으로 붙는 번호
0부터 시작함
배열 선언
자료형 배열이름 [배열 길이]
int arr[3]
자료형 int
배열 이름 arr
배열의 길이 3
배열의 초기화 1
int arr [3] = {1,2,3};
배열의 초기화 2
int arr [] = {1,2,3,4};
배열의접근
arr[5] 인덱스 번호 사용
배열의 첫 번째 요소 값 읽기
printf("%d\n", arr[0];
배열의 개별 요소 초기화
arr[1] = 50; //배열의 두번째 요소 50으로 초기화
기본값은 쓰레기값
int main(void) {
int arr[2];
printf("%d, %d\n", arr[0],arr[1]);
return 0;
}
// 출력 //
-858993460, -858993460
초기화 1개 하면 나머지는 0으로
int main(void) {
int arr[3] = {1};
printf("%d, %d, %d\n", arr[0],arr[1],arr[2]);
printf("%d", arr[2] + 112);
return 0;
}
// 출력 //
1, 0, 0
112
초기화 3개
int main(void) {
int arr[3] = {2,5,7};
printf("%d, %d, %d\n", arr[0],arr[1],arr[2]);
return 0;
}
// 출력 //
2, 5, 7
주소값 확인
int main(void) {
int arr[2];
printf("%p\n", arr);
return 0;
}
// 출력 //
0000009CED0FF928
배열의 길이확인
열은 한번 생성하면 실행되는 동안 그 길이를 바꿀 수 없다.
배열은 상수임
?
메모리 공간이 있는데 int형 5자리라고 하면
5*4 = 20byte가 드는데
배열은 주소를 연속되게 갖고 있어야함
20byte의 공간에 맞는 메모리를 찾아서
그곳에 저장됨 그렇기 때문에 자동으로 변경되면은
메모리 공간을 다시 찾아야 함
int arr[] = {1,2,3}
sizeof(int) int byte
sizeof(arr) = 배열사이즈 * int
int main(void) {
int arr[] = {2,5,7};
printf("%d\n", sizeof(int));
printf("%d\n", sizeof(arr));
printf("%d\n", sizeof(arr)/4);
return 0;
}
// 출력 //
4
12
3
배열은 한번 생성하면 실행되는 동안 그 길이를 바꿀 수 없다.
배열은 상수임
왜?
메모리 공간이 있는데 int형 5자리라고 하면
5*4 = 20byte가 드는데
배열은 주소를 연속되게 갖고 있어야함
20byte의 공간에 맞는 메모리를 찾아서
그곳에 저장됨 그렇기 때문에 자동으로 변경되면은
메모리 공간을 다시 찾아야 함
공간이 부족하다면
새로운 큰 배열을 만들어서
작은 배열에 있는 것을 옮겨야 함
배열 초기화 for문 사용
int main(void) {
int arr[5];
for (int i = 0; i < 5; i++) {
arr[i] = i + 1;
}
for (int i = 0; i < 5; i++) {
printf("%d ",arr[i]);
}
}
// 출력 //
1 2 3 4 5
배열의 변화에 따른 사이즈 확인
int main(void) {
int arr[10];
int size = sizeof(arr) / 4;
for (int i = 0; i < size; i++) {
arr[i] = i + 1;
}
for (int i = 0; i < size; i++) {
printf("%d ",arr[i]);
}
}
// 출력 //
1 2 3 4 5 6 7 8 9 10
char 배열 확인
int main(void)
{
char a[] = {'h','e','l','l','o','w'};
printf("%s\n", a);
printf("%c\n", a[0]);
printf("%d",sizeof(a)); //char 1byte
return 0;
}
// 출력 //
hellow
h
6
문자열 변수 표현
문자열 : 문자 여러개가 1차원적으로
나열되어 있는 데이터를 의미
char a[] = "hello, c"
문자 확인
int main(void)
{
char a[] = "hellow";
printf("%s\n", a);
printf("%c\n", a[0]);
printf("%d",sizeof(a)); // 마지막 \0
return 0;
}
// 출력 //
hellow
h
7
배열길이 선정 후
출력할때 \0문자가 나올때까지
%s 문자열을 출력함으로 인하여 문제 발생
int main(void)
{
char a[50] = "hellow";
printf("%s\n", a);
printf("%d",sizeof(a));
return 0;
}
// 출력 //
hellow
50
배열 추가
int main(void)
{
char a[50] = "hellow";
a[6] = ' ';
a[7] = 'C';
printf("%s\n", a);
printf("%d",sizeof(a));
return 0;
}
// 출력 //
hellow C
50
크기 미지정
index 6번 이후 에러
int main(void)
{
char a[] = "hellow";
a[2] = 'a';
printf("%s\n", a);
printf("%d", sizeof(a));
return 0;
}
// 출력 //
healow
7
한글은 2byte + \0 1byte
int main(void)
{
char a[] = "안녕";
printf("%s\n", a);
printf("%d",sizeof(a));
return 0;
}
// 출력 //
안녕
5
문자열 저장
int main(void)
{
char a[50];
scanf("%s", a);
printf("%s",a);
return 0;
}
띄어 쓰기 저장
[ ]는 어떤 한 문자
^는 부정
[^\n]는 한줄 띄는것 제외
int main(void)
{
char a[50];
scanf("%49[^\n]", &a);
printf("%s",a);
return 0;
}
// 출력 //
안녕하세요 제 이름은
안녕하세요 제 이름은
배열관련 연습문제
연습문제 1
[ 0, 0, 0 ] 형태로 출력
#include<stdio.h>
int main(void) {
int a[30];
for (int i = 0; i < sizeof(a) / 4; i++) {
a[i] = i + 1;
if (i == 0) {
printf("[%d, ", a[i]);
}
else if (i == sizeof(a) / 4 - 1) {
printf("%d]", a[i]);
}
else {
printf("%d, ", a[i]);
}
}
return 0;
}
연습문제 2
배열로 평균구하기
92,88,86,79
총계 = xxx, 평균 = xx.xx
int main(void)
{
int arr[] = {92,88,86,79};
int size = sizeof(arr) / 4;
int sum = 0;
for (int i = 0; i < size;i++) {
sum += arr[i];
}
float avg = sum / (float)size;
printf("총계 = %d, 평균 = %.2f", sum, avg);
return 0;
}
// 출력 //
총계 = 345, 평균 = 86.25
연습문제 3
최대값 최소값 확인
int main(void)
{
int arr[] = {92,88,86,79};
int size = sizeof(arr) / 4;
int max = 0;
int min = 100;
for (int i = 0; i < size;i++) {
if (max < arr[i]) {
max = arr[i];
}
if (min > arr[i]) {
min = arr[i];
}
}
printf("최대값 = %d, 최소값 = %d", max, min);
return 0;
}
// 출력 //
최대값 = 92, 최소값 = 79
응용문제
응용문제 2
사용자로부터 영어단어 입력받아 char배열에 저장
그리고 배열에 저장된 단어를 역순으로 뒤집어 출력
int main(void)
{
char arr[20];
printf("영단어 입력 : ");
scanf("%s", &arr);
int size;
for (int i = 0; i < sizeof(arr); i++) {
if (arr[i] == '\0') {
size = i;
}
}
for (int i = size-1; i >= 0;i--) {
printf("%c", arr[i]);
}
return 0;
}
// 출력 //
hellow
wolleh
연습문제 1
배열에 기본값이 있는 상태에서
또다른 배열에 홀수만 저장하고 그후
뒤에 짝수를 저장하라
int main(void) {
int a[10] = { 11,22,35,47,59,62,71,83,98,100 };
int b[10] = { 0 };
int c = 0;
for (int i = 0; i < 10; i++) {
if (a[i] % 2 == 1) {
b[c++] = a[i];
}
}
for (int i = 0; i < 10; i++) {
if (a[i] % 2 == 0) {
b[c++] = a[i];
}
}
for (int i = 0; i < 10; i++) {
printf("%d ", b[i]);
}
return 0;
}
// 출력 //
11 35 47 59 71 83 22 62 98 100
연습문제 2
입력한 값이 1~9까지 입력되고
맞으면 종료해라
그리고 출력
int main(void) {
int a[3];
int s = sizeof(a) / 4;
int c = 0;
while (1) {
printf("입력 현재(%d/%d) >> ", c, s);
int b;
scanf("%d", &b);
if (b < 10 && b>0) {
a[c++] = b;
if (c == s) {
for (int i = 0; i < s; i++) {
printf("%d ", a[i]);
}
break;
}
}
}
return 0;
}
// 출력 //
입력 현재(0/3) >> 20
입력 현재(0/3) >> 0
입력 현재(0/3) >> 8
입력 현재(1/3) >> 5
입력 현재(2/3) >> 0
입력 현재(2/3) >> 7
8 5 7
응용문제 3
사용자로부터 영단어 입력받아서
아스키코드값이 가장 큰 문자 출력
int main(void)
{
char arr[20];
printf("영단어 입력 : ");
scanf("%s", &arr);
int size, max=0;
for (int i = 0; i < sizeof(arr); i++) {
if (max < arr[i]) {
max = arr[i];
}
}
printf("%c", max);
return 0;
}
// 출력 //
영단어 입력 : asdhjkashdugz
아스키코드값이 가장 큰 문자 = z
응용문제 4
배열안에 0이 아닌 숫자를 찾아서 앞에서 부터 체워줘
#include <stdio.h>
int main() {
int arr[8] = {0, 3, 0, 1, 0, 5, 7, 0};
int size = 8;
int idx = 0; // 다음에 넣을 위치
for (int i = 0; i < size; i++) {
if (arr[i] != 0) {
arr[idx++] = arr[i];
}
}
// 나머지 뒤를 0으로 채움
for (int i = idx; i < size; i++) {
arr[i] = 0;
}
// 출력
for (int i = 0; i < size; i++) {
printf("%d ", arr[i]);
}
return 0;
}
■ 1월 20일 - 5일차
포인터의 이해
포인터란
메모리의 주솟값을 의미
포인터변수란
주솟값을 저장하는 변수를 가리킴
포인터 변수를 사용하면 메모리 주소에 직접적으로 접근할 수 있음.
포인터라는 것은 주소값을 가보는 것이고
거기에 있는 값이 무엇인지 확인해보는 것임.
즉 참조하는 것을 찾는 것임.
포인터 변수의 선언
int* a;
int형 데이터가 저장된 메모리 공간의 포인터
즉 메모리 주소를 저장할 수 있는 포인터 변수를 선언
포인터 변수의 초기화
int num = 1;
int* a;
a = #
num은 정수형 데이터를 저장하는 변수
a는 정수형 데이터의 주소를 저장할 수 있는 포인터 변수
&num은 num변수가 저장되어있는 주소를 반환한다는 의미
즉 a에 num변수의 주솟값을 대입한다는 의미임.
&엠퍼샌드, * 에스터리스크
int main(void) {
char cn = 5;
int in = 100;
double dn = 3.14;
char* cp = &cn;
int* ip = ∈
double* dp = &dn;
printf("%p\n", cp);
printf("%p\n", ip);
printf("%p\n", dp);
return 0;
}
// 출력 //
0000005A6C5FF754
0000005A6C5FF774
0000005A6C5FF798
포인터 연산하기
& : 변수의 주솟값을 반환
* : 포인터가 가리키는 메모리를 참조
#include <stdio.h>
int main(void) {
int a = 1;
int* p = &a;
printf("a = %d \n", a);
*p = 5;
printf("p = %p \n", p);
printf("*p = %d \n", *p);
printf("a = %d \n", a);
return 0;
}
// 출력 //
a = 1
p = 000000B6860FFA64
*p = 5
a = 5
포인터 사용이유
주소연산, 참조연산 등을 수행해야 할때 사용하는게 좋음
또한 동적 할당 선언 및 동적 할당 메모리에 대한 접근시 좋음
응용문제
응용문제 1
코드 실행결과 예측
int main(void) {
int a = 10;
int* p = &a;
*p = 20;
printf("%d\n", a);
*p = 50;
printf("%d\n", a);
return 0;
}
// 출력 //
20
50
응용문제 2
빈칸 체우기
int main(void) {
int* ptr;
int num1 = 5;
int num2 = 8;
//
printf("%d\n", *ptr);
//
printf("%d\n", *ptr);
return 0;
}
// 출력 //
5
8
답
int main(void) {
int* ptr;
int num1 = 5;
int num2 = 8;
ptr = &num1;
printf("%d\n", *ptr);
ptr = &num2;
printf("%d\n", *ptr);
return 0;
}
포인터와 배열
배열의 주소확인
arr = &arr[0]
arr+1 = &arr[1]
&는 주소값이라는 것을 나타내는데
arr은 배열의 주소값이 들어가 있음
+1하면 배열하나의 크기만큼 주소가 더해져+1해주면
2번째 배열값이 있는 주소값과 동일한 곳을 선정해줌
int main(void) {
int arr[] = { 1,2,3 };
printf("arr = %p\n", arr);
printf("arr[0] = %p", &arr[0]);
printf("\n\n");
printf("arr+1 = %p\n", arr+1);
printf("arr[1] = %p", &arr[1]);
printf("\n\n");
printf("arr+2 = %p\n", arr + 2);
printf("arr[2] = %p", &arr[2]);
return 0;
}
// 출력 //
arr = 000000607F4FFCA8
arr[0] = 000000607F4FFCA8
arr+1 = 000000607F4FFCAC //4차이
arr[1] = 000000607F4FFCAC
arr+2 = 000000607F4FFCB0 //4차이
arr[2] = 000000607F4FFCB0
char는 1차이
int main(void) {
char arr[] = { 1,2,3 };
printf("arr = %p\n", arr);
printf("arr[0] = %p", &arr[0]);
printf("\n\n");
printf("arr+1 = %p\n", arr+1);
printf("arr[1] = %p", &arr[1]);
printf("\n\n");
printf("arr+2 = %p\n", arr + 2);
printf("arr[2] = %p", &arr[2]);
return 0;
}
// 출력 //
arr = 000000E1BCD4F774
arr[0] = 000000E1BCD4F774
arr+1 = 000000E1BCD4F775
arr[1] = 000000E1BCD4F775
arr+2 = 000000E1BCD4F776
arr[2] = 000000E1BCD4F776
long long
int main(void) {
long long arr[] = { 1,2,3 };
printf("arr = %p\n", arr);
printf("arr[0] = %p", &arr[0]);
printf("\n\n");
printf("arr+1 = %p\n", arr+1);
printf("arr[1] = %p", &arr[1]);
printf("\n\n");
printf("arr+2 = %p\n", arr + 2);
printf("arr[2] = %p", &arr[2]);
return 0;
}
// 출력 //
arr = 00000080ABCFF658
arr[0] = 00000080ABCFF658
arr+1 = 00000080ABCFF660
arr[1] = 00000080ABCFF660
arr+2 = 00000080ABCFF668
arr[2] = 00000080ABCFF668
값과 주솟값과 포인터 값 확인
int main(void) {
int arr[] = { 1,2,3 };
printf("arr[0] = %d\n", arr[0]);
printf("arr[1] = %d\n", arr[1]);
printf("arr[2] = %d\n", arr[2]);
printf("\n주소값\n\n");
printf("arr[0] = %p\n", &arr[0]);
printf("arr[1] = %p\n", &arr[1]);
printf("arr[2] = %p\n", &arr[2]);
printf("\n포인터 주소값\n\n");
printf("arr[0] = %d\n", *arr);
printf("arr[1] = %d\n", *(arr+1));
printf("arr[2] = %d\n", *(arr+2));
return 0;
}
// 출력 //
arr[0] = 1
arr[1] = 2
arr[2] = 3
주소값
arr[0] = 0000001A4B5BF7A8
arr[1] = 0000001A4B5BF7AC
arr[2] = 0000001A4B5BF7B0
포인터 주소값
arr[0] = 1
arr[1] = 2
arr[2] = 3
포인터 배열
int main(void) {
int n1 = 3, n2 = 6, n3 = 9;
int* p1 = &n1;
int* p2 = &n3;
int* p3 = &n3;
int* parr[3] = { p1,p2,p3 };
printf("%d, %d, %d \n", *parr[0], *parr[1], *parr[2]);
printf("%p, %p, %p \n", parr[0], parr[1], parr[2]);
return 0;
}
// 출력 //
3, 6, 9
000000C717EFF944, 000000C717EFF964, 000000C717EFF984
응용문제
응용문제 1
길이가 5인 배열 arr선언 10,20,30,40,50으로 초기화
이배열의 첫번째 요소를 가리키는 포인터 변수 ptr선언
포인터 변수 ptr에 저장된 값을 증가시키는 방식으로
배열의 모든 요소를 출력
int main(void) {
int arr[5] = { 10,20,30,40,50 };
int* ptr = arr;
printf("%d %d %d %d %d\n",*ptr, *(ptr+1), *(ptr+2), *(ptr+3), *(ptr+4));
for (int i = 0; i < 5; i++) {
printf("%d ", *(ptr + i));
}
return 0;
}
// 출력 //
10 20 30 40 50
10 20 30 40 50
응용문제 2
길이가 8인 배열 arr을 선언하고 1,2,3,4,5,6,7,8로 초기화 합니다.
이배열의 마지막 요소를 가리키는 포인터 변수 ptr을 선언
ptr에 저장된 값을 감소시키는 방식으로
배열의 모든 요소에 점근하여 배열 요소 중 홀수에
해당하는 값들의 총합을 구해 출력
int main(void) {
int arr[8] = { 1,2,3,4,5,6,7,8 };
int* ptr = &arr[7];
int sum = 0;
for (int i = 0; i < 8; i++) {
if (*(ptr - i) % 2 == 1) {
sum += *(ptr - i);
}
}
printf("배열 요소중 홀수의 총합은 : %d", sum);
return 0;
}
// 출력 //
배열 요소중 홀수의 총합은 : 16
사이즈가 변할 수 있을 경우
int main(void) {
int arr[] = { 1,2,3,4,5,6,7,8 };
int size = sizeof(arr) / sizeof(int);
int* ptr = &arr[size-1];
int sum = 0;
for (int i = 0; i < size; i++) {
if (*(ptr - i) % 2 == 1) {
sum += *(ptr - i);
}
}
printf("배열 요소중 홀수의 총합은 : %d", sum);
return 0;
}
응용문제 3
길이가 8인 배열 arr을 선언하고 1,2,3,4,5,6,7,8로 초기화 합니다.
첫번째 요소를 가리키는 포인터와, 마지막을 가리키는 포인터 선언
두 포인터 활용 arr요소가 역순으로 나열되도록 변경
int main(void) {
int arr[] = { 1,2,3,4,5,6,7,8,9 };
int* sp = arr;
int size = sizeof(arr) / sizeof(int);
int* ep = &arr[size-1];
for (int i = 0; i < size; i++) {
printf("%d ", arr[i]);
}
printf("\n");
for (int i = 0; i < size/2; i++) {
int temp = *(ep-i);
arr[size-(i+1)] = *(sp+i);
arr[i] = temp;
}
for (int i = 0; i < size; i++) {
printf("%d ", arr[i]);
}
return 0;
}
// 출력 //
1 2 3 4 5 6 7 8 9
9 8 7 6 5 4 3 2 1
연습문제
홀수면 뒤부터 짝수면 앞부터 저장
#include<stdio.h>
int main(void) {
int arr1[6] = { 1,7,9,2,8,11 };
int arr2[6] = { 0 };
int* sp = arr2;
int* ep = &arr2[5];
int si = 0, ei = 0;
for (int i = 0; i < 6; i++) {
if (arr1[i] % 2) {
ep[-(ei++)] = arr1[i];
// *(ep-(ei++)) = arr1[i];
}
else {
sp[si++] = arr1[i];
}
}
for (int i = 0; i < 6; i++) {
printf("%d ", arr2[i]);
}
return 0;
}
다차원 배열
2차원 이상의 배열을의미
배열의 요소가 선형적으로 나열되어 있는 형태
2차원 int arrs[5][3] : 세로 5, 가로 3인 2차원 배열
3차원 int arrt[2][3][4] : 높이 2, 세로 3, 가로 4인 3차원 배열
배열선언
int a[][] = {{1},{2}}; 불가
int a[2][1] = {{1},{2}}; 가능
int main(void) {
int arrs[2][2] = { {1,2}, {3,4} };
printf("%d\n", arrs[0][0]);
printf("주소 [0][0] = %p\n", &arrs[0][0]);
printf("주소 [1][0] = %p\n", &arrs[1][0]); //8차이
int arrt[2][2][2];
printf("주소 [0][0][0] = %p\n", &arrt[0][0][0]);
printf("주소 [1][0][0] = %p\n", &arrt[1][0][0]); //16차이
int arr1[3] = {1};
printf("%d\n", arr1[1]);
int arr2[2][3] = { {1,2},{3,4} };
printf("%d\n", arr2[0][2]);
return 0;
}
// 출력 //
1
주소 [0][0] = 000000775639F988
주소 [1][0] = 000000775639F990
주소 [0][0][0] = 000000775639F9B8
주소 [1][0][0] = 000000775639F9C8
0
0
다차원 배열 보기 좋게 선언
int main(void) {
int a[2][3] = {
{1,2,3},
{4,5,6}
};
int b[2][3][4] = {
{
{1,2,3,4},
{5,6,7,8},
{9,10,11,12}
},
{
{13,14,15,16},
{17,18,19,20},
{21,22,23,24}
}
};
return 0;
}
2차원 배열의 저장과 출력
2차원 배열의 사이즈 확인
int main(void) {
int a;
int arr[2][3];
printf("%d\n",sizeof(arr)/4); //2*3 = 6
printf("%d\n",sizeof(arr[0]) / 4); // 3
printf("%d\n", sizeof(arr) / sizeof(arr[0])); // 24/12 = 2
return 0;
}
// 출력 //
6
3
2
2차원 배열 1~배열 사이즈 만큼 저장 후 출력
int main(void) {
int c = 1;
int arr[2][3];
int si = sizeof(arr) / sizeof(arr[0]);
int sj = sizeof(arr[0]) / 4;
for (int i = 0; i < si; i++) {
for (int j = 0; j < sj; j++) {
arr[i][j] = c;
c++;
}
}
for (int i = 0; i < si; i++) {
for (int j = 0; j < sj; j++) {
printf("%d ", arr[i][j]);
}
printf("\n");
}
return 0;
}
// 출력 //
1 2 3
4 5 6
사이즈 확대
int arr[5][10];
// 출력 //
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 32 33 34 35 36 37 38 39 40
41 42 43 44 45 46 47 48 49 50
■ 1월 21일 - 6일차
배열 포인터
포인터 변수를 요소로 가지는 배열을 의미함
int a[2][5]; 에서 주소값 확인
int main(void) {
int a[2][5];
printf("%p\n", &a);
printf("%p\n", &a[0]);
printf("%p\n", &a[1]);
return 0;
}
// 출력 //
00000097A715F778
00000097A715F778
00000097A715F78C
16진수계산
0,1,2,3,4,5,6,7,8,9,a,b,c,d,e,f
16증가하면 10의 자리에 1증가
4증가 8에서 4증가 c
즉 16진수 78에서 20이 증가하면
8C
int main(void) {
printf("\n");
printf("%x\n", 8+20);
return 0;
}
// 출력 //
1c
a배열을 포인터에 넣어서 출력 하면
int* p = &a;
printf("%p\n", p);
printf("%p\n", p+1);
// 출력 //
000000C4E936F6B8
000000C4E936F6BC //4증가
주소값에 있는거 확인하고 싶으면
int main(void) {
int a[2][5];
int* p = &a;
printf("%p\n", p);
printf("%p\n", p+1);
printf("========\n");
a[0][0] = 1;
a[0][1] = 100;
printf("%d\n", *p);
printf("%d\n", *(p + 1));
return 0;
}
// 출력 //
000000DE5C51F578
000000DE5C51F57C
========
1
100
배열포인터
int(*p)[5] = a;
int main(void) {
int a[2][5];
int(* p)[5] = a;
printf("%p\n", p);
printf("%p\n", a[0]);
printf("========\n");
printf("%p\n", p+1);
printf("%p\n", a[1]);
return 0;
}
// 출력 //
00000058B20FF608
00000058B20FF608
========
00000058B20FF61C
00000058B20FF61C
주소값 확인
int main(void) {
int a[2][5];
int(*p)[5] = a;
printf("%p\n", p);
printf("%p\n", p[0]);
printf("%p\n", &p[0][0]);
return 0;
}
// 출력 //
000000F6012FF568
000000F6012FF568
000000F6012FF568
==
1
10
주소값확인
int main(void) {
int a[2][5];
int(*p)[5] = a;
printf("%p\n", p);
printf("%p\n", p[0]);
printf("%p\n", &p[0][0]);
printf("==\n\n");
printf("%p\n", &a[1]);
printf("%p\n", p+1);
printf("%p\n", p[1]);
printf("%p\n", &p[1][0]);
return 0;
}
// 출력 //
00000012CB6FF7A8
00000012CB6FF7A8
00000012CB6FF7A8
==
00000012CB6FF7BC
00000012CB6FF7BC
00000012CB6FF7BC
00000012CB6FF7BC
포인터배열 과 배열 포인터
int main(void) {
int a[2][5];
int(*p)[5] = a;
int* p2[5] = { &a[0][0],&a[0][1],&a[0][2],&a[0][3],&a[0][4] };
printf("%p\n", p[0]);
printf("%p\n", p2[0]);
printf("%p\n", &p[0][1]);
printf("%p\n", p2[1]);
return 0;
}
// 출력 //
000000CEC9D4F618
000000CEC9D4F618
000000CEC9D4F61C
000000CEC9D4F61C
int (*p) [5] = a;
p= 5개짜리 배열을 저장하고 있는 배열 포인터
int main(void) {
int a[2][5];
int(*p)[5] = a;
a[0][0] = 1;
a[1][0] = 100;
printf("%d\n", *p[0]);
printf("%d\n", *p[1]);
a[0][1] = 2;
printf("===\n\n");
printf("%d\n", p[0][0]);
printf("%d\n", p[0][1]);
return 0;
}
// 출력 //
1
100
===
1
2
배열 포인터 차원증가
int main(void) {
int a[2][5][2];
int(*p)[5][2] = a;
a[0][0][0] = 1;
a[1][0][0] = 100;
printf("%d\n", *p[0][0]);
printf("%d\n", *p[1][0]);
a[0][0][1] = 2;
printf("===\n\n");
printf("%d\n", p[0][0][0]);
printf("%d\n", p[0][0][1]);
return 0;
}
// 출력 //
1
100
===
1
2
주소값
int main(void) {
int a[2][5][2];
int(*p)[5][2] = a;
printf("%p\n", p[0][0]);
printf("%p\n\n", &a[0][0]);
printf("%p\n", p[1][0]);
printf("%p\n", &a[1][0]);
return 0;
}
// 출력 //
000000729DBBF860
000000729DBBF860
000000729DBBF888
000000729DBBF888
주소값 심화
int main(void) {
int a[2][5][2];
int(*p)[5][2] = a;
printf("%p\n", p[0][0]);
printf("%p\n", p[0]);
printf("%p\n\n", &a[0][0][0]);
printf("%p\n", p + 1);
printf("%p\n", p[1]);
printf("%p\n\n", &a[1][0][0]);
printf("%p\n", p[0] + 1);
printf("%p\n", p[0][1]);
printf("%p\n", &a[0][1][0]);
return 0;
}
// 출력 //
000000618FB6F5B0
000000618FB6F5B0
000000618FB6F5B0
000000618FB6F5D8
000000618FB6F5D8
000000618FB6F5D8
000000618FB6F5B8
000000618FB6F5B8
000000618FB6F5B8
응용문제
응용문제 1
행 3, 열 3인 char형 2차원 배열 bingo를 선언하고 다음과 같이 값이
저장되도록 프로그램을 작성해 보세요. 단 선언과 동시에 초기화하지 않고
선언 이후에 따로 초기화를 진행하세요.
O X X
X O X
X X O
for문의 중첩을 사용해 보세요.
int main(void) {
char b[3][3];
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 3; j++) {
if (i == j) {
b[i][j] = 'O';
}
else {
b[i][j] = 'X';
}
}
}
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 3; j++) {
printf("%c ", b[i][j]);
}
printf("\n");
}
return 0;
}
// 출력 //
O X X
X O X
X X O
발전
X X X
O O O
X X X
if (i == 1) {
b[i][j] = 'O';
}
응용문제 2
행 4, 열 9인 2차원 배열을 선언하고, 배열의 각 요소에 구구잔 2단부터
5단까지의 결과를 저장하세요. 하나의 행이 하나의 단을 의미합니다. 저장을
마친 후 모든 요소를 다음과 같이 출력하는 프로그램을 작성해 보세요.
2 4 6 8 10 12 14 16 18
3 6 9 12 15 18 21 24 27
4 8 12 16 20 24 28 32 36
5 10 15 20 25 30 35 40 45
int main(void) {
int a[4][9];
for (int i = 0; i < 4; i++) {
for (int j = 0; j < 9; j++) {
a[i][j] = (i + 2) * (j + 1);
printf("%d ", a[i][j]);
}
printf("\n");
}
return 0;
}
응용문제 3
결과 예상
#include <stdio.h>
int main(void) {
int arr[3][2] = { {6, 7}, {8, 9}, {3, 4} };
printf("%d %d\n", arr[1][0], arr[0][1]); // 8 7
printf("%d %d\n", *(arr[2] + 1), *(arr[1] + 1)); //4 9
printf("%d %d\n", (*(arr + 2))[0], (*(arr + 0))[1]); // 3 7
printf("%d %d\n", **arr, *(*(arr + 0) + 0)); // 6 6
return 0;
}
// 출력 //
8 7
4 9
3 7
6 6
문자열과 함수
문자와 문자열
기본적인 문자열표현
int main(void) {
char a[] = "hellow";
printf("%c\n", a[1]);
printf("%s\n", a);
return 0;
}
// 출력 //
e
hellow
문자열 표현의 변화
문자열은 배열을 기반으로 정의할 수 있는 데이터
배열의 이름은 첫번째 요소의 주소를 의미
다음과 같이 진행 가능
int main(void) {
char *a = "good";
printf("%c\n", a[1]);
printf("%s\n", a);
return 0;
}
// 출력 //
o
good
포인터 기반의 문자열 제한
포인터 기반 문자열은
개별 요솟값 할당 불가능
배열 기반의 문자열 변수
변수형태의 문자열 이라고 함
포인터 기반의 문자열 변수
상수 형태의 문자열 이라고 함
int main(void) {
char *a = "good";
char b[] = "nice";
// a[0] = 'h'; // 에러
b[0] = 'g';
a = "hello";
printf("%s, %s\n", a, b);
printf("%c, %c", a[0], b[0]);
return 0;
}
// 출력 //
hello, gice
h, g
문자열 관련 함수
putchar(출력문자); // 문자정보 출력
getchar(); // 입력데이터 반환
int main(void) {
int ch1, ch2;
ch1 = getchar();
ch2 = getchar();
putchar(ch1);
printf("\n");
putchar(ch2);
return 0;
}
// 출력 //
asda
a
s
변형
int main(void) {
double ch1, ch2;
ch1 = getchar();
ch2 = getchar();
putchar(ch1);
printf("\n");
putchar(ch2);
return 0;
}
// 출력 //
asdf
a
s
출력확인
int main(void) {
double ch1, ch2;
ch1 = getchar();
ch2 = getchar();
printf("%d\n", ch1);
putchar(ch1);
printf("\n");
putchar(ch2);
return 0;
}
// 출력 //
asdf
0
a
s
인트형태 출력
int main(void) {
int ch1, ch2;
ch1 = getchar();
ch2 = getchar();
printf("%d\n", ch1);
putchar(ch1);
printf("\n");
putchar(ch2);
return 0;
}
// 출력 //
12
49
1
2
for문형태로 변경
int main(void) {
int ch;
for (int i = 0; i < 10; i++) {
ch = getchar();
putchar(ch);
}
return 0;
}
// 출력 //
hellomynameiskim
hellomynam
안녕하세요제이름은
안녕하세요
무한 반복문 형태로 변경
EOF End Of File
표준상수로 문자를 입력할때 입력이 종료되었음을 의미
키보드로 문자를 입력하고 Ctrl + Z 로 반환
int main(void) {
int ch;
for (;;) {
ch = getchar();
if (ch == EOF) {
break;
}
putchar(ch);
}
return 0;
}
// 출력 //
asd
asd
as
as
^Z
문자열 단위 입출력 함수
puts(출력할 문자열);
gets(pointer)
gets함수는 키보드로 입력되는 문자열을
인자로 전달된 주소에 저장함
문자열 끝에 자동으로 널 문자 삽입
int main(void) {
char ch[30]; //개수 넘으면 에러
gets(ch);
puts(ch);
printf("%s",ch);
return 0;
}
// 출력 //
asdasd
asdasd
asdasd
int로 해도 상관없음
int main(void) {
int ch[30];
gets(ch);
puts(ch);
printf("%s",ch);
return 0;
}
// 출력 //
asdaasd
asdaasd
asdaasd
문자열 처리함수
문자열 처리함수 쓰기전
#include <string.h>
strlen(str)
문자열 길이출력
#include <stdio.h>
#include <string.h>
int main(void) {
int* a1 = "apple is good";
char a2[50] = "good";
printf("%d, %d\n", strlen(a1), strlen(a2));
printf("%s, %s",a1,a2);
return 0;
}
// 출력 //
13, 4
apple is good, good
strcpy() , strncpy()
strcpy()
2번째 문자열을 1번째에 복사
char a[] 배열로 넣어야 함
strncpy()
2번째 문자열을 1번째에 3번째 숫자만큼 복사
마지막 \0값을 넣어줘야 확인 가능
int main(void) {
char a1[50] = "apple is good";
char a2[50] = "abcde";
char b1[50], b2[50];
strcpy(b1, a1);
strcpy(b2, a1);
strncpy(b2, a2, 4);
printf("%s\n%s",b1,b2);
return 0;
}
// 출력 //
apple is good
abcde is good
strcat(), strncat()
문자열을 붙임, n은 몇개
int main(void) {
char a1[50] = "apple";
strcat(a1, " hello");
printf("%s\n",a1);
strncat(a1, " abcdef",3);
printf("%s\n",a1);
return 0;
}
// 출력 //
apple hello
apple hello ab
strcmp(), strncmp()
문자열 비교, n은 몇개
다를경우 -a 컴파일러마다 다름
같을경우 0 반환
int main(void) {
char a1[50] = "apple";
char a2[50] = "apple abc";
printf("cmp : %d\n", strcmp(a1, a2));
printf("ncmp : %d\n", strncmp(a1, a2,5));
return 0;
}
// 출력 //
cmp : -1
ncmp : 0
응용문제
응용문제 1
사용자로부터 두 개의 이름(문자열)을 입력받아
두 이름이 같은지 또는 같지 않은지를 알려주는
프로그램을 작성해 보세요.
int main(void) {
char a1[20];
char a2[20];
gets(a1);
gets(a2);
if (strcmp(a1, a2) == 0) {
puts("같습니다.");
}
else {
puts("같지 않습니다.");
}
return 0;
}
// 출력 //
리오넬 메시
리오넬 메시
같습니다.
응용문제 2
두개의 문자열을 입력받아 길이가
긴 문자열부터 순서대로 출력하는 프로그램을 작성해 보세요.
int main(void) {
char a1[20];
char a2[20];
gets(a1);
gets(a2);
if (strlen(a1) >= strlen(a2)) {
puts(a1), puts(a2);
}
else {
puts(a2), puts(a1);
}
return 0;
}
// 출력 //
hello
i love you
i love you
hello
응용문제 3
적당한 길이의 문자열을 입력받아 그 안에 존재하는 숫자(1-9)까지의
총합을 출력하는 프로그램을 작성해 보세요.
입력된 문자열에는 문자, 숫자, 기호등이 섞여있을 수 있으며
실행 예와 같이 숫자의 합만 구하여 출력합니다.
'0' = 48 '1' = 49 '9' = 57
57 - 48 = 9 49 - 48 = 1
int main(void) {
char a[20];
puts("문자열 입력");
gets(a);
int s = 0;
for (int i = 0; i < strlen(a);i++) {
if (a[i] >= 48 && a[i] <= 57) {
s += a[i]-48; //'0'
}
}
printf("숫자의 합 : %d",s);
return 0;
}
// 출력 //
문자열 입력
asd123kas
숫자의 합 : 6
■ 1월 22일 - 7일차
함수
main 함수는 C언어 프로그램의 시작과 끝임
함수 몸체에 정의된 실행문이 곧 프로그램의 기능(동작)을 의미함.
함수의 구성요소
반환형 : 함수로부터 반환할 데이터의 자료형태
함수의 이름 : 함수를 호출시 사용할 이름값
입력데이터 표현(매개변수) : 함수에 전달할 인자의 형태를 정의
함수의 기능 : 함수가 호출되었을때 실행할 기능을 정의
사용자 정의 함수
사용자가 기본적으로 실행하는 방식과
순서를 정하여 제작되는 함수로
함수를 구성하여 사용
기본적으로 선언및 정의를 main함수보다 위에 만드는 것이
기본이지만 컴파일러의 종류에 따라 밑에 작성해도 문제는 없음
위에 만들어주는 것이 기본임
기본구성
#include <stdio.h>
int main(void) {
int n = add(5, 10);
printf("%d\n", n);
return 0;
}
int add(int a, int b) {
return a + b;
}
// 출력 //
15
새로운 변수를 생성하여
인수로 지정할 수 있음.
int main(void) {
int a = 10, b = 5;
int n = add(a, b);
printf("%d + %d = %d\n", a,b,n);
return 0;
}
int add(int a, int b) {
return a + b;
}
입력값을 주어서 시행
int main(void) {
int a , b;
scanf("%d %d", &a, &b);
int n = add(a, b);
printf("%d + %d = %d\n", a,b,n);
return 0;
}
int add(int a, int b) {
return a + b;
}
함수의 형태
매개변수의 유무,
반환값의 유무에 따라 4가지 종류
-입력값 유, 반환값 유
-입력값 유, 반환값 무
-입력값 무, 반환값 유
-입력값 무, 반환값 무
입력값 유, 반환값 유
매개변수를 2개 입력받아
큰수를 반환하는 함수
int big(int a, int b) {
int c = a;
if (a <= b) {
c = b;
}
return c;
}
int main(void) {
int r = big(3, 8);
printf("큰값은 : %d", r);
return 0;
}
// 출력 //
큰값은 : 8
입력값 유, 반환값 무
반환값이 없을경우 void로 선언
void big(int a, int b) {
int c = a;
if (a <= b) {
c = b;
}
printf("큰값은 : %d", c);
}
int main(void) {
big(3, 8);
return 0;
}
// 출력 //
큰값은 : 8
입력값 무, 반환값 유
int big() {
int a, b;
printf("두수 입력 ");
scanf("%d %d", &a,&b);
int c = a;
if (a <= b) {
c = b;
}
return c;
}
int main(void) {
int c = big();
printf("큰값은 : %d", c);
return 0;
}
// 출력 //
두수 입력 2 9
큰값은 : 9
입력값 무, 반환값 무
반환값이 없을경우 void로 선언
void big() {
int a, b;
printf("두수 입력 ");
scanf("%d %d", &a, &b);
int c = a;
if (a <= b) {
c = b;
}
printf("큰값은 : %d", c);
}
int main(void) {
big();
return 0;
}
// 출력 //
두수 입력 5 11
큰값은 : 11
변수의 생명주기
지역변수
특정지역에서만 사용할 수 있는변수
지역이란 블록(중괄호)에서만 사용됨
지역변수의 특징
중괄호 내에 선언된 모든 변수
함수의 매개변수도 지역변수의 일종
자신이 선언한 지역 외 다른 영역 사용불가
선언 지역이 다를 경우 중복되어도 문제되지 않음
void add(int a, int b) {
// 매개변수 에러 int a = 10, b =2;
printf("a = %d, b = %d", a, b);
}
int main(void) {
add(1, 5);
//변수 미선언 에러 printf("a = %d, b = %d", a, b);
return 0;
}
변형
void add(int a, int b) {
int a2 = 10, b2 =2;
printf("a = %d, b = %d", a+a2, b+b2);
}
int main(void) {
add(1, 5);
return 0;
}
// 출력 //
a = 11, b = 7
전역변수
모든 지역에서 접근가능한 변수
전역변수 특성
프로그램 시작과 동시에 메모리 공간에 할당
모든 영역에서 접근 가능
전역변수와 동일 지역변수 선언시 지역내에서는 전역대신 지역이 사용됨
초기화를 변수로서 불가, 초기화 하지 않으면 0으로 자동 초기화
전역변수를 아래쪽에 선언할 수 없음
매개변수와 전역변수가 같은경우
함수내에서는 매개변수를 사용
변수로서 초기화
int a = 1; //심볼릭 상수
int b = a; //에러 상수로만 가능
define 상수는 가능
#define a 10;
int b = a;
초기화 하지 않으면 0
int a;
int main() {
printf("%d", a);
return 0;
}
// 출력 //
0
기본 사용
int a = 10;
void add(int a) {
printf("%d", a);
}
int main(void) {
add(5);
return 0;
}
// 출력 //
5
동일한 이름의 변수선언되었을때
부터는 메인함수에서 지역변수를 참조하여 출력
int a = 10;
void add(int a) {
printf("%d\n", a);
}
int main() {
add(a);
int a = 1;
add(a);
return 0;
}
// 출력 //
10
1
함수내에서 값을 변경해서 사용가능
예시1
int a = 10;
void add(int a) {
printf("%d\n", a);
}
int main() {
add(a);
a = 5; //전역변수의 변경
add(a);
return 0;
}
// 출력 //
10
5
예시2
add함수에 출력을 전역변수로
지정함
int a = 10;
void add(int b) {
printf("%d\n", a);
}
int main() {
add(2);
a = 5;
add(a);
return 0;
}
// 출력 //
10
5
예시3
함수를 실행하면서 전역변수의 값을 변동
int a = 10;
void add(int b) {
a = 100;
printf("%d\n", a);
}
int main() {
add(2);
a = 5; // 순서변경시 값이 5임
add(a);
printf("%d", a);
return 0;
}
// 출력 //
100
100
100
지역변수의 소멸 확인
void a() {
int a = 1;
a++;
printf("%d\n", a);
}
int main() {
a();
a();
return 0;
}
// 출력 //
2
2
전역변수 일 경우
int a1 = 1;
void a() { // 스스로 자신의 함수이름과 영향을 받아서 변경
a1++;
printf("%d\n", a1);
}
int main() {
a();
a();
return 0;
}
// 출력 //
2
3
static 변수 (정적변수)
지역내에서 선언하지만 소멸되지 않음
void pf() {
static int a = 1;
printf("%d\n", a);
a++;
}
int main() {
pf();
pf();
pf();
return 0;
}
// 출력 //
1
2
3
값변경시 당연히 1만 출력
void pf() {
static int a = 1;
a = 1;
printf("%d\n", a);
a++;
}
int main() {
pf();
pf();
pf();
return 0;
}
// 출력 //
1
1
1
응용문제
응용문제 1
두개의 정수를 매개변수로 받아
두정수의 덧셈, 뺄셈, 곱셈, 나눗셈 모두 출력
main에서 이를 호출
void pf(int a, int b) {
printf("%d + %d = %d\n", a, b, a + b);
printf("%d - %d = %d\n", a, b, a - b);
printf("%d * %d = %d\n", a, b, a * b);
printf("%d / %d = %d\n", a, b, a / b);
}
int main() {
pf(7,3);
return 0;
}
// 출력 //
7 + 3 = 10
7 - 3 = 4
7 * 3 = 21
7 / 3 = 2
응용문제 2
두개의 매개변수로 입력받아
두정수 사이에 있는 모든 정수의 합을 구하여 반환하는
함수를 정의 main에서 호출
출력 : 5 와 9 사이의 정수의 총합은 21
void pf(int a, int b) {
int c = 0;
for (int i = a+1; i < b; i++) {
c += i;
}
printf("%d 와 %d 사이의 정수의 총합은 %d", a, b, c);
}
int main() {
pf(5,9);
return 0;
}
// 출력 //
5 와 9 사이의 정수의 총합은 21
응용문제 3
한개의 정수를 매개 변수로 입력받아
입력받은수와 그 수보다 200 더 큰 정수사이에
7의 배수가 몇개나 존재하는지를 구하고 그 결과를
반환하는 함수 구현
예) 100 전달시 300사이의 7의 배수가 몇개인지 확인
void pf() {
int a;
printf("정수를 입력하세요 : ");
scanf("%d", &a);
int c = 0;
for (int i = a; i < a + 200; i++) {
if (i % 7 == 0) {
c++;
}
}
printf("%d 와 %d 사이의 7의 배수는 %d개 입니다.", a, a+200, c);
}
int main() {
pf();
return 0;
}
// 출력 //
정수를 입력하세요 : 6
6 와 206 사이의 7의 배수는 29개 입니다.
정수를 입력하세요 : 100
100 와 300 사이의 7의 배수는 28개 입니다.
변형
void pf() {
int a;
printf("정수를 입력하세요 : ");
scanf("%d", &a);
printf("%d 와 %d 사이의 7의 배수는 %d개 입니다.", a, a+200, (a+200)/7-(a-1)/7);
}
int main() {
pf();
return 0;
}
응용문제 4
사용자로부터 키를 cm로 입력받아
m단위로 환산하여 출력하는 프로그램 작성
함수를 정의하고 키를 인자로 받아 cm를 m단위로 반환
float f(int a) {
float b = a / 100.0;
return b;
}
int main() {
int a;
printf("키입력 cm단위 : ");
scanf("%d", &a);
float b = f(a);
printf("결과 : %.2fm", b);
return 0;
}
// 출력 //
키입력 cm단위 : 181
결과 : 1.81m
함수심화
배열을 전달받는 함수
int paf(int* a, int len) {
int i;
printf("배열 확인 : [");
for (i = 0; i < len;i++) {
printf("%d", a[i]);
if (i + 1 < len) {
printf(",");
}
else {
printf("]\n");
}
}
}
void main() {
int a[] = { 3,2,5,7,9 };
int si = sizeof(a)/4;
paf(a,si);
}
// 출력 //
배열 확인 : [3,2,5,7,9]
변형
int paf(int a[], int len) {
int i;
printf("배열 확인 : [");
for (i = 0; i < len;i++) {
printf("%d", a[i]); //*(a+i)넣어도 됨
if (i + 1 < len) {
printf(",");
}
else {
printf("]\n");
}
}
}
void main() {
int a[] = { 3,2,5,7,9 };
int si = sizeof(a)/4;
paf(a,si);
}
// 출력 //
배열 확인 : [3,2,5,7,9]배열로 숫자 값 넣어주는 함수
#include<stdio.h>
#include<string.h>
//배열 출력 함수
void apr(int a[],int s) {
for (int i = 0; i < s; i++) {
printf("%d ",a[i]);
}
printf("\n");
}
//1번에값을 2번에 넘기기
void acp(int a[], int b[], int s) {
for (int i = 0; i < s; i++) {
b[i] = a[i];
}
}
//홀수 넣어주고 나머지는 0으로 체우기
void acpo(int a[], int b[], int s) {
int c = 0;
for (int i = 0; i < s; i++) {
if (a[i] % 2 == 1) {
b[c++] = a[i];
}
}
for (int i = c; i < s; i++) {
b[i] = 0;
}
}
//인덱스 부터 x개 넣어주는 형태
void acpn(int a[], int b[], int c, int d) {
int ct = 0;
for (int i = c; i < c + d; i++) {
b[ct++] = a[i];
}
}
int main(void) {
int arr[] = { 1,2,7,10,3,7,12,8 };
int arr2[8];
acpn(arr, arr2, 2, 5);
apr(arr2, 8);
return 0;
}
전역 변수 배열에 값을 추가 삭제 해주기
#include <stdio.h>
int arr[30] = {0};
int ix = 0;
void add(int a) {
arr[ix++] = a;
}
void pr() {
for (int i = 0; i < ix; i++) {
printf("%d ", arr[i]);
}
if (ix == 0) {
printf("비었습니다.\n");
}
printf("\n");
}
void del() {
if (ix == 0) {
printf("삭제할게 없어요\n");
}
else {
ix--;
}
}
void adds(int a, int b) {
for (int i = 0; i < b; i++) {
arr[ix++] = a;
}
}
void dels(int a) {
if (ix < a) {
ix = 0;
}
else {
ix -= a;
}
}
int play() {
for (;;) {
int a;
printf("1.추가 2.대량추가 3.삭제 4.출력 5.종료 6.대량삭제 \n");
printf("입력 >> ");
scanf_s("%d", &a);
int b,c;
switch (a) {
case 1:
printf("추가할 값 : ");
scanf_s("%d", &b);
add(b);
break;
case 2:
printf("추가할 값 : ");
scanf_s("%d", &b);
printf("몇개 : ");
scanf_s("%d", &c);
adds(b, c);
break;
case 3:
printf("삭제 됨\n");
del();
break;
case 4:
pr();
break;
case 5:
return 0;
case 6:
printf("몇개 삭제 : ");
scanf_s("%d", &c);
dels(c);
break;
default:
printf("잘못된 값을 입력 했습니다.");
}
}
}
int main(void) {
play();
return 0;
}
■ 1월 23일 - 8일차
○ 포인터 배열을 이용한 값 교환 함수 작성
정수 변수 3개가 있다.
이 변수들의 주소를 저장한 포인터 배열을 함수로 전달하여
첫 번째 값과 세 번째 값을 교환하고,
교환 후 두 번째 값에 첫 번째 값의 2배를 더하라.
#include <stdio.h>
void process(int *p[]) {
int temp = *p[0];
*p[0] = *p[2];
*p[2] = temp;
*p[1] += (*p[0] * 2);
}
int main(void) {
int a = 2, b = 4, c = 6;
int *p[3] = { &a, &b, &c };
process(p);
printf("%d %d %d\n", a, b, c);
return 0;
}
6 16 2
○ 포인터 배열을 이용한 선택적 누적 합 계산
정수 배열이 주어진다.
포인터 배열을 사용하여
짝수 인덱스의 값만 누적 합
그 결과를 첫 번째 요소에 저장
#include <stdio.h>
void accumulate_even(int *p[], int n) {
int sum = 0;
for (int i = 0; i < n; i++) {
if (i % 2 == 0)
sum += *p[i];
}
*p[0] = sum;
}
int main(void) {
int data[5] = { 1, 2, 3, 4, 5 };
int *p[5] = { data, data+1, data+2, data+3, data+4 };
accumulate_even(p, 5);
printf("%d %d %d %d %d\n",
data[0], data[1], data[2], data[3], data[4]);
return 0;
}
9 2 3 4 5
○ 포인터 배열을 재구성하는 함수 작성
포인터 배열의 순서를 다음과 같이 변경하라.
p[0] → 원래 p[2]
p[1] → 원래 p[0]
p[2] → 원래 p[1]
재배치 후, 모든 값에 +1을 적용하라.
#include <stdio.h>
void reorder_and_inc(int *p[]) {
int *t0 = p[0];
int *t1 = p[1];
int *t2 = p[2];
p[0] = t2;
p[1] = t0;
p[2] = t1;
for (int i = 0; i < 3; i++)
(*p[i])++;
}
int main(void) {
int x = 5, y = 10, z = 15;
int *p[3] = { &x, &y, &z };
reorder_and_inc(p);
printf("%d %d %d\n", x, y, z);
return 0;
}
6 11 16
○ 함수 내부에서 포인터 배열을 이용한 최대값 수정
포인터 배열을 사용하여
세 값 중 가장 큰 값만 찾아 10을 증가시키는 함수를 작성하라.
#include <stdio.h>
void boost_max(int *p[]) {
int max_i = 0;
for (int i = 1; i < 3; i++) {
if (*p[i] > *p[max_i])
max_i = i;
}
*p[max_i] += 10;
}
int main(void) {
int a = 7, b = 12, c = 9;
int *p[3] = { &a, &b, &c };
boost_max(p);
printf("%d %d %d\n", a, b, c);
return 0;
}
7 22 9
○ 2개의 배열을 번갈아 합산하기
서로 다른 int 배열 A, B와 0으로 초기화된 C가 있다.
포인터 배열 p[3]에 A, B, C의 시작 주소를 넣고,
A[i] + B[i]를 C[i]에 넣고 C를 출력하라.
#include <stdio.h>
void fillC_by_sum(int *p[3], int n) {
for (int i = 0; i < n; i++) {
p[2][i] = p[0][i] + p[1][i];
}
}
int main(void) {
int A[4] = { 1, 3, 5, 7 };
int B[4] = { 2, 4, 6, 8 };
int C[4] = { 0, 0, 0, 0 };
int *p[3] = { A, B, C };
fillC_by_sum(p, 4);
for (int i = 0; i < 4; i++) {
printf("%d ", C[i]);
}
printf("\n");
return 0;
}
○ 포인터 배열로 “행 단위 가변 데이터”를 구성하고 특정 규칙으로 변환
서로 다른 배열 3개를 “행(row)”처럼 다룬다.
포인터 배열 rows[3]에 넣고, len[3]을 이용한다.
규칙: 각 행에서 짝수 인덱스 값은 +5, 홀수 인덱스 값은 *2를 적용한다.
마지막으로 3개 행을 그대로 출력하라.
#include <stdio.h>
void transform(int *rows[], int len[], int rcount) {
for (int r = 0; r < rcount; r++) {
for (int i = 0; i < len[r]; i++) {
if (i % 2 == 0) rows[r][i] += 5;
else rows[r][i] *= 2;
}
}
}
void print_rows(int *rows[], int len[], int rcount) {
for (int r = 0; r < rcount; r++) {
for (int i = 0; i < len[r]; i++) {
printf("%d ", rows[r][i]);
}
printf("\n");
}
}
int main(void) {
int R0[4] = { 1, 2, 3, 4 };
int R1[3] = { 10, 20, 30 };
int R2[5] = { 7, 1, 8, 2, 9 };
int *rows[3] = { R0, R1, R2 };
int len[3] = { 4, 3, 5 };
transform(rows, len, 3);
print_rows(rows, len, 3);
return 0;
}
문자열 통제
#include <stdio.h>
void f(char a[3][10], int b) {
printf("%s", a[b - 1]);
}
void f1(char a[3][10], int b, int c) {
for (int i = 0; i < 10; i++) {
a[b][i] = a[c][i];
}
}
void f2(char* a, int b) {
printf("%s", a + (b - 1) * 10);
}
int main() {
char a[3][10] = { "hello","apple","banana" };
return 0;
}
Call-by-Value, Call-by-reference
값을 받을경우 Call-by-Value
void sw(int n1, int n2) {
int t = n1;
n1 = n2;
n2 = t;
printf("sw함수 n1 = %d n2 = %d\n",n1,n2);
}
void main() {
int a1 = 33, a2 = 99;
sw(a1, a2);
printf("main a1 = %d a2 = %d\n", a1, a2);
}
// 출력 //
sw함수 n1 = 99 n2 = 33
main a1 = 33 a2 = 99
주소값을 받아서 변경 Call-by-reference
#include <stdio.h>
void sw(int* n1, int* n2) {
int t = *n1;
*n1 = *n2;
*n2 = t;
printf("sw함수 n1 = %d n2 = %d\n",*n1,*n2);
}
void main() {
int a1 = 33, a2 = 99;
sw(&a1, &a2);
printf("main a1 = %d a2 = %d\n", a1, a2);
}
// 출력 //
sw함수 n1 = 99 n2 = 33
main a1 = 99 a2 = 33
재귀호출함수
함수가 몸체 내에서 자기 자신을 호출하는 것을 말함
void sh () {
printf("hello!\n");
sh();
}
void main() {
sh();
}
// 출력 //
무한반복
반복통제
int sh (int c) {
printf("hello!\n");
if (c != 3) {
sh(c + 1);
}
return 0;
}
void main() {
sh(3);
}
// 출력 //
hello!
2회 출력
int sh (int c) {
printf("hello!\n");
if (c != 3) {
sh(c + 1);
}
return 0;
}
void main() {
sh(2);
}
// 출력 //
hello!
hello!
개수를 입력받아 반복실행
#include <stdio.h>
int sh (int c) {
if (c == 0) {
return 0;
}
printf("hello!\n");
sh(c - 1);
}
void main() {
sh(4);
}
// 출력 //
hello!
hello!
hello!
hello!
재귀함수 팩토리얼
값이 너무 크면 long long
5! = 5x4x3x2x1
5*(5-1)!
n! = n *(n-1)!
#include <stdio.h>
int ff (int n) {
if (n == 1) {
return 1;
}
return n * ff(n - 1);
}
void main() {
printf("팩토리얼 %d = %d\n", 3, ff(3));
printf("팩토리얼 %d = %d\n", 5, ff(5));
printf("팩토리얼 %d = %d\n", 11, ff(11));
}
// 출력 //
팩토리얼 3 = 6
팩토리얼 5 = 120
팩토리얼 11 = 39916800
재귀함수 피보나치 수열
피보나치 수열 간단히
첫달에는 새로태어난 토끼한쌍이 존재
두달 이상 되야 토끼번식
그다음 토끼 한쌍은 새끼 한쌍 번식 총 두쌍
네번째 달은 3쌍
다섯번째 달은 5쌍
피보나치 수열은 1:1.6의 황금비를 갖추고 있다.
f(1) = 1
f(2) = 1
f(n) = f(n-1)+f(n-2)
예 f(3) = 2, f(4) = 3, f(5) = 5, 8, 13, 21
단점 40을 넘으면 너무 느림
int pf (int n) {
if (n == 1 || n==2) {
return 1;
}
else {
return pf(n-1) + pf(n-2);
}
}
void main() {
for (int i = 1; i <= 20; i++) {
printf("pf(%d) = %d\n", i, pf(i));
}
}
// 출력 //
pf(1) = 1
pf(2) = 1
pf(3) = 2
pf(4) = 3
pf(5) = 5
pf(6) = 8
pf(7) = 13
pf(8) = 21
pf(9) = 34
pf(10) = 55
pf(11) = 89
pf(12) = 144
pf(13) = 233
pf(14) = 377
pf(15) = 610
pf(16) = 987
pf(17) = 1597
pf(18) = 2584
pf(19) = 4181
pf(20) = 6765
일반 for문 피보나치 수열
void main() {
long long f1 = 0;
long long f2 = 1;
long long f3;
for (int i = 1; i <= 50; i++) {
if (i == 1) {
printf("pf(%d) = %lld\n", i, f2);
}
else{
f3 = f1 + f2;
printf("pf(%d) = %lld\n", i, f3);
f1 = f2;
f2 = f3;
}
}
}
응용문제
응용문제 1
int형 변수 n1과 n2를 선언하고,
두 개의 인자를 전달받는 두 개의 함수를 정의해 보세요.
두 함수의 이름과 기능은 다음과 같습니다.
두 함수를 정의한 후 main함수에서 실행이 원활하게 되는지 확인해 보세요.
cv : call-by-value 방식으로 두 수의 차를 구하여 반환하는 함수 (int)
cr : call-by-reference 방식으로 두 수중에서 큰 것을
n1에, 작은것을 n2에 저장하는 함수 (void)
(n1에 저장된 정수가 더 큰 경우 변화가 없으나,
n2에 저장된 정수가 더 큰 경우 교환)
int cv(int n1, int n2) {
return n1 - n2;
}
void cr(int *n1, int *n2) {
int t;
if (*n1 < *n2) {
t = *n2;
*n2 = *n1;
*n1 = t;
}
}
void main() {
int n1 = 5, n2 = 10;
printf("cv = %d\n", cv(n1, n2));
cr(&n1, &n2);
printf("n1 = %d, n2 = %d\n", n1, n2);
printf("cv = %d\n", cv(n1, n2));
}
// 출력 //
cv = -5
n1 = 10, n2 = 5
cv = 5
응용문제 2
main함수가 작성된 상태에서
세 변수에 저장된 값을 서로 바꾸는 함수를 정의
호출 결과는 n1에 저장된 값은 n2에,
n2에 저장된 값은 n3에,
그리고 n3에 저장된 값은 n1에 저장
예
전 : 5 8 10
후 : 10 5 8
#include <stdio.h>
void sn(int *n1, int *n2, int *n3) {
int t = *n3;
*n3 = *n2;
*n2 = *n1;
*n1 = t;
}
void main() {
int n1 = 5, n2 = 8, n3 = 10;
printf("전 : %d %d %d\n",n1,n2,n3);
sn(&n1, &n2, &n3);
printf("전 : %d %d %d\n",n1,n2,n3);
}
// 출력 //
전 : 5 8 10
전 : 10 5 8
응용문제 3
main 함수가 다음과 같이 작성된 상태에서
1부터 n까지의 합을 구하여 반환하는
재귀 호출 함수 rs을 정의해 보세요.
0이 될 때까지 인자 값을 계속해서 더하는 방식
int rs(int n) {
if (n > 1) {
return n + rs(n - 1);
}
else {
return 1;
}
}
void main() {
int n = 10;
int r = rs(n);
printf("1부터 %d까지의 합 : %d", n, r);
}
// 출력 //
1부터 10까지의 합 : 55
종합문제
종합문제 1
rand() 함수에 의해 생성되는 난수 : 0 ~ 32767
rand() 확인하여 0~10 범위로 생성 시키기
#include <stdio.h>
#include <stdlib.h>
int main() {
for (int i = 0; i < 10; i++) {
int r = rand()%11;
printf("%d\n", r);
}
return 0;
}
고정값 변경
srand(time(NULL))
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
int main() {
srand(time(NULL));
for (int i = 0; i < 10; i++) {
int r = rand()%11;
printf("%d\n", r);
}
return 0;
}
종합문제 2
생성된 난수를 맞추면 프로그램종료
1~10까지의 난수 생성
또는 0 입력시 종료
틀리면 난수 : x 후 다시 실행
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
int main() {
srand(time(NULL));
for (;;) {
int a;
int r = rand() % 10 + 1;
printf("난수 맞춰(1~10) : ");
scanf("%d", &a);
if (a == r) {
printf("정답입니다.\n");
return;
}
else if (a == 0) {
printf("종료합니다\n");
return;
}
else {
printf("틀렸습니다. 난수 : %d\n", r);
}
}
return 0;
}
종합문제 3
가위바위보 게임을 만들기
규칙 가위 1, 바위 2, 보 3
사용자는 숫자를 입력 결과를 출력하기
가위바위보 게임은 함수로 제작
가위1 바위2 보3 : 2
당신은 바위, 컴퓨터는 바위 비겼습니다.
가위1 바위2 보3 : 2
당신은 바위, 컴퓨터는 가위 이겼습니다.
#include<stdio.h>
#include<string.h>
#include<time.h>
void game() {
srand(time(NULL));
char a[4][10] = { "","가위","바위","보" };
int r = rand() % 3 + 1;
printf("가위1, 바위2, 보3 : ");
int b;
scanf("%d", &b);
printf("당신은 %s 컴퓨터는 %s \t", a[b], a[r]);
if (b == r) {
printf("비겼습니다.\n");
}
else if(b == r % 3 + 1) {
printf("이겼습니다.\n");
}
else {
printf("졌습니다.\n");
}
}
int main(void) {
game();
return 0;
}
■ 1월 26일 - 9일차
종합문제 5
길이가 5인 int형 배열을 만들고,
사용자로부터 정수 5개를 입력받아 저장
배열을 오름차순 정렬 시키는 asc와 desc를
각각 정의하여 호출
#include <stdio.h>
void asc(int* a) {
for (int i = 0; i < 4; i++) {
for (int j = 0; j < 4 - i;j++) {
if (a[j] > a[j + 1]) {
int t = a[j];
a[j] = a[j + 1];
a[j + 1] = t;
}
}
}
}
void asc2(int* a) {
for (int i = 0; i < 4; i++) {
for (int j = i+1; j < 5; j++) {
if (a[i] > a[j]) {
int t = a[i];
a[i] = a[j];
a[j] = t;
}
}
}
}
void desc(int* a) {
for (int i = 0; i < 4; i++) {
for (int j = 0; j < 4 - i; j++) {
if (a[j] < a[j + 1]) {
int t = a[j];
a[j] = a[j + 1];
a[j + 1] = t;
}
}
}
}
int main(){
int a[5] = { 8,4,2,6,7 };
desc(a);
for (int i = 0; i < 5; i++) {
printf("%d ", a[i]);
}
}
포인터 심화
포인터의 포인터
포인터변수는 메모리 주솟값을 저장하는 변수
포인터 변수 또한 하나의 변수로 메모리공간을
차지하고 있음
포인터의 포인터를 저장하면 더블 포인터라고 함
더블포인터 사용
int n = 3;
int * p = &n;
int **dp = &p;
int main() {
int n = 3;
int* p1 = &n;
int** dp = &p1;
int* p2 = *dp;
printf("p1 = %p\np2 = %p\n*dp= %p\n&n = %p\n\n", p1, p2,*dp,&n);
*p2 = 11;
printf("n = %d, **dp = %d *p1 = %d", n, **dp, *p1);
return 0;
}
// 출력 //
p1 = 0000008B92F6FB94
p2 = 0000008B92F6FB94
*dp= 0000008B92F6FB94
&n = 0000008B92F6FB94
n = 11, **dp = 11 *p1 = 11
더블포인터의 Call-by-reference
함수를 호출할때 인자로 포인터 변수의 주소를 넣어줌
주소값이 바뀜
n1 과 n2가 바뀐게 아니라 p1과 p2 즉 주소값이 변화
처음에는 p1 -> n1, p2 -> n2
함수실행후 p1 -> n2, p2 -> n1
#include <stdio.h>
void sw(int** a, int** b) {
int* t = *a;
*a = *b;
*b = t;
}
int main() {
int n1 = 11, n2 = 9;
int* p1 = &n1;
int* p2 = &n2;
printf("p1 = %p\np2 = %p\n\n", p1, p2);
sw(&p1, &p2);
printf("p1 = %p\np2 = %p\n\n", p1, p2);
return 0;
}
// 출력 //
p1 = 000000B6FB4FFB54
p2 = 000000B6FB4FFB74
p1 = 000000B6FB4FFB74
p2 = 000000B6FB4FFB54
함수 포인터
함수도 변수와 마찬가지로 메모리 주소가 존재
C언어는 함수의 주소를 저장할 수 있는 포인터 변수를 제공
이를 함수 포인터라 부름
함수의 이름은 메모리 공간에 저장되어 있는
함수실행문의 시작 주소값임
#include <stdio.h>
void mf(int a, int b) {
printf("a : %d, b : %d\n", a, b);
}
int main() {
int (*fp)(int, int) = mf;
fp(10, 12);
printf("%p\n", &mf);
printf("%p\n", fp);
return 0;
}
// 출력 //
a : 10, b : 12
00007FF6D7BF1410
00007FF6D7BF1410
void형 포인터
포인터 변수를 선언할때 자료형을 정의하지만
void로 지정할 수 있다.
어차피 주솟값을 저장하는 역활로 어떠한 주솟값도 저장할 수 있다.
하지만 type에 대한 정보가 없어서
포인터 연산이 불가능하다. 단순히 주솟값을 저장할 수 있는
의미만 있다.
응용문제
응용문제 1
예측
#include <stdio.h>
int main() {
double v = 3.8;
double* p = &v;
double** dp = &p;
printf("%0.1f\n", **dp); //v값
printf("%p\n", &dp); // dp주소
printf("%p\n", *&dp); // p주소
printf("%p\n", *dp); // v주소
printf("%p\n", &*dp); // p주소
printf("%p\n", &p); // p주소
return 0;
}
메모리 동적할당
프로그램이 실행되는 동안
사용할 메모리 공간을 할당하는 것이 메모리 동적할당임
malloc함수
사용자가 생성과 소멸시기를
결정할 수 있는 변수를 선언할때 사용
#include <stdlib.h>
malloc(size) // 메모리 공간 크기를 바이트로 받음
int * np = (int * )malloc(sizeof(int) * x)
x만큼 메모리 할당
free(np); 메모리 해제
char* a() {
char* st = (char*)malloc(sizeof(char)*10);
printf("좋아하는 단어 ");
scanf("%s", st);
printf("함수 실행 %s\n", st);
return st;
}
int main() {
char* c = a();
printf("메인 실행 %s\n", c);
free(c);
return 0;
}
// 출력 //
좋아하는 단어 카라멜마키아또
함수 실행 카라멜마키아또
메인 실행 카라멜마키아또
calloc
calloc(개수, 크기)
calloc은 할당하고자하는 메모리 공간의 개수와
각 메모리 공간별 크기를 전달받는다.
크기단위는 바이트이며
malloc과 마찬가지로 포인터로 반환
malloc(sizeof(int) * 10)
calloc(10,sizeof(int))
realloc
목적이 다른함수로 힙영역에 할당되어 있는
메모리 공간의 크기를 조절하는 기능을 가짐
realroc(포인터, 새로운크기)
#include <stdio.h>
#include <stdlib.h>
int main() {
int c = 0;
int size = 3;
int n;
int* p = (int*)calloc(size,sizeof(int));
while (1) {
printf("정수(-1종료) >> ");
scanf("%d", &n);
if (n == -1) {
break;
}
if (c == size) { //없으면 에러
size += size; // 사이즈 +3
p = (int*)realloc(p, size * sizeof(int)); //증가
}
p[c++] = n;
}
for (int i = 0; i < c; i++) {
printf("%d ", p[i]);
}
free(p);
return 0;
}
// 출력 //
정수(-1종료) >> 0
정수(-1종료) >> 1
정수(-1종료) >> 2
정수(-1종료) >> 3
정수(-1종료) >> 4
정수(-1종료) >> -1
0 1 2 3 4
#include<stdio.h>
#include<stdlib.h>
int size = 1;
int count = 0;
int* f(int a) {
int* p = malloc(size * 4);
size++;
p[count++] = a;
return p;
}
int* f2(int* p1, int a) {
int* np = malloc(size * 4);
size++;
for (int i = 0; i < count; i++) {
np[i] = p1[i];
}
np[count++] = a;
free(p1);
return np;
}
int* f3(int* p) {
int a;
printf("몇개 >> ");
scanf("%d", &a);
for (int i = 0; i < a; i++) {
printf("%d 입력 >> ",i+1);
int b;
scanf("%d", &b);
p = f2(p, b);
}
return p;
}
void pr(int* a, int b) {
for (int i = 0; i < b; i++) {
printf("%d ", a[i]);
}
}
void main() {
int* p = f(5);
p = f2(p, 10);
p = f2(p, 20);
p = f2(p, 30);
p = f3(p);
pr(p, count);
}응용문제 1
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
int main() {
char* s1 = "Take a look!";
char* s2 = ;
if (s2 != NULL) {
free(s2);
}
return 0;
}
답
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
int main() {
char* s1 = "Take a look!";
int le = strlen(s1) + 1;
char* s2 = (char*)malloc(sizeof(char) * le);
for (int i = 0; i < le; i++) {
s2[i] = s1[i];
}
printf("%s\n", s2);
if (s2 != NULL) {
free(s2);
}
return 0;
}
// 출력 //
Take a look!
다른방법
strcpy(s2, s1);
#include <stdio.h>
#include <stdlib.h>
int size = 0;
int* arr;
void make() {
arr = malloc(size * sizeof(int));
}
void add(int a) {
size++;
arr = realloc(arr, size * sizeof(int));
arr[size - 1] = a;
}
void del() {
size--;
arr = realloc(arr, size * sizeof(int));
}
void pr() {
for (int i = 0; i < size; i++) {
printf("%d ", arr[i]);
}
}
void play() {
make();
int a = 0;
int b = 0;
for (;;) {
printf("1추가 2삭제 3출력 0종료\n입력 : ");
scanf_s("%d", &a);
switch (a) {
case 0:
return 0;
case 1:
printf("추가 : ");scanf_s("%d", &b);
add(b); break;
case 2:
if (size == 0) printf("비어있음");
else del(); break;
case 3:
pr(); printf("\n"); break;
default:
return 0;
}
}
}
int main() {
play();
return 0;
}
■ 1월 27일 - 10일차
○ 공간열고 문자열 넣기
#include <stdio.h>
#include <stdlib.h>
void arrin(char* a[]) {
char* p = malloc(10);
printf("입력 : ");
scanf_s("%s", p, 9);
a[0] = p;
}
int main(void) {
char* arr[10] = { 0 };
arrin(arr);
for (int i = 0; i < 10; i++) {
printf("%s ", arr[i]);
}
return 0;
}
- 여러가지 함수로
#include <stdio.h>
#include <stdlib.h>
int s = 3;
void pr(char* a[]) {
for (int i = 0; i < s; i++) {
printf("%s ", a[i]);
}
}
void ain(char* a[]) {
int b;
printf("몇개 : ");
scanf_s("%d", &b);
char* p = malloc(b);
printf("입력 : ");
scanf_s("%s", p, b);
a[s++] = p;
}
void add(char* a[], char* b) {
a[s++] = b;
}
void del() {
s--;
}
void dels(char* a[], char* b) {
for (int i = 0; i < s; i++) {
if (a[i] == b) {
for (int j = i; j < s-1; j++) {
a[j] = a[j + 1];
}
}
}
s--;
}
int main() {
char* arr[10] = {"apple","c++","python"};
add(arr, "hello");
add(arr, "java");
dels(arr, "c++");
pr(arr);
return 0;
}
구조체(Structure)
하나이상의 변수를 한번에 묶어서 사용
다른종류의 타입의 데이터를 저장할 수 있게됨
구조체를 구성하는 각 변수는
각각의 메모리 공간 할당, 구조체의 멤버로서 역할을 수행
사용자 정의 자료형이라 부른다 (사용자에 의해 정의)
메인함수 위에 정의 되어야 함
struct 키워드로 정의함
struct p{
int a;
char name[30];
};
구조체 선언 및 접근
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
struct p{
int a;
char name[30];
};
int main() {
struct p a, b;
strcpy(a.name, "백두산");
strcpy(b.name, "한라산");
a.a = 22;
b.a = 33;
printf("a 이름 : %s, 나이 : %d\n", a.name, a.a);
printf("b 이름 : %s, 나이 : %d", b.name, b.a);
return 0;
}
// 출력 //
a 이름 : 백두산, 나이 : 22
b 이름 : 한라산, 나이 : 33
구조체 변수 초기화
struct p{
int a;
char name[30];
};
int main() {
struct p a = { 30, "백두산" };
struct p b = { 22, "한라산" };
printf("a 이름 : %s, 나이 : %d\n", a.name, a.a);
printf("b 이름 : %s, 나이 : %d", b.name, b.a);
return 0;
}
// 출력 //
a 이름 : 백두산, 나이 : 30
b 이름 : 한라산, 나이 : 22
구조체와 배열
struct p{
int a;
char name[30];
};
int main() {
struct p a[3] = {
{ 30, "백두산" },
{ 22, "한라산" },
{ 29, "지리산"} };
int si = sizeof(a) / sizeof(struct p);
printf("%d\n", sizeof(struct p));
printf("%d\n", si);
for (int i = 0; i < si; i++) {
printf("a%d 이름 : %s, 나이 : %d\n", i,a[i].name, a[i].a);
}
return 0;
}
// 출력 //
36
3
a0 이름 : 백두산, 나이 : 30
a1 이름 : 한라산, 나이 : 22
a2 이름 : 지리산, 나이 : 29
입출력 받을수 있도록 생성
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
struct p{
int a;
char name[30];
};
int main() {
struct p a[3];
int si = sizeof(a) / sizeof(struct p);
for (int i = 0; i < si; i++) {
printf("%d번째 이름 : ", i + 1);
scanf("%s", a[i].name);
printf("%d번째 나이 : ", i + 1);
scanf("%d", &a[i].a);
}
for (int i = 0; i < si; i++) {
printf("a%d 이름 : %s, 나이 : %d\n", i,a[i].name, a[i].a);
}
return 0;
}
// 출력 //
1번째 이름 : 백두산
1번째 나이 : 22
2번째 이름 : 한라산
2번째 나이 : 23
3번째 이름 : 지리산
3번째 나이 : 32
a0 이름 : 백두산, 나이 : 22
a1 이름 : 한라산, 나이 : 23
a2 이름 : 지리산, 나이 : 32
typedef 선언
기존에 존재하는 자료형에 새 이름을 부여
typedef int i;
typedef int* p;
int main() {
i a = 3;
i b[] = { 10,20,30 };
p p1 = &a;
p p2 = b;
printf("%d\n", *p1);
printf("%d", *(p2 + 1));
return 0;
}
// 출력 //
3
20
구조체와 typedef
struct p{
int a;
char name[30];
};
typedef struct pp {
int a;
char name[20];
}PP;
typedef struct p pst;
int main() {
pst a1 = { 22,"백두산" };
pst a2 = { 33, "한라산" };
PP b1 = { 25,"지리산" };
struct pp c1 = { 31, "설악산" };
printf("%d %s \n", a1.a, a1.name);
printf("%d %s \n", a2.a, a2.name);
printf("%d %s \n", b1.a, b1.name);
printf("%d %s \n", c1.a, c1.name);
return 0;
}
// 출력 //
22 백두산
33 한라산
25 지리산
31 설악산
응용문제 1
원산지(or), 가격(pr),바리스타 이름(br)을
멤버로 갖는 coffee 구조체를 정의한 선언문 작성
문자열을 변수로 갖는 경우 문자열의 길이는 임의
typedef struct coffee {
char or[10];
int pr;
char br[20];
}cf;
int main() {
cf a = { "케냐", 1000, "클라크" };
printf("원산지 %s, 가격 %d, 바리스타 이름 %s \n", a.or,a.pr,a.br);
return 0;
}
// 출력 //
원산지 케냐, 가격 1000, 바리스타 이름 클라크
응용문제 2
직원 관리를 위한 구조체를 정의해 보세요.
문자열 형태의 이름, 문자열 형태의 전화번호,
정수 형태의 월급을 저장할 수 있는 worker라는
이름의 구조체를 정의하세요.
그리고 구조체변수를 하나 선언한 다음
프로그램 사용자가 직접 입력하는 정보로
변수를 채워 출력하세요.
입력예
직원의 이름 : 제임스
직원의 전화번호 : 010-1234-5678
직원의 월급여 : 1000000
실행예
직원의 이름 : 제임스
직원의 전화번호 : 010-1234-5678
직원의 월급여 : 1000000
typedef struct worker {
char n[20];
char pn[20];
int s;
}w;
int main() {
w a;
printf("이름 : ");
scanf("%s", a.n);
printf("전화번호 : ");
scanf("%s", a.pn);
printf("월급여 : ");
scanf("%d", &a.s);
printf("이름 : %s\n전화번호 %s\n월급여 %d", a.n,a.pn,a.s);
return 0;
}
// 출력 //
이름 : 제임스
전화번호 : 010-1234-5678
월급여 : 10000000
이름 : 제임스
전화번호 010-1234-5678
월급여 10000000
응용문제 2
직원 관리를 위한 구조체를 정의해 보세요.
문자열 형태의 이름, 문자열 형태의 전화번호,
정수 형태의 월급을 저장할 수 있는 worker라는
이름의 구조체를 정의하세요.
그리고 구조체변수를 하나 선언한 다음
프로그램 사용자가 직접 입력하는 정보로
변수를 채워 출력하세요.
입력예
직원의 이름 : 제임스
직원의 전화번호 : 010-1234-5678
직원의 월급여 : 1000000
실행예
직원의 이름 : 제임스
직원의 전화번호 : 010-1234-5678
직원의 월급여 : 1000000
typedef struct worker {
char n[20];
char pn[20];
int s;
}w;
int main() {
w a;
printf("이름 : ");
scanf("%s", a.n);
printf("전화번호 : ");
scanf("%s", a.pn);
printf("월급여 : ");
scanf("%d", &a.s);
printf("이름 : %s\n전화번호 %s\n월급여 %d", a.n,a.pn,a.s);
return 0;
}
// 출력 //
이름 : 제임스
전화번호 : 010-1234-5678
월급여 : 10000000
이름 : 제임스
전화번호 010-1234-5678
월급여 10000000
응용문제 3
배열로 만들어서 저장한후 순서대로 출력
typedef struct worker {
char n[20];
char pn[20];
int s;
}w;
int main() {
w a[3];
int si = sizeof(a) / sizeof(w);
for (int i = 0; i < si; i++) {
printf("%d 이름 : ",i+1);
scanf("%s", a[i].n);
printf("%d 전화번호 : ",i+1);
scanf("%s", a[i].pn);
printf("%d 월급여 : ",i+1);
scanf("%d", &a[i].s);
}
for (int i = 0; i < si; i++) {
printf("\n직원%d\n이름 : %s\n전화번호 %s\n월급여 %d\n", i+1,a[i].n, a[i].pn, a[i].s);
}
return 0;
}
// 출력 //
1 이름 : 백두산
1 전화번호 : 010-1234-5678
1 월급여 : 100
2 이름 : 설악산
2 전화번호 : 010-456-1234
2 월급여 : 200
3 이름 : 한라산
3 전화번호 : 010-789-1234
3 월급여 : 350
직원1
이름 : 백두산
전화번호 010-1234-5678
월급여 100
직원2
이름 : 설악산
전화번호 010-456-1234
월급여 200
직원3
이름 : 한라산
전화번호 010-789-1234
월급여 350
구조체와 포인터
(*p).age 이런형태와 p->age 동일
typedef struct worker {
char n[20];
int a;
}p;
int main() {
p a = { "호날두", 38 };
p* p = &a;
printf("%s(%d)\n", (*p).n, (*p).a);
printf("%s(%d)\n", p->n, p->a);
return 0;
}
// 출력 //
호날두(38)
호날두(38)
구조체 멤버 변수로 선언된 포인터 변수
pi라는 구조체는
i라는 구조체 형태의 포인터를 갖는다
그리고 두가지의 포인터 변수를 저장할 수 있는
데이터형으로 변경
i형태로 만든 p1이라는 변수는 1,5의 값을 갖고 있고
p2는 10과 50의 변수를 갖고있다.
pi라는 구조체에 p1변수와 p2변수의 주소를 넣어
포인터로 가르키면 1번째는 p1변수의 값을
2번째는 p2변수의 값을 가르킴
typedef struct{
int a, b;
}i;
typedef struct {
i* p1;
i* p2;
}pi;
int main() {
i p1 = { 1,5 };
i p2 = { 10,50 };
pi l = { &p1,&p2 };
printf("1번 [%d, %d]\n",l.p1->a,l.p1->b);
printf("2번 [%d, %d]\n",l.p2->a,l.p2->b);
return 0;
}
// 출력 //
1번 [1, 5]
2번 [10, 50]
구조체 중첩
구조체에 들어 있는 멤버로
다른 구조체를 사용할 수 있다.
기존에 선언되어 있는 구조체를
멤버변수로 선언할 수 있고
자기 자신의 변수까지도 사용할 수 있다.
typedef struct{
int a, b;
}i;
typedef struct {
i i;
int c;
}i2;
int main() {
i2 a = { 10,50,999 };
printf("[%d, %d, %d]\n",a.i.a,a.i.b,a.c);
return 0;
}
// 출력 //
[10, 50, 999]
구조체 배열 멤버변수
구조체를 중첩하는 기능에서, 배열형태로서도 작성 가능
typedef struct{
int a, b;
}i;
typedef struct {
i i[3];
int c;
}i2;
int main() {
i2 a = { {{1,5},{10,50},{20,60}},999 };
int si = sizeof(a.i) / sizeof(i);
for (int i = 0; i < si; i++) {
printf("[%2d, %2d, %d]\n", a.i[i].a, a.i[i].b, a.c);
}
return 0;
}
// 출력 //
[ 1, 5, 999]
[10, 50, 999]
[20, 60, 999]
구조체와 함수
구조체변수를 함수의 인자로 전달하고 반환도 가능함
typedef struct{
int a, b;
}ist;
ist sint(int f1, int f2) {
ist a = { f1, f2 };
return a;
}
void pr(ist a) {
printf("[%d, %d]", a.a, a.b);
}
int main() {
ist o = sint(10, 20);
pr(o);
return 0;
}
// 출력 //
[10, 20]
구조체와 Call-by-reference
큰값만 나올수 있도록 sp함수를 구성
포인터 a또는 b의 값(주소x)을 바꿔줌
typedef struct{
int a, b;
}i;
void sp(i* p) {
if (p->a > p->b) {
p->b = p->a;
}
else {
p->a = p->b;
}
}
void pr(i a) {
printf("[%d, %d]\n", a.a, a.b);
}
int main() {
i a1 = { 1,20 };
i a2 = { 100, 10 };
sp(&a1);
sp(&a2);
pr(a1);
pr(a2);
return 0;
}
// 출력 //
[20, 20]
[100, 100]
응용문제
응용문제1
다음과 같이 구조체 변수와 구조체 포인터를 선언시
p를 사용하여 구조체의 모든 변수를 출력
typedef struct{
char n[30];
int a;
double h;
}ps;
int main() {
ps a = { "손오공", 30, 180.35};
ps* p = &a;
printf("이름 : %s\n나이 : %d\n신장 : %.2f", p->n, p->a, p->h);
return 0;
}
// 출력 //
이름 : 손오공
나이 : 30
신장 : 180.35
응용문제2
다음과 같은 구조체를 정의
두 멤버 변수를 대상으로 저장된 값을 서로 변형
이를 호출
1번째는 3,6 2번째는 4,9를 저장하고 있고
이 값을 변경하는 함수를 호출
typedef struct {
int x;
int y;
}in;
void insw(in* a, in* b) {
in c;
c.x = a->x;
c.y = a->y;
a->x = b->x;
a->y = b->y;
b->x = c.x;
b->y = c.y;
}
void main() {
in a1 = { 3,6 };
in a2 = { 4,9 };
insw(&a1,&a2);
printf("a1 x : %d, a1 y : %d\n", a1.x, a1.y);
printf("a2 x : %d, a2 y : %d", a2.x, a2.y);
}
// 출력 //
a1 x : 4, a1 y : 9
a2 x : 3, a2 y : 6
응용문제3
좌측 상단의 x, y좌표와 우측 하단의 x, y좌표를 가진
사각형 정보를 표현하기 위한 구조체 Rect를 정의합니다.
이 때 다음 구조체를 기반으로 정의해야 합니다.
멤버 변수로는 좌측상단과 우측하단 두개의 변수가 요구됩니다.
typedef struct {
int x;
int y;
}pit;
typedef struct {
pit l;
pit r;
}rect;
void prr(rect a) {
int h = a.l.x - a.r.x;
int w = a.l.y - a.r.y;
if (h*w<0) {
printf("사각형 넓이 : %d\n", -h * w);
}
else {
printf("사각형 넓이 : %d\n", h * w);
}
}
void main() {
pit a1 = { 5,1 };
pit a2 = { 1,6 };
rect r = {a1,a2};
prr(r);
}
// 출력 //
사각형 넓이 : 20
절대값 함수 사용
printf("사각형 넓이 : %d", abs(h * w));
종합문제
종합문제 1
오름차순으로 정렬된 int형 배열과 int형 정수, 배열의 길이를 각각 인자로 전달
전달된 정수를 포함하는 새로운 오름차순 배열을 만들어 반환하는
createarr을 정의하고 호출해 보세요
이때 동적할당을 활용해 보세요
int* ca(int* a, int n, int l) {
int* na = (int*)malloc(sizeof(int)*(l+1));
na[l] = n;
for (int i = 0; i < l; i++) {
if (n > a[i]) {
na[i] = a[i];
na[i + 1] = n;
}
else {
na[i + 1] = a[i];
}
if (n < a[0]) {
na[0] = n;
}
}
return na;
}
int main() {
int a[3] = { 1,5,7 };
int len = sizeof(a) / sizeof(int);
int n = 3;
int* p;
p = ca(a, n, len);
for (int i = 0; i < len + 1; i++) {
printf("%d ", p[i]);
}
}
종합문제 2
길이가 동일한 두개의 배열을 인자로 받아
서로 값을 교환하는 함수 swapArr을 정의하고
호출해보기
void swa(int* a, int* b, int l) {
int* c = (int *)malloc(sizeof(int)*l);
for (int i = 0; i < l; i++) {
c[i] = a[i];
a[i] = b[i];
b[i] = c[i];
}
free(c);
}
void main() {
int a1[5] = { 1,3,5,7,9 };
int a2[5] = { 2,4,6,8,10 };
int len = sizeof(a1) / sizeof(int);
swa(a1, a2, len);
for (int i = 0; i < len; i++) {
printf("%d ", a1[i]);
}
printf("\n");
for (int i = 0; i < len; i++) {
printf("%d ", a2[i]);
}
}
// 출력 //
2 4 6 8 10
1 3 5 7 9
구조체 메모리 할당
함수 사용시 마다 메모리를 할당 후 추가 되는 구조체
#include <stdio.h>
#include <stdlib.h>
int ix = 0;
typedef struct {
int a;
char* n;
}s;
s* f(s* a, int b, char* c) {
s* n = malloc(sizeof(s) * (++ix));
for (int i = 0; i < ix - 1; i++) {
n[i].a = a[i].a;
n[i].n = malloc(10);
n[i].n = a[i].n;
}
n[ix - 1].a = b;
n[ix - 1].n = malloc(10);
n[ix - 1].n = c;
free(a);
return n;
}
void pr(s* s) {
for (int i = 0; i < ix; i++) {
printf("이름 : %s\n", s[i].n);
printf("나이 : %d\n\n", s[i].a);
}
}
void main() {
s* a = malloc(sizeof(s));
a = f(a, 22, "홍길동");
a = f(a, 33, "백두산");
a = f(a, 11, "안녕");
pr(a);
}
추가 수정 삭제 가능한 구조체
함수 사용시 마다 메모리를 할당 후 추가 되는 구조체
#include <stdio.h>
#include <stdlib.h>
typedef struct {
int number;
int age;
char name[10];
}st;
st z[3] = { {1,20,"홍길동"},{2,30,"백두산"},{3,40,"한라산"}};
st* a = z;
int id = 3;
void pr() {
for (int i = 0; i < id; i++) {
printf("번호 : %d 나이 : %d 이름 : % s\n", a[i].number, a[i].age, a[i].name);
}
}
void sc() {
printf("검색 번호 : ");
for (int i = 0; i < id; i++) {
printf("%d ", a[i].number);
}
printf("몇번 >> ");
int asd;
scanf("%d", &asd);
printf("번호 : %d 나이 : %d 이름 : % s\n",
a[asd - 1].number, a[asd - 1].age, a[asd - 1].name);
}
void del() {
printf("검색 번호 : ");
for (int i = 0; i < id; i++) {
printf("%d ", a[i].number);
}
printf("몇번 >> ");
int asd;
scanf("%d", &asd);
st* ne = malloc(sizeof(st) * (id-1));
int c = 0;
for (int i = 0; i < id; i++) {
if (i == asd - 1) continue;
ne[c].number = c + 1;
ne[c].age = a[i].age;
for (int j = 0; j < 10; j++) {
ne[c].name[j] = a[i].name[j];
}
c++;
}
id--;
a = ne;
}
void ip() {
st* ne = malloc(sizeof(st)*(++id));
for (int i = 0; i < id - 1; i++) {
ne[i].number = i + 1;
ne[i].age = a[i].age;
for (int j = 0; j < 10; j++) {
ne[i].name[j] = a[i].name[j];
}
}
ne[id - 1].number = id;
printf("이름 입력 >> ");
scanf("%s", ne[id - 1].name);
printf("나이 입력 >> ");
scanf("%d", &ne[id - 1].age);
a = ne;
}
void play() {
int num;
while (1) {
printf("====메뉴===\n");
printf("1.입력 2. 출력 3. 검색 4. 삭제 5. 종료\n");
printf("선택 >> ");
scanf("%d", &num);
switch (num) {
case 1:
ip();
break;
case 2:
pr();
break;
case 3:
sc();
break;
case 4:
del();
break;
case 5:
return;
}
printf("\n\n");
}
}
void main() {
play();
}