c 5

#include "pch.h"
#include <iostream>
#include <time.h>
#include <windows.h>
//func01이 함수 이름이다.
//함수이름은 중복될 수 없다.
//void는 '없다'라는 의미를 가진다.
//함수는 이름을 불러야(call) 실행이 된다.
//func01함수를 call 한다.
//뒤에있는 void는 생략할 수 있다.
//함수를 call할때는 반드시 함수명뒤에 ()가 있어야된다.
//함수는 구태여 주석을 잡을 필요가 없다. - 안 부르면 콜안됨.
//컴파일창에서 ctrl + a 에 엔터를 치면 복붙이됨.
//ctrl k c k u
//func01(); - call한다는 얘기는 그 함수로 jump해서 실행후 다시 돌아오는 것.
void func01() {
    printf("함수 1번콜\n");
    printf("호 랑 이 \n");
}
//func02(); - 함수가 콜이되면 함수내용이 실행된다.
//함수는 한번이상 몇번이고 콜할수있다.
void func02() {
    printf("함수 2번콜\n");
    printf("라면먹고\n");
    printf("밥먹고\n");
}
void func03() {
    printf("함수 3번콜\n");
    for (int i = 0; i < 10; i++)
        printf("5*%d=%d\n", i, 5 * i);
}
void func04() {
    int s = 0;
    for (int i = 0; i <= 10; i++)
        s += i;
 
    printf("%d\n", s);
}
//내가 만든 구조체의 크기를 알고싶을때 sizeof()를 쓸 수 있다.
void func05() {
    char a = 10;//1byte 8bit
    short b = 20;//2byte
    long c = 30;//4byte - 반드시 4byte
    int d = 40;//4byte - 사용하고있는 컴퓨터의 비트수에 따라 다름. 64비트 컴퓨터에서는 8byte,32비트는 4byte, default = 4byte,
    float e = 3.14f;//4byte - 실수, 끝에 f붙여줘야된다. 오류날수있다.
    double f = 3.14;//8byte - 실수, float보단 정밀하다.
    bool g = true;//1byte - T or F , 0,1도가능
    printf("%d \n", sizeof(char));
    printf("%d \n", sizeof(short));
    printf("%d \n", sizeof(long));
    printf("%d \n", sizeof(int));
    printf("%d \n", sizeof(float));
    printf("%d \n", sizeof(double));
    printf("%d \n", sizeof(bool));
}
void func06() {
    int a = 10;
    int b = -10;
    signed int c = -20;//signed을 적으나 안적으나, 안적어도 default로 들어가있다(굳이 안적어도된다.) - 양수,음수 다 사용할 수 있다.
    unsigned int d = 30;//원래 int가 20억까지 쓸수있다면, unsigned 붙이면 40억까지 가능 but 음수안됨.
    //unsigned e = -30; 양수만 사용가능
    signed char e = 150;
    unsigned char f = 150;//max = 255 8bit는 2의8승 = 256, 0부터 255까지
    printf("%d %d\n", e, f);//e는 비정상적으로 출력됨
    //unsigned = 나이,볼륨의 감도,색상값
    //java에서는 안쓴다.
}
void func07() {
    int a = 123, b = 0x123, c = 0xab7;// d = ab7; 0x안붙이면 안됨 - 앞에 0x를 붙이면 16진수가되고, 출력은 10진수로된다. 0만붙이면 8진수 0,0x 8,16
    //int e = 0386; 8진수가 넘어가므로 오류가뜬다.
    int f = 0376;//8진수 376을 10진수로
    printf("%d %d %d %d \n", a, b, c, f);//2진법을 표현하는 문법은 없다.
}
//변수와 상수개념
//변수를 상수화시킬때 const(상수변수)를 붙인다.
void func08() {
    //int는 type, a = 변수,'='은 대입, 대입되는값을 literal이라고함.
    int a = 10, b = 20;
    a = 100;//a가 값을 대입받을 수 있다면 a는 변수 이다.
    b = 200;//b가 값을 대입받을 수 없다면 b는 상수이다.
    const int c = 30;//얘는 이 이후부터 상수가된다 - 대입을 받을 수 없다.
    //c = 300; const해서 대입 못받음.
    //const int d; - const변수는 무조건 초기값을 받아야된다, 이제 대입을 받을 수 없기 때문에.
    const int RainbowColorNumber = 7;//다른수로 안바뀌도록 고정하려고 씀 ,ex)1분 =60초 등
    const float pi = 3.14f;//고정값
    //20 = 30; 상수이기 때문에 대입받을 수없다..
}
//shift + tab
void func09() {
    /*
    printf("함수9번콜\n");
 //10      16      2      진수
    0      0      0000
    1      1      0001
    2      2      0010
    3      3      0011
    4      4      0100
    5      5      0101
    6      6      0110
    7      7      0111
    8      8      1000
    9      9      1001
    10      A      1010
    11      B      1011
    12      C      1100
    13      D      1101
    14      E      1110
    15      F      1111
    */
}
void func10() {
    for (int i = 0; i < 10; i++)
    {
    printf("%d\n", rand() % 100);
    }
}
//선물을 들고가는것 인수를 들고간다.
//func11(10);//인수 전달을 함수 호출할때 ()에 넣어준다.
//func11(); //인수전달을 받아야되는데 값이 없으므로 오류가뜬다.
void func11(int num) {//int num대신에 모든 타입들을 사용가능하다.
    //void func11(void)
    //(안의)void는 들고갈 선물이 없다는것
    //인수 전달 정수를 입력하면 num이 받는다
    printf("꽃다발 %d송이\n", num);
    //함수의 인수전달은 대입연산이다. num = 100가 생략되어있다. 대입연산은 반드시 서로 타입이 같아야된다. 
}
//func12(8);
void func12(int num) {//함수의 인수이름은 다른 함수의 인수이름과 같아도 상관없다.
    for (int i = 0; i < 10; i++)
        printf("%d*%d=%d\n", num,i, num * i);
}
//func13(100);
void func13(int num) {
    int s = 0;
    for (int i = 0; i <= num; i++)
        s += i;
 
    printf("%d\n", s);
}
//func14(10,20);
void func14(int a,int b) {//인수를 한 개 이상 던질 수 있다. void func14(int a,b) 이런식으로는 던질 수 없다.
    //인수 전달은 얼마든지 많이 사용해도 상관없다.
    printf("%d\n", a + b);
}
//func15('H',10,20,30.0f,true);//아스키코드 char a = 숫자 or '문', float는 30.0f 형식이 보기가 좋다.
void func15(char a,short b,unsigned long c,float d,bool e) {
    printf("%d %03d %3d %.03f %d\n", a, b, c, d, e);//타입별 받는 방식 봐두기 맨 앞의 char 는 %d = 아스키코드, %c는 문자, 
                                                                    //%.03f = 소수점 셋째자리까지, 03d는 공간을 세개준다 남는 앞자리는 0
}
//func16(10000,30);
void func16(int a,int b) {
    for (int i = 0; i < b; i++)
        printf("%d\n", rand() % a);
}
//func17('H',30);
void func17(char ch,int n) {//변수 하나만 쓸때는 char ch, int num,int n이라고 많이 씀
    for (int i = 0; i < n; i++)
    {
        printf("%c", ch);
        printf("%d", n);
    }
    printf("\n");
}
/*
    func18();//이떄는 써주지않아서 100이 증발함.
    int num = func18();//이떄 num은 100을 가지고있다.
    printf("%d\n", num);
    printf("%d\n", func18());
    */
