반응형
_11_교재
- 수업013_입력.cpp
#include <stdio.h>
int main(void) {
int n;
printf("숫자를 입력하고 엔터를 누르시오.");
scanf("%d", &n);
printf("입력한숫자는 %d 입니다.\n", n);
return 0;
}- 수업014_함수.cpp
#include <stdio.h>
void print() {
printf("print() 함수입니다.\n");
}
int main(void) {
print();
print();
print();
return 0;
}- 수업014_함수02.cpp
#include <stdio.h>
void print(int a) {
printf("%d\n", a);
}
int main(void) {
print(10);
print(2);
print(3);
return 0;
}- 수업014_함수03.cpp
#include <stdio.h>
void plus(int a, int b) {
printf("%d\n", a + b);
}
void minus(int a, int b) {
printf("%d\n", a - b);
}
int main(void) {
plus(10, 3);
minus(10, 3);
return 0;
}- 수업014_함수04.cpp
- return은 자료형을 맞추어 주어야 한다.
- retrun이 없으면 void
- 있으면 자료형 맞추어 주기
#include <stdio.h>
int change(int n) {
n = 20;
return n;
}
int main(void) {
int n = 10;
printf("%d\n", n);
// 리턴으로 함수를 이용해 변수값을 변경할수있다.
n = change(n);
printf("%d\n", n);
return 0;
}- 수업014_함수05.cpp
#include <stdio.h>
#include <stdlib.h>
void swap(int a, int b){
int temp;
temp = a;
a = b;
b = temp;
}
int main(void) {
int k, j;
k = 3;
j = 2;
swap(k, j);
printf("%d %d \n", k, j); // 값이 안바뀜
//변수는 안 바뀐다.
return 0;
}- 수업015_함수와배열.cpp
- 변수는 바뀌지 않는다.
#include <stdio.h>
void temp(int a, int b) {
a = 30;
b = 40;
printf("temp() ==> %d %d \n", a, b);
}
int main(void) {
int a = 10;
int b = 20;
temp(a, b);
// 값이 전혀 바뀌지않는다.
printf("main() ==> %d %d \n", a , b);
return 0;
}- 수업015_함수와배열02.cpp
- 배열은 바뀐다.
#include <stdio.h>
void temp(int arr[]) {
arr[0] = 100;
arr[1] = 200;
arr[2] = 300;
}
int main(void) {
int arr[] = { 10, 20, 30 };
int i = 0;
for (i = 0; i < 3; i++)
printf("%d ", arr[i]);
printf("\n\n\n");
// 배열은 수정이 된다.
temp(arr);
for(i = 0; i < 3; i++)
printf("%d ",arr[i]);
printf("\n\n\n");
return 0;
}- _11_문제
- 문제014_함수02.cpp
#include <stdio.h>
#include <stdlib.h>
void swap(int a, int b){
int temp;
temp = a;
a = b;
b = temp;
}
int main(void) {
int k, j;
k = 3;
j = 2;
swap(k, j);
printf("%d %d \n", k, j); // 값이 안바뀜
return 0;
}- 문제014_함수03.cpp
- 프로그램은 위에서 아래로. 왼쪽에서 오른쪽으로
#include <stdio.h>
#include <stdlib.h>
// 함수전방선언 // 전방선언을 하면 main 밑에 함수를 정의할수있다.
int func(int n);
//모르기 때문에 위에 적어놓는것
int main(void) {
//main함수는 func이라는 함수를 모른다.
//그래서 에러가 난다.
//위에 적으면 밑으로 내려 갈 수 있다.
int num;
printf("%d\n" , func(5)); //5
return 0;
}
int func(int n){
if (n < 2)
return n;
else{
int i, tmp, curent = 1, last =0;
// 2 , 3 , 4 , 5
for (i = 2; i <= n; i++){
tmp = curent; // 1 //1 //2 //3
curent += last; // 1 //2 //3 //5
last = tmp; // 1 //1 //2 //3
printf("%d %d %d %d\n" , i , tmp , curent, last);
// 2 1 1 1
// 3 1 2 1
// 4 2 3 2
// 5 3 5 3
}
return curent;
}
}- 문제014_함수04.cpp
#include <stdio.h>
#include <stdlib.h>
int func(int base, int exp); //전반선언
int main(void) {
int res;
res = func(2, 10);
printf("main=> %d\n" , res);
return 0;
}
int func(int base, int exp){ // 2, 10
int res = 1;
int i =0;
//0 1 2 3 4 5 6 7 8 9
for (i = 0; i < exp; i++){
// 1 * 2, 2 * 2, 3 * 2, 4 * 2, 5 * 2, 6 * 2, 7 * 2, 8 *2, 9 * 2
res = res * base;
printf("%d \n" , res);
}
return res;
}- 문제014_함수05.cpp
- 전역 변수
- 밖에 있는 변수는 미리 만들어 진다.
- 자바에서는 스태틱과 같다.
- 그 다음에 main이 실행된다.
#include <stdio.h>
#include <stdlib.h>
// 함수와 전역변수
int a = 1, b = 2, c =3;
int f();
int main(void) {
printf("%3d\n", f()); //12
printf("%3d %3d %3d\n" , a , b , c);
//여기는 밑의 함수와 상관 없이. 위의 전역변수로 나온다.
// 4 2 3
return 0;
}
int f(){
int b, c; //먼저 우선순위
a = b = c = 4;
return (a + b + c);
}- 문제014_함수06.cpp
#include <stdio.h>
#include <stdlib.h>
int star = 10; //지역 변수
void printStar(){
printf("%d\n", star); //10
//이 star은 위의 지역 변수 10이다.
}
int main(void) {
int star = 5; //이것은 main안에서만 쓸 수 있다.
printStar();
printf("%d\n" , star); // 5
return 0;
}- 문제014_함수07.cpp
#include <stdio.h>
#include <stdlib.h>
//1. 전역변수. 3번 전역에 만들어 진다. 제일 먼저 만들어 진다.
int a = 10;
int b = 20;
int c = 30;
void func(void)
{
static int a = 100;
//스택틱도 전역변수에 만들어진다. 3번
//한번 하고. 2번째는 동작을 안한다. //2번째는 동작 x
//100이 아니라. 그래도 101이다.
int b = 200;
a++;
b++;
c = a;
}
//2. 그다음 main이 실행됨.
int main(void) {
func();
func(); //2번째
printf("a = %d, b = %d, c = %d\n", a, b, c);
return 0;
}출력 : a = 10 , b = 20, c = 102
- 문제015_함수와배열.cpp
#include <stdio.h>
void align(int a[]) { //배열은 바뀐다.
// 버블정렬
int temp;
int i;
int j;
// 0 1 2 3
for (i = 0; i < 4; i++) {
//0123, 012, 01, 0
for (j = 0; j < 4 - i; j++) {
// 85, 75, 50, 100, 95
// 75, 50, 85, 95, 100
// 50, 75, 85, 95, 100
// 50, 75, 85, 95, 100
if (a[j] > a[j + 1]) {
temp = a[j];
a[j] = a[j + 1];
a[j + 1] = temp;
}
}
}
}
int main(void) {
int a[] = { 85, 75, 50, 100, 95 };
align(a);
int i;
for (i = 0; i < 5; i++)
printf("%d ", a[i]);
return 0;
}- 문제-예제
- 예제001.cpp
- 스택에 만들 수 있는것
- 삭제를 못 한다.
#include<stdio.h>
#include<stdlib.h>
#define N 3
int main(void){
/*
c언어의 데이터 저장 종류
*/
/*
stack에 만들어지는 데이터
(1) 변수, (2) 일차배열, (3) 이차배열
*/
int a;
int arr[3];
int darr[3][3];
//지역변수로 만들 수 있다.
//원래는 못 만드는데.
//c언어는 만들 수 있따.
//main함수 안에 만들 수 있다.
return 0;
}- 예제002.cpp
- heap 만들 수 있다.
- heap만들면 삭제 할 수 있다.
#include<stdio.h>
#include<stdlib.h> //이게 있어야. malloc()을 쓸 수 있다.
#define N 3
int main(void){
/*
c언어의 데이터 저장 종류
*/
/*
heap 에 만들어지는 데이터
heap에 만들어지는 데이터는 반드시 사용후 삭제해야한다.
// 생성함수 malloc();
// 삭제키워드 free();
*/
/*
엠얼록사용법
엠얼록을 사용하여 heap에 공간을 생성할수있다.
단, 직접 원하는 바이트를 적어야한다.
malloc(바이트); //메모리 할당. 메모리얼록케이션?
*/
malloc(16); //공간 생성
return 0;
}- 예제003.cpp
#include<stdio.h>
#include<stdlib.h>
#define N 3
int main(void){
malloc(16); //=>new int[4];
//이렇게 만들면. heap에 메모리를 만든것.
//이렇게 만들면 메모리는 만들었는데. 사용할 수 없다.
//왜? 어디있는지 모르니까.
//자바에서
//int[]arr = new int[4];
//여기서 앞을 안 쓴것과 같다. new int[4];
//변수가 있어야. arr[1] = 100;
//c언어는 변수를 포인터
int * p; //=>int [] arr; 같다.
/*
이와같이 heap에 메모리를 생성하나 접근할수없기때문에 사용할수없다.
마치 자바의 int[] arr = new int[4]; 를 하지않고,
new int[4]; 만 한것이랑 같은 상황이다.
*/
/*
힙에 생성되기 때문에 주소를 저장해야 한다.
원하는 자료형의 포인터변수에 저장한다.
int * p = malloc(16); 는
자바의 int[]arr = new int[4]; 와 같은상황이다.
*/
int* p = malloc(16); //int[]arr = new int[4];
free(p); // 사용후에는 메모리삭제를 직접한다.
// 자바는 자동삭제가된다.
return 0;
}
- 예제004.cpp
#include<stdio.h>
#include<stdlib.h>
#define N 3
int main(void){
/*
int* p = malloc(16);
16은 보기가 않좋다.
malloc(16) => 통으로 메모리를 만든것
// 몇칸짜리인지 모른다.
그래서 (int*)을 붙여주어야 한다.
즉, 몇 바이트씩 나누어진지 모른다. 몇개씩 써야 하는지.
p[0] = 10;
4바이트에 들어가야하는데. 모른다는 것.
이렇게되면 생메모리 16바이트가 몇개로 나눠지는지
알수가없기때문에 int* p = (int*)malloc(16); 이와같이 형변환을한다.
그리면 malloc()은 아하 4바이트씩 사용한다는 것을 인지한다.
예를들어
char* cp = (char*)malloc(16);
은 char[] arr = new char[4]; 가아니라 char[] arr = new char[16];으로인지한다.
왜냐하면 char는 1바이트이기때문이다.
정리하면 (int*)malloc(16); 은 16바이트를 4바이트단위로 잘라줘라는뜻이다.
*/
// 아래 는 똑같은 16바이트지만 뜻이 완전히 다르다.
int * p = (int*)malloc(16);
//4바이트씩 나누라는 뜻
//자바로변형시 int[] arr = new int[4];
//(int*) => 형변환
//4개씩 나누어서 저장되고. p에 저장된다.
//p[15]; //이러면 에러
//p[0~3]; 이게 끝이다.
char* cp = (char*)malloc(16);
//1칸씩 저장해라. char*
// cp[0~15]; 1바이트니까. 가능하다.
//자바로변형시 char[] arr = new char[16];
return 0;
}- 예제005.cpp
#include<stdio.h>
#include<stdlib.h>
#define N 3
int main(void){
/*
int * p = (int*)malloc(16);
//16이 보기가 싫다.
위 형태에서 최종적으로 한번의 변화를 더한다. 16이라는 숫자는
아무래도 헷갈리는 위험이 있기때문이다.
*/
// SIZE는 4이고 sizeof(int) 또한 4이므로 16이된다.
//최종형태
int SIZE = 4;
int * p = (int*)malloc(SIZE * sizeof(int));
free(p);
// 결국 저한줄이 int[]arr = new int[SIZE]; 와같다.
return 0;
}- 예제006.cpp
#include<stdio.h>
#include<stdlib.h>
#define N 3
int main(void){
/*
포인터 변수의 종류
*/
int *p; // 일차배열
p = (int*)malloc(N * sizeof(int));
// 12바이트
// 3칸 배열
//----------------------------------------------
//2차배열
int (*pArr)[N];
//p가 3개 있는것
// 이차배열 // 스택과 힙이 반반섞어 만드는방법
pArr = (int(*)[N])malloc(N * N * sizeof(int)); // 3 * 3 * 4
//9칸
// 마치 아래와 같다.
//pArr[0] = (int*)malloc(N * sizeof(int));
//pArr[1] = (int*)malloc(N * sizeof(int));
//pArr[2] = (int*)malloc(N * sizeof(int));
int **pp; // 이차배열 // 온전히 힙으로만 만드는방법
pp = (int**)malloc(N * sizeof(int*)); // 머리만 3개 만들기
//각각 new를 한것
//머리를 저장하는것을 또 만든것
pp[0] = (int*)malloc(N * sizeof(int));
pp[1] = (int*)malloc(N * sizeof(int));
pp[2] = (int*)malloc(N * sizeof(int));
return 0;
}- 예제007.cpp
#include<stdio.h>
#include<stdlib.h>
#define N 3
int main(void){
int (*pArr)[N]; //머리 3개 만든것 //main에 만든것
pArr = (int(*)[N])malloc(N * N * sizeof(int));
int num = 0;
for(int i = 0; i < N; i++){ //2차원 배열도 된다.
//2차로 저장함
for(int j = 0; j < N; j++){
pArr[i][j] = num;
num += 1;
}
}
for(int i = 0; i < N; i++){
for(int j =0; j < N; j++){
printf("%d " , pArr[i][j]);
}
}
printf("\n\n");
// c언어 2차배열은 1차배열과 같다.
// 그러므로 첫번째 주소를 *p에 저장할수있다.
int * p; //그냥 배열
p = (int*)pArr; //주소를 준것
printf("%d %d %d",p[0], p[4], p[8]);
return 0;
}
반응형
'코딩 > C언어' 카테고리의 다른 글
| 수업022_포인터와문자열 ~ 수업022_포인터와문자열03, 문제022_포인터와문자열 ~ 문제022_포인터와문자열03 (1~5) (1) | 2025.07.04 |
|---|---|
| 수업021_포인터 ~ 수업021_포인터07 , 문제021_포인터 ~ 문제021_포인터04(1~3) (0) | 2025.07.03 |
| _11_교재 => 수업012_배열 ~ 수업012_배열03 , _11_문제 => 문제012_배열 ~ 문제012_배열08 (1~3) (1) | 2025.07.01 |
| c언어 해설 (0) | 2025.07.01 |
| _11_교재 => 수업011_반복문 ~ 수업011_반복문03 , _11_문제 => 문제011_반복문 ~ 문제011_반복문12(1~3) (1) | 2025.06.27 |