c 마지막

#include "stdafx.h"
#include <iostream>
#include <time.h>
#pragma pack(1)
#include <windows.h>
#pragma warning(disable:4996) //컴파일시 옵션 지정 , 4996 warning을 끄세요
 
// func84 복습
void func85() {
}
 
void func86() {
    int *a, *b, *c; // 
                    // 이 함수에 내부적으로 일어난길
                    // a가 주소를 받기위한 공간이 4byte 공간이 생겼다가 사라진다
                    // b가 주소를 받기위한 공간이 4byte 공간이 생겼다가 사라진다
                    // c가 주소를 받기위한 공간이 4byte 공간이 생겼다가 사라진다
                    // 총 12 바이트가 생겼다가 사라졌다.
                    // 포인터 : 누군가의 주소를 기억하기 위해서 태어났다
 
 
 
    int *ptr;
    ptr = new int;
 
 
 
    *ptr = 99;
    printf("주소받기 전의 메모리 주소 : %d, 할당 받은 주소 : %d, 할당 받은 값 : %d \n", &ptr, ptr, *ptr); // ex) 1000의 주소, 2000의 주소, 2000의 값
}
 
 
 
void func87() {
    int *a;
    int **b;
 
 
 
    // 존재하는 놈
    b = &a; // &a 말고는 존재하는 놈이 하나도 없다, b는 주소를 받아야한다
    a = new int; // a가 주소를 받았다. 이 이유만으로 *b도 쓸 수 있다
    **b = 99; // 값을 받고있다
    printf("%d \n", *a); //
 
 
 
    printf("%d %d %d \n", &a, a, *a);
    printf("%d %d %d \n", b, *b, **b); // 아래 위로 출력값이 같다. - 공유되고 있으므로
 
    delete a; // 하자마자 a도 못쓰지만 b도 못씀, 원상태로 돌아온것
 
 
 
              // *b = new int; // a가 주소받은 적이 없으니까 먼저 적지 못함
 
 
 
    b = &a; // 이전에 한번 받아 놓은것이 있으므로, 첫줄에서 받아놓은것,
            // *b는 주소받은 적이 없다
 
 
 
    *b = new int; // 주소받은 거와 공유므로 a와 받은것과 같은말 ,
 
    *a = 77; // *a는 값 받겠다
    printf("%d \n", **b); // 같이 공유되고 있음을 알아보기 위해
 
 
 
    printf("%d %d %d \n", &a, a, *a);
    printf("%d %d %d \n", b, *b, **b); // 아래 위로 같다.
 
    delete *b; // 혹은 a, 확보된 모습 그대로 해제, 같이 확보 받았으므로 무얼로 해제해도 상관없다.
}
 
 
 
 
 
void func88() {
 
    short **a; // &a 존재, 처음부터 존재, ex) &a = 500번지(주소이다
    a = new short*; // a 존재, ex) a = 1000번지, a도 결국 주소 저장하기 위해 , 500번지에 1000을 저장
    *a = new short; // *a 존재 ex) *a = 2000번지, 1000번지에 2000을 저장
    **a = 100; // 값을 쓰는 문법이다, **a는 100이다. 2000번지에 값100을 저장
               // 메모리 해제 아직안함
 
 
 
               // 확인용 샘플용 실전용 아님
    short *****b;
    short **c;
 
 
 
    /*
    // 실행은 안되지만 성립 가능한 문법
    *****b = **c; //
    // ****b = **c; // 한놈은 값을 한놈은 주소를
    ****b = *c;
    ***b = c;
    **b = &c; // c와 b공유 시킬 수 있는 문법, b가 주소를 받은 적이 없기때문에 공유를 할 수 없다, **b가 주소 받는다면,
    */
 
 
 
    b = new short****; // 주소 받아야함
    *b = new short***; //
    **b = &c; // new short** 도 가능하지만 c공유
              // c = new short*; // **b가 주소 받은것, 이 문법 때문에 사용할 수 있는 문법
 
 
 
    c = new short*; // c가 메모리 받는거나 ***b가 메모리 받는거나
    ****b = new short;
    **c = 100;
 
 
    printf("%d \n", *****b);
 
}
 
 
 