int func18() {//void func18()에서 void는 들고갈게 없다이다.
    //함수에서 값을 리턴한다.
    //리턴값은 하나만 가능
    //리턴받는 것 세가지 방법이있다.
    printf("함수 18번이 콜되었습니다.\n");
    return 100;//반드시 리턴값이 있어야한다. 안써주면 리턴이 사라짐
}
//printf("%d", func19());
//printf("계란 %d개를 요리합니다.", func19());//출력이 아니라 가져온 것을 조합해서 쓸 수 있다.
//printf("라면 %d개를 요리합니다.", func19());
//printf("우동 %d개를 요리합니다.", func19());
int func19() {
    printf("함수 19번이 콜되었습니다.\n");
    printf("%d\n", 100);
    return 100;
}
//왜 함수에서 출력을 안하고 return값을 적절히 사용하는것에 대해 생각해보자.
//return을 활용하면 함수를 꼭 출력안해도 된다.(융통성있게 사용가능)
//printf("%d\n", func20(10,20));
int func20(int a,int b) {
    return a + b;
}
//printf("%d", func21(2, 8));
int func21(int a,int b) {
    int s = 1;
    for (int i = 0; i < b; i++)
    {
        s = s * a;
    }
    return s;
}
int func22() {
    //4가지형태 복습
    //void funcname(void)//전달인수와 return값 다 없다. - 함수원형 function prototype
    //void funcname(int a,int b,...)/전달되는 인수가있는데 return값이 없는경우
    //int funcname(void)/전달인수는 없는데 return값은 있다.
    //int funcname(int a,int b,....)/전달인수도 있고 return도 있다.
    return 0;
}
//int num = 100;
//func23(10, &num);//주소를 줘야되는데 값을주면 오류가 남. 이 상황에서는 &num빼고는 실행할 수 있는 것이 없다.
//printf("%d %d", num, &num);//b가 공유되었기떄문에 200이 나오게됨 = 주소는같은데 값은 바뀜.
void func23(int a,int *b) {//항상 인수전달은 대입연산이 이루어진다.
    //두번째 인수는 주소를 받겠다.(주소를 받기 전에는 사용 불가)
    printf("%d %d %d\n", a,b,*b);
    *b = 200;
}
//int x = 10, y = 20;
//printf("%d %d\n", x, y);//함수안에서 a,b의 데이터교환이 이루어진 것은 맞지만, 함수의 {}가 끝나면 메모리가 사라지기 때문에 그대로 값이 나온다.
//func24(x, y);
//printf("%d %d", x, y);
//call by value = 값에 의한 호출
void func24(int a,int b) {
    int t = a;
    a = b;
    b = t;
    printf("%d %d\n", a, b);
}
//int x = 10, y = 20;
//printf("%d %d\n", x, y);//값은 함수에서 {}가 끝나면 메모리가 삭제되지만 주소값은 공유가 되어 그대로 남아있다.
//func25(&x, &y);
//printf("%d %d", x, y);
//call by address = 주소에 의한 호출
void func25(int *a,int *b) {
    int t = *a;
    *a = *b;
    *b = t;
}
//int ar[] = { 3,4,5,6,7 };
//sizeof(ar)/sizeof(int)
//func26(&ar[0], sizeof(ar) / sizeof(int));//공유함
 
//printf("%d\n", sizeof(ar) / sizeof(int));//int type 메모리가 4개 = 16,배열의 크기를 구할때 사용하는 함수.
 
//for (int i = 0; i < sizeof(ar) / sizeof(int); i++)
    //printf("%d ", ar[i]);//공유가되서 가능
void func26(int *num,int s) {
    //printf("%d ", sizeof(num));//변수는 사이즈를 얻을 수 없다.
    for (int i = 0; i < s; i++)
    {
        num[i] = num[i] * 10;
    }
}
//받을때도 배열이므로 10개를 던져줘야된다.
//따로 한번 더 설명해주신다고 함.
//int ar[4] = { 1,2,3,4 };
//int br[4] = { 1,2,3,4 };
//func27(ar, br);//첫번째 ar은 값이 모두 0으로 복사, 두번째 ar은 *로 공유가 일어난것. (값에의한 것 ,주소에 의한 것)
//for (int i = 0; i < 4; i++)
//{
//    printf("%d %d\n", ar[i], br[i]);
//}
void func27(int a[4],int *b) {
    for (int i = 0; i < 4; i++)
    {
        a[i] = i * 10;
        b[i] = i * 10;
    }
}
//int *p = new int[5];
//func28(p);//p와 a를 공유
//delete[]p;
void func28(int *a) {
    for (int i = 0; i < 5; i++)
    {
        a[i] = i;
        printf("%d ", a[i]);
    }
}
//func29(new int[5]);//메모리 생성 동시에 함수 콜 - 함수를 콜하고 나서는 출력불가, 메모리 해제도 함수가 책임져야된다.
void func29(int *a) {
    int *p = new int[5];
 
    for (int i = 0; i < 5; i++)
    {
        a[i] = i;
        printf("%d ", a[i]);
    }
    printf("호");
    delete[]p;
}
//int funcname는 값이 return , int *funcname = 주소가 return
 