// 정석 문법
void func89() {
    char **a;
    char *b;
 
    a = &b; // 공유
    *a = new char[10];
    // *a나 b나 같음
 
 
 
    for (char i = 0; i < 10; i++)
    {
        b[i] = i;
    }
 
 
 
    for (char i = 0; i < 10; i++)
    {
        printf("%d ", b);
    }printf("\n");
 
 
    delete b; // 메모리 할당이 하나므로 포문 돌리지 않는다., 메모리 할당 a가 아닌 공유받은 b로 해제한다
 
 
 
              // 왜 이렇게 하느냐 -> 
              // 처음부터 b가 받고 버리지, 왜 a를 쓰는가
              // ..?
 
 
}
void func90(char **a, int s) { // a와b는 공유 - 주소던지고 주소 받는다 *a -> **a
    *a = new char[s]; // 10개 넘어온다 a -> *a
 
}
 
//
//int *b;
//func91(&b, 10, 100);
//for (int i = 0; i < 10; i++)
//{
//    printf("%02d ", b[i]);
//} printf("\n");
//
//
//
//delete[] b;
//
//
//
//func91(&b, 20, 1000);
//
//
//for (int i = 0; i < 20; i++)
//{
//    printf("%02d ", b[i]);
//}printf("\n");
//
//
//
//delete[] b;
//void func91(int **a, int s, int rn) {
//
//    *a = new int[s];
//
//    for (int i = 0; i < s; i++)
//    {
//        (*a)[i] = rand() % rn; //*a[i] // 연산자 우선순위
//    }
//}
//void func92() {
//    int **a;//주소 두번받아야 사용가능 공유or할당 -> int*(타입)      *a
//    a = new int *[10];//세로갯수
//    //int a[10];//위와 같은코드. 주소 10개
//    /*a[0] = new int[5];
//    a[1] = new int[5];
//    a[9] = new int[5];*/
//    for (int i = 0; i < 10; i++)
//    {
//        a[i] = new int[5];
//    }
//    //위의 과정이 밑의 과정과 같다.
//    int ar[10][5];//세로가로
//    for (int i = 0; i < 10; i++)//밖이 세로
//    {
//        for (int j = 0; j < 5; j++)
//        {
//            a[i][j] = i * 5+j;
//        }
//    }
//    for (int i = 0; i < 10; i++)
//    {
//        for (int j = 0; j < 5; j++)
//        {
//            printf("%02d ", a[i][j]);
//        }
//        printf("\n");
//    }
//    for (int i = 0; i < 10; i++)
//    {
//        delete[] a[i];
//    }
//    delete a;
//}
void func93() {
    
    int a[2][3][4];//만드는순서 123
    for (int i = 0; i < 2; i++)//다차원 배열 적은 순서대로 for문에 넣어주면된다.    
    {
        for (int j = 0; j < 3; j++)
        {
            for (int k = 0; k < 4; k++)
            {
                a[i][j][k] = rand() % 10;
                printf("%02d ",a[i][j][k]);
            }
            printf("\n");
        }
        printf("\n");
    }
    printf("\n\n");
    
    //int sum = 0;
    //for (int i = 0; i < 2; i++)//다차원 배열 적은 순서대로 for문에 넣어주면된다.    
    //{
    //    for (int j = 0; j < 3; j++)
    //    {
    //        for (int k = 0; k < 4; k++)
    //        {
    //            sum = a[i+1][j][k]+a[i][j][k];
    //            printf("%02d ", sum);
    //        }
    //        printf("\n");
    //    }
    //    printf("\n");
    //    break;
    //}
    for (int i = 0; i < 3; i++) 
    {
        for (int j = 0; j < 4; j++)
        {
            printf("%02d ", a[0][i][j] + a[1][i][j]);
        }
        printf("\n");
    }
}
void func94() {
    for (int i = 0; i < 10; i++)//for문 내용이 한줄이면 {}없이 사용가능
        printf("%d ", i);
 
 
    for (int i = 0; i < 2; i++)
        for (int j = 0; j < 3; j++)
            printf("호랑이");
 
    printf("\n\n");
 
    for (int i = 0; i < 2; i++)
            printf("토끼");//중간에 코드 걸리면안된다.
        for (int j = 0; j < 3; j++)
    printf("\n");
}
 
// func86();
// func87();
// func88();
// func89();
 
/*
char *b;



func90(&b,10); // b가 주소 던지면 a가 주소받는다, 10던지면 10받는다


for (char i = 0; i < 10; i++)
{
b[i] = i;  // 위의 함수는 내가 포인터를 던지고 인트를 던지면 메모리를 대신 확보해주는 함수
}



for (char i = 0; i < 10; i++)
{
printf("%d ", b[i]);
}printf("\n");


delete[] b; // b문법으로 메모리 해제, a와 공유 되었으믈


func90(&b,100); // 10000바이트 메모리를 가져옴


// 실행시키면 터진다. -> 첫번째 인수 전달 b는 쓸 수없다. b자체를 쓸 수 없다, 왜 포인터는 주소받기전에 사용할 수 없기 때문이다.
// 내가 지금 하고싶은 함수의 역할은 메모리를 대신 확보해서 끝내는 것
// b -> &b 는 *a로 못받음, **a로 받을 수 있음



for (char i = 0; i < 100; i++)
{
b[i] = i;
}

for (char i = 0; i < 100; i++)
{
printf("%d ", b[i]);
}printf("\n");


delete[] b;
*/
 
 
/*
// 1.
int *a = new int[10];
for (int i = 0; i < 10; i++)
{
a[i] = rand() % 100;

}

for (int i = 0; i < 10; i++)
{
printf("%02d ", a[i]);
}printf("\n");

delete[] a;


// 2.
//int *
a = new int[20];
for (int i = 0; i < 20; i++)
{
a[i] = rand() % 50;

}

for (int i = 0; i < 20; i++)
{
printf("%02d ", a[i]);
}printf("\n");

delete[] a;



// 3.
a = new int[30];
for (int i = 0; i < 30; i++)
{
a[i] = rand() % 80;

}

for (int i = 0; i < 30; i++)
{
printf("%02d ", a[i]);
}printf("\n");

delete[] a;

// 함수의 목적 : 자주 사용하는 코드, 반복되는 코드를 융통성있게 저장하는 목적
// 메모리 확보 갯수, 랜덤 갯수만 다를 뿐, 코드가 반복된다.
// 이런기능을 하는 함수를 만들어 사용하면 얼마나 유용하겠니
// 함수를 만들고 싶다
*/
void func95() {
    int n1, n2, n3;//n1은 나둬야된다.
    scanf("%d",&n1);
    scanf("%d", &n2);
    scanf("%d", &n3);
    int** *a;
    a = new int**[n1];
 
    /*a[0] = new int*[3];
    a[1] = new int*[3];
    a[2] = new int*[3];*/
    /*a[0][0] = new int[4];
    a[0][1] = new int[4];
    a[0][2] = new int[4];
    a[1][0] = new int[4];
    a[1][1] = new int[4];
    a[1][2] = new int[4];*/
    for (int i = 0; i < n1; i++)
        a[i] = new int*[n2];
 
    for (int i = 0; i < n1; i++)
        for (int j = 0; j < n2; j++)
            a[i][j] = new int[n3];
 
    for (int i = 0; i < n1; i++)//다차원 배열 적은 순서대로 for문에 넣어주면된다.    
        for (int j = 0; j < n2; j++)
            for (int k = 0; k < n3; k++)
                a[i][j][k] = rand() % 10;
 
    for (int i = 0; i < n1; i++)//다차원 배열 적은 순서대로 for문에 넣어주면된다.    
    {
        for (int j = 0; j < n2; j++)
        {
            for (int k = 0; k < n3; k++)
            {
                printf("%03d ", a[i][j][k]);
            }
            printf("\n");
        }
        printf("\n");
    }
    printf("\n");
    for (int i = 0; i < n2; i++)
    {
        for (int j = 0; j < n3; j++)
        {
            int sum = 0;
            for (int k = 0; k < n1; k++)
            {
                sum = sum + a[k][i][j];
            }
            printf("%03d ", sum);
        }
        printf("\n");
    }
    for (int i = 0; i < n1; i++)
        for (int j = 0; j < n2; j++)
            delete[] a[i][j];
 
    for (int i = 0; i < n1; i++)
        delete[] a[i];
 
    delete[] a;
}
void func96() {
    int a;
    if (3 > 2) 
        a = 10;
    else
        a = 20;
    printf("%d", a);
    /*int a;
    if (3 > 2) {
        a = 10;
    }
    else
        a = 20;
    printf("%d", a);*/
 
    if((3>2) ? 10 : 20)
        printf("%d", a);
    //조건에 만족하던지 만족하지 않던지 어쩃든 a가 값을 받는다 
}
void func97() {
    int a = 3,b=2;//대입연산자로 받아줘야된다.
    (a > b ? printf("호랑이\n") : printf("코끼리\n"));
    //위의 방식 보다는 아래방식이 맞다 대입이 되어진다.
    //조건에 맞는것이 대입된다.
    printf("%s", (a>b)?"호랑이":"코끼리");
}
//int a = func98();
//printf("%d", a);
//printf("%d", func98());
int func98() {
    /*if (3 > 2)
        return 100;
    else
        return 200;
*/
    
    return (3 > 2 ? 100 : 200);//쓰는법 
}
//printf("%d\n", func99(50, 100));
//printf("%d", func99(func99(3, 4), func99(4, 5)));
int func99(int a,int b) {//어떤수를 던지던 큰 숫자가 나온다.
    
    return (a>b)?a:b;
}
 