//func30();//함수가 메모리를 확보해서 해제를 할수가 없다. 쓸수 없다.
//    //printf("%d", func30());//return된 주소를 출력하려는 것 메모리 해제를 할 수 없다.
//int *t = func30();//공유를 받음 ->메모리 해제가능
//delete[]t;//셋 중 방법만 쓸 수 있다.
//delete[]func30();//콜하면서 바로 해제가능
int *func30() {
    printf("호");
    int *p = new int[5];
    return p;//주소를 return 해줘야된다.
}
//delete func31(new int[5]);
int *func31(int *a) {
 
    return a;
}
//int *p = new int[10];
    //func32(new int[10]);
    //delete[] p;
//delete[] func32(new int[10]);
int *func32(int *pp) {
 
    for (int i = 0; i < 10; i++)
    {
        pp[i] = i;
        printf("%d ", pp[i]);
    }
    return pp;
}
void func33() {
    printf("1");
    return;//return은 단독으로 쓰면 함수가 중단된다.
    printf("2");
}
//func34(-5);
void func34(int n) {
    if (n < 0) {
        printf("음수는 사용할 수 없습니다.");
        return;//이럴떄 사용 함수 실행시 음수를 던지면 종료
        printf("1");//도달할 수 없다.
    }
    if (n % 2 == 0) {
        printf("짝수입니다.");
    }
    else
        printf("홀수입니다.");
}
//int *funcname = 주소
//int funcname = 값
//func35();
int func35() {//리턴값이 있다고 해놓고 리턴값을 못만나게 하면 안된다.
    int n = 4;
    if (n == 3) {
        return 100;
    }
        return 200;
}
//출력보충 switch보충
int func36(int n) {
    switch (n)
    {
    case 10:
        return n * 10;
        //break; //return자체가 break역할을 하게 한다. 이유는 break되면 다음껄로 넘어갈수가없기 때문이다.
    case 20:
        return n * 20;
        //break;
    case 30:
        return n * 30;
        //break;//return값을 만날수있게 해줘야한다
    default:
        break;
    }
    printf("%d", n);
    
}//37,38,39는 확실히 구분하자
//func37(); func37(); func37();
void func37(int ct = 0) {//지역변수는 안에서만 돈다.
        ct++;
        printf("%d", ct);
        //for문이 아니라 부를떄마다 {}가 끝나면 메모리가 날아간다.
}
int ct = 0;//전역변수
void func38() {//지역변수를 넣지않고 밖으로 빼면 밖에서 돈다. - 전역과 지역을 같이써도 지역을 먼저쓰기 때문에 안에서 돈다.
    ct++;
    printf("%d", ct);
}
//38은 전역으로 모든 함수가 쓸 수 있지만 39는 지역변수로만 쓸수있다. 함수전용 전역변수이다. 다른함수못씀
void func39(static int ct = 0) {//static을 쓰면 컴파일시 지역변수를 전역변수로 쓴다.
    ct++;
    printf("%d", ct);
}
void func40() {
    int a = 3, b = a++;//대입증가 - 대입되고 증가
    printf("%d %d\n",a, b);
}
void func41() {
    int a = 3, b = ++a;
    printf("%d %d \n",a, b);
    int c = 3, d = 3;
    printf("%d %d \n", c++, ++d);//대입증가 c++ c는 사용되자마자 증가되어있다.
    printf("%d %d \n", c, d);//d는 사용후 증가됫고 c는 사용되자마자 증가되어있다.
 
}
//    func42(a, b);
    //함수안에서 쓰는 a와 main에서 선언된 변수a는 다른값이다.