void func100() {//함수명은 같은 것을 쓸 수 없다. 그러나 인수를 넣으면 쓸 수 있다.
    printf("호랑이\n");
}
//함수재정의
//오버로딩
//인수의 갯수가 다르거나, 인수의 갯수가 같아도 타입이 다르면 오버로딩이 가능하다.
//func100();
//func100(1);
//func100(1, 2);
//func100((short)9);
//func100((int*)NULL);//int* 은 주소를 나타내는것 NULL을 0으로 봐서 쓸수없다.
//
//STRU100 s100 = { 10,20 };//구조체에 a,b값 넣어주기
//
//printf("%d %d\n", s100.a, s100.b);
void func100(int a) {
    //함수의 전달인수 갯수가 다르면 동일한 함수이름으로 사용할 수 있다.
    printf("코끼리\n");
}
void func100(int a,int b) {
    printf("앵무새\n");
}
void func100(short a) {//인수전달 갯수가 같아도 그 타입이 다르면 컴퓨터가 분별가능 
    //
    printf("토끼\n");//func100((short)9);인수전달 갯수가 같고 타입이 다르면 앞에 형변환을 적고 사용해야한다.
}
void func100(int *a) {
    printf("하마\n");
}
struct STRU100 {//구조체 선언
    int a, b;
};
void func100(STRU100 s) {//구조체의 변수를 함수에서 사용가능
    printf("%d %d", s.a, s.b);
}
//printf("%d\n", showmethemoney());
//printf("%d\n", showmethemoney(10000));
//printf("%d\n", showmethemoney(5000, 3));
int showmethemoney() {
    return 1000;
}
int showmethemoney(int a) {
    return a;
}
int showmethemoney(int a,int b) {
    return a*b;
}
//printf("%d", getarea(10));
int getarea(int a,int b) {//사각형의 면적 구하기
    return a * b;
}
int getarea(int radius) {//원의 넓이.
    return radius*radius*3;//(3.14)
}
//func101(10);
//
//int *t;
//func102(&t);
//for (int i = 0; i < 10; i++)
//{
//    t[i] = i;
//    printf("%d", t[i]);
//}
//delete[] t;
void func101(int a,int b=50,int c=100) {//인수값을 초기화시켜놓으면 초기화한 만큼 뺴고 던질수있다. - b만채울수없다 c부터 채우고 b가능,
    
    printf("%d %d %d\n", a, b, c);
}
void func102(int **p) {//가로세로 길이 모를 때 메모리할당을 위임하기위해 이차원배열 사용
 
                       //p는 &t의 주소를 받음
 
    *p = new int[10];
    //------------------홍래씨설명---------------------
 
    //**p는 p와 *p가 메모리할당을 받아야 **p를 사용할 수 있음 - 둘다 받아야된다.
 
    //메인에서 함수 콜 할때 &t의 주소를 p 가 받기 때문에 *p의 메모리를 10개 받으면 *p = t와 같기 때문에 
 
    //*t가 10개가 된다.
 
    //*LP와 *P의 차이는 예전개발자들은 LongPoint를 (4btye)를 사용하기 때문에 LP라 사용했지만
 
    //현재의 개발자들은 LongPoint라 사용하지않고 Point라 사용하기때문에 P라고 하게 되었다. 사실상 차이없음
    //즉 LP는 그냥 구조체와 포인터구조체를 구별하기 위하여 사용한다.
 
    //표준 구조체모양을 쓰고 main에서 LP구조체 라고 사용하게된다면 그것은 포인터구조체가 된다.
    //스코프 뒤의 *LPSTRU103 **LPLPSTRU103 은 전달인수타입이 될 때 
 
    //전달인수가 포인터*w라면 LPSTRU103의 전달인수는 **w인 2차원 포인터가 되고 
 
    //LPLPSTRU103의 전달인수는 ***w인 3차원포인터가 된다
 
 
 
}//표준 구조체 모양
typedef struct tagSTRU103{//tag붙인다. 구조체쓰는 두번째 방법
    int a;
    int b;
    int c;
    int d;
}STRU103,*LPSTRU103,*PSTRU103, **LPLPSTRU103;//LP와 P는 상관없음 세가지 방법
 
void func103(STRU103 s, LPSTRU103 t, LPSTRU103 *w, LPLPSTRU103 y) {
                        //포인터,    이차원,            이차원
}
void func104(SIZE **s) {
        //이차원포인터
    SIZE *tt;
    *s = new SIZE;//메모리 확보
    (*s)->cx = 10;
    (*s)->cy = 20;
}
void func105(SIZE **s) {
    *s = new SIZE[10];
    for (int i = 0; i < 10; i++)
    {
        (*s)[i].cx = i*10;
        (*s)[i].cy = i*100;
    }//열개받고 초기화까지
    
}
struct STRU106{
    int a;
    //char *name;
    //char home[10];
    //char salary;
    //char family;
    //int tel;
    //char id;
    //int password;
    void f1() {
        printf("나는 함수입니다.");
    }
    int b;
};
void func106() {
    STRU106 s;
    s.a = 10, s.b = 20;
    printf("%d %d\n", s.a, s.b);
    s.f1();
 
}
int main()
{
    srand((signed)time(NULL));
    STRU103 a = { 1,2,3,4 };
    STRU103 *b, *c;
    func103(a, &a,&b,&c);
 
 
    //func104(*tt);
    //printf("%d %d", tt->cx, tt->cy);
    
 
    /*func105(&tt);
    for (int i = 0; i < 10; i++)
    {
        printf("%d %d\n",tt[i].cx, tt[i].cy);
    }*/
    func106();
    
}
 
 

c++ oop 
 
object 객체
oriented 지향
p프로그래밍
 
struct대신 class를 쓴다.
속성       속성 + 동작(함수)
            
java의 부모는 c++
 
구조체 -> class
       초기화 - 생성자 
      변수 - 필드 ex)이름,나이,학번
      함수 - 메소드(클래스안에 들어있는 함수)
         일반적으로 쓰는 함수는 그냥 함수라 칭함.
 
object   비행기,붕어빵
 
instance class로 object를 만든다.
 
class만 만들어만 놓는것은 메모리 소모안된다.
 
class     설계도,붕어빵틀
 
변수     날개조립
함수    바퀴조립
    몸체조립
 
 
class안에들어있는 변수와 함수는 반드시 객체를 이용해야한다.
 
 
c++ oop
 
object 객체
oriented 지향
p프로그래밍
 
struct대신 class를 쓴다.
속성      속성 + 동작(함수)
         
java의 부모는 c++
 
구조체->   class
   초기화- 생성자
   변수- 필드
   함수- 메소드(클래스 안에 들어있는 함수) //funtion말고 method라고 주로사용
 
예시
바퀴조립,날개조립,몸체조립 다모여서 비행기 설계도
비행기의 설계도 (class)
비행기 (객체/object) //설계도를 보고 비행기를 만든다(instance화 시킨다)
 
설계도는 설계도일 뿐 실체는 없다(설계도 자체는 메모리를 소비하지 않는다, 객체가 만들어 지면서 메모리를 소비한다/ 문서가 늘어날 뿐 메모리 낭비x)
 
클래스 안에 들어있는 변수와 함수는 반드시 "객체."를 이용해야 한다.