//func43(a, b);
void func42(int a,int b) {
    printf("%d %d\n",a, b);
}
void func43(int a, int b) {
    printf("%d %d\n", &a, &b);
 
}
void func44(int x,int y) {
    //이중for문
    for (int a= 0;  a < y;  a++)
    {
        for (int b = 0; b < x; b++)
        {
            printf("[%d %d] ", a, b);
        }
        printf("\n");
    }
    printf("\n");
}
//func45( 4,3);
//가로 x,cx,width,horizantal,hor
//세로 y,cy,height,vertical,ver
void func45(int x, int y) {
    //이중for문
    for (int a = 0; a < y; a++)
    {
        for (int b = 0; b < x; b++)
        {
            printf("%02d ", rand()%100);
        }
        printf("\n");
    }
    printf("\n");
}
void func46() {
    //ex1
    int a = 10;
    a = 20;
    
    //ex2
    const int b = 20;//값이 초기화되야된다, 더이상 값을 바꿀수없다.
    //b = 30;  //상수가 되어서 값을 변경할 수 없다.
    
    //ex3
    int *c;
    c = new int;
    *c = 10;
 
    //ex4
    int n = 100;
    const int *d = &n;//값변경불가
    //*d=200 //오류
 
    d = new int;
    delete d;
    //ex5
    int s = 100;
    int *const e = &s;//주소받는 것이 상수화된것 이제 주소 변경불가. (주소 변경불가)
    //e = new int; //더 이상 주소를 받을 수 없다.
 
    //ex6
    int t = 100;
    const int *const f = &t;//주소변경 불가, 값변경불가.
    //*f = 10; 둘다안됨
    //f = new int;
}
//int ar[] = { 1,2,3,4,5 };
//func47(ar);
void func47(const int const *p) {//const 붙이면 밑에서 데이터를 갱신 할 수없다. 주소도 변경불가.
    
    for (int i = 0; i < 5; i++)
    {
        int n = rand();
        if (n == 7777) {
            //p[0] = 9999;
            printf("메롱");
        }
        printf("%d",p[i]);
    }
}
//func48();
//func48(10);
//func48(10, 20);
void func48(...) {//...은 인수전달을 몇개 할 지 모르겠다를 나타내는 문법이다.
    printf("1");
}
void func49(int a, int b,...) {//인수전달 두개는 무조건 해야된다.
    printf("1");
}
void func50() {
    printf("1");
    //커서 + ctrl f12
    int  printf(const char *const _Format, ...);//return 값이 있는 함수
    //int  printf(char _a, ...);//return 값이 있는 함수 위와 같다고 보면됨
    //""사이에 뭘 넣더라고 안넣어지게
    //_Format은 변수이름
 
    int n = printf("Apple");//printf가 return하는건 글자의 수
    printf("%d\n", n);
    printf("%d\n", printf("APPLEBANANA"));
}
void func51() {
    char ar[] = { 10,20,30,40,50,60,70 };
    for (int i = 0; i < 7; i++)
    {
        printf("%d ",ar[i]);
    }
    memset(ar,0,4);//0을 4개 넣는다.
    for (int i = 0; i < 7; i++)
    {
        printf("%d ", ar[i]);
    }
}
struct STRU52 {
    int a, b;
};
//STRU52 s = { 10, 20 };
//printf("%d %d\n", s.a, s.b);
//func52(100, s);0.0
//s.a = 77, s.b = 88;
//func52(200, s);
void func52(int n,STRU52 s) {//인수가 52번 타입이어야한다.
    printf("%d %d %d\n", n, s.a, s.b);
}
 
struct STRU53{
    int num;
    int *ptr;
};
//다시하기
//STRU53 t;
//t.num = 10;
//t.ptr = &t.num;//
//func53(t);
//
//*t.ptr = 20;
//t.ptr = new int;
//func53(t);
void func53(STRU53 s) {
    printf("%d %d %d\n", s.num, *s.ptr,s.ptr);//구조체 포인트 출력
    
}
struct STRU54 {
    int num;
    int *ptr;
};
//STRU54 t;
//t.num = 10;
//t.ptr = new int;//
//
//*t.ptr = 20;
//func54(&t);
//delete t.ptr;
//
//STRU54 *st;
//st = new STRU54;//메모리 받기
////func54(st); //st는 주소를 받고 사용해야된다. 
//st->num = 20;
//st->ptr = new int;//
//*st->ptr = 30;
//func54(st);
//delete st->ptr;
//delete st;
void func54(STRU54 *s) {//주소받는다.
    printf("%d %d %d\n", s->num, *s->ptr, s->ptr);//s. 쓸수없다. ->
}
struct STRU55 {
    int a, b;
};
//STRU55 s1 = { 10,20 };
//STRU55 s2 = { 30,40 };
//STRU55 s3 = func55(s1, s2);//55번타입으로 주고받는다.
//printf("%d %d\n", s3.a, s3.b);
STRU55 func55(STRU55 xx,STRU55 yy) {
    STRU55 result;
    result.a =xx.a + yy.a;//결과를 구조체값에 넣어주겠다.
    result.b = xx.b - yy.b;
    return result;//&result는 안됨.
}
//func56();
//int *pp = func56();//지역변수를 공유받으려고 하지만 스코프가 끝나면 지역변수가 끝나므로 데이터를 넣을수없다.
//printf("%d %d\n", *pp, pp);
int *func56() {//못쓰는함수
    int a = 10;
    return &a;//return 에 대한 메모리가 없음 스코프끝나면 사라짐
    
}
//int *pp = func57();
//delete pp;
int *func57() {//delete가 없으므로 안사라지고 유지된다.
    int *pp = new int;
    return pp;
}
#define APPLE58 (10) 
#define BANANA58 (20+30)
#define ORANGE58 (3+4)
//두개 곱할시 연산순서때문에 
#define MELON58 ((3)+(4))
#define KIWI58(a,b) ((a)+(b))
//#define     매크로함수 //타입간에 제약이없다, 매크로가 일반함수보다 속도가 훨씬 빠르다, 코드의 가독성이 떨어진다 괄호가 많아서.
//BANANA58이 나오면 50을 바꿔치기
//#define은 끝에 ';'안붙는다. //#define 뒤에 영문자는 보통 대문자를 쓴다. ex) APPLE
//#define 뒤에는 주석처리도 하지않는다. //컴파일될때 바꿔치기가 일어난다.
//.코드의 유지보수때문에 쓴다. //for문 숫자 바뀔때 
void func58() {
    printf("%d %d %d %d %d %d\n", APPLE58,APPLE58+10,BANANA58,ORANGE58*ORANGE58, MELON58*MELON58,KIWI58(5,8));
    printf("%d %d", max(3, 4), min(10, 20));
}
void func59(int a,int b,int c,int d) {
    int r1 = max(a, b);
    int r2 = max(c, d);
    int r3 = max(r1, r2);
    printf("%d", r3);
 
}
int main()
{    srand((signed)time(NULL));//srand는 함수에 넣는게아니라 main안에 한줄만 넣는다.
    //ctrl k c k u
    //ctrl shift enter
    func59(7,5,15,13);
 
}