int main(){
    return 1; //값 1을 반환함
}

int Sum(int value1, int value2){
    int result = value1 + alue2;
    return result;
}
void main(){
    int a = 2, b = 3;
    int value = Sum(a, b); 
}

/* o */
void ZeroData(int *p){
    *p = 0;
} 

/* x */
void Test(int value1, int value2){
    int result = value1 + value2;
    return result; //오류발생!!!
}

int Sum(int value1, int value2); //함수 원형 선언

void main(){
    int s = Sum(2, 3);
}

int Sum(int value1, int value2){
    int result = value1 + value 2;
    return result;
}

int Sum(int, int);

void main(){

    char data = 65;
    printf("%c 의 ASCII 값은 %d 입니다.", data, data);

    //출력 -> A의 ASCII 값은 65 입니다.
}

void main(){

    float value = 2.1f;
    printf("%f", value);

    //출력 -> 2.100000
}

voind main(){

    int data = 7;
    printf("[%d], [%5d], [%05d], [%-5d]", dat, data, data, data);

    //출력 -> [7], [    7], [00007], [7    ] 
}

void main(){

    double data = 3.141592;
    printf("[%f], [%.4f], [%8.4f], [%08.4f]", data, data, data, data, data);

    // 출력 -> [3.141592], [3.1416], [  3.1416], [003.1416]

}

void main(){

    int data1 = 5, data2 = 3;

    int result1 = data1 + data2; //덧셈
    int result2 = data1 * data2; //곱셈
    int result3 = data1 / data2; //나눗셈(몫)
    int result4 = data1 % data2; //나눗셈(나머지)
}

void main(){

    int data1 = 5, data2 = 3;

    int result1 = 0 || 1;
    int result2 = 3 && -1;
    int result3 = data1 == 3 || data2 == 3;
    int result4 = data1 == 3 && data2 == 3;
    int result5 = !data1;

    printf("%d, %d, %d, %d, %d, ", result1, result2, result3, result4, result5);

    //결과 -> 1, 1, 1, 0, 0
    //0이 아니면 다 참(1)으로 인지!!!!!!!!!

}

void main(){

    int score = 92;
    char grade;

    if(score >= 90){
        grade = 'A';
        printf("점수는 %d이고 등급은 %c입니다.\n", score, grade);
    }else{
        grade = 'B';
        printf("점수는 %d이고 등급은 %c입니다.\n", score, grade);
    }
    printf("작업종료");

    //결과 -> 점수는 92이고 등급은 A 입니다.
    //        작업종료
}

point = (value >= 10000) ? value * 0.1 : value * 0.5;

if(data > 5){
    return 1;
}else{
    return 0;
}

//삼항으로 변환
return (data > 5) ? 1 : 0;

void main(){

    int score = 86;
    char grade;

    if(score >= 90){
        grade = 'A';
    }else if(score >= 80){
        grade = 'B';
    }else if(score >= 70){
        grade = 'C';
    }else{
        grade = 'D';
    }

    printf("점수는 %d, 등급은 %c", score, grade);
    
    //결과 -> 점수는 86, 등급은 B
    
}

void main(){

    int score = 86;
    char grade;

    switch(score / 10){
        case 10:
        case 9:
            grade = 'A';
            break;
        case 8:
            grade = 'B';
            break;
        case 7:
            grade = 'C';
            break;
        default:
            grade = 'D';
            break;      
    }

    printf("점수는 %d, 등급은 %c", score, grade);
    
    //결과 -> 점수는 86, 등급은 B
}

void main(){

    int sum = 0, num;

    for(num = 1; num <= 5; num++){
        printf("num(%d) + sum(%d) = ", num, sum);
        sum += num;
        printf("%d\n", sum);
    }
    printf("\n result : num = %d, sum : %d", num, sum);
}
//결과 -> num(1) + sum(0) = 1
//        num(2) + sum(1) = 3
//        num(3) + sum(3) = 6
//        num(4) + sum(6) = 10
//        num(5) + sum(10) = 15
//        
//        result : num = 6, sum : 15

//시작조건은 이미 변수에서 초기화 했기 때문에 생략 가능
int sum = 0, num = 1;
for( ; num <= 5; num++){...}

//또는 시작조건에 쉼표를 사용하여 여러 개의 변수 초기화 가능
int sum, num;
for(sum = 0, num = 1; num<=5; num++){...}

void main(){

    int sum = 0;
    int num = 1;  //시작조건
    for( ; ; ){  //무한루프
        printf("num(%d) + sum(%d) = ", num, sum);
        sum += num;
        printf("%d\n", sum);
        num++;  //조건변화 수식
        if(num > 5){  //반복문 종료
            break;
        }
    }
    printf("\n result : num = %d, sum : %d", num, sum);
}
//결과 -> num(1) + sum(0) = 1
//        num(2) + sum(1) = 3
//        num(3) + sum(3) = 6
//        num(4) + sum(6) = 10
//        num(5) + sum(10) = 15
//        
//        result : num = 6, sum : 15

void main(){

    int sum = 0;
    int num = 1; //시작조건
    while(num <=5 ){ //종결조건
        printf("num(%d) + sum(%d) = ", num, sum);
        sum += num;
        printf("%d\n", sum);
        num++; //조건 변화 수식
    }
    printf("resut = num : %d, sum : %d", num, sum);
}
//결과 -> num(1) + sum(0) = 1
//        num(2) + sum(1) = 3
//        num(3) + sum(3) = 6
//        num(4) + sum(6) = 10
//        num(5) + sum(10) = 15
//        resut = num : 6, sum : 15

void main(){

    do{
        명령문;
    }while(종결조건);
}

void main(){

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

//결과 - > 2 * 1 = 2
//         2 * 2 = 4
//            ...
//         9 * 7 = 63
//         9 * 8 = 72

#define max 5
void main(){

    for(int col = 1; col <= max; col++){
        for(int i = 1; i < col; i++){
            printf("*");
        }
        printf("\n");
    }
}

//결과 - > *
//         **
//         ***
//         ****

#define max 5
void main(){

    for(int col = max; col > 1; col--){
        for(int i = 1; i < col; i++){
            printf("*");
        }
        printf("\n");
    }
}

//결과 -> ****
//        ***
//        **
//        *

#define max 5
void main() {
    int sc = 0;
    for (int step = 1; step <= max; step += 2) {

        sc = (max - step) / 2;
        for (int s = 1; s <= sc; s++) {
            printf(" ");
        }

        for (int i = 1; i <= step; i++) {
            printf("*");
        }
        printf("\n");
    }
}

// 결과 - >   *
//           ***
//          *****

void main(){
    int m, n;
    for(m = 5; m < 7; m++){
        for(n = 0; n < 3; n++){
            if(m == 5 && n ==1){ //m값은 5이고 n값은 1일 때 break문 수행
                break;
            }
            printf("m(%d) - n(%d)", m, n);
        }
        if(m == 5 && n == 1){
            break;
        }
    }
}

//결과 -> m(5) - n(0)

void main(){
    int m;
    for(m = 5; m < 8; m++){
        if(m == 6){  //m값이 6일 때 continue문 수행
            continue;
        }
        printf("m(%d)\n", m);
    }
}
// 결과 -> m(5)
//         m(7)

int ReturnNum(){
    int num = 5;
    return num;
}
void main(){
    ReturnNum();
    printf("%d", num);
}
// 결과 -> 11행의 num이 선언되지 않은 함수라면서 오류 발생

int Sum(int data1, int data2){   //매개변수 data1, data2는 Sum함수의 지역변수
    int result = data1 + data2; //해당 result와 아래 result는 서로 다른 메모리에 할당되어 값이 공유되지 않는다.
    return result;
}
void main(){
    int result;
    result = Sum(5, 3); //해당 result와 위의 result는 서로 다른 메모리에 할당되어 값이 공유되지 않는다. 초기화 되지 않아 어떤 값이 들어있는지 모름
    printf("5 + 3 = %d", result);
}

//Sum.c
int result = 0; //전역변수

void Sum(int data1, int data2){
    result = data1 + data2;
}

//----------------------------------------------------------------------------------------------------------------------------------------

//Main.c
void Sum(int, int);   //함수 원형 선언
exturn int result;    //전역변수 참조 선언

void main(){
    Sum(5, 3);
    printf("5 + 3 = %d",result);
}

void main(){
    short student[20];   //short 타입 변수 20개 만들어라

    student[1] = 10;  // 배열의 두번째 요소에 10 대입
}

short student[20]; //20은 무조건 상수!

int CNT = 30;
int arr[CNT]; //오류!!! 변수 안된다.

void main(){
    short student[20] = {0, };

    short data[5] = {3, };  // 결과 -> 3, 0, 0, 0, 0 처럼 된다
}

short data[] = {1, 2, 1, 2, 1};

void main(){
    char data[5] = {1, 2, 3, 4, 5};
    int result = 0, i;

    for(i = 0; i < 5; i++){
        result = result + data[i];
    }
    printf("data 배열의 각 요소의 합은 %d입니다.", result);
}

// 결과 -> data 배열의 각 요소의 합은 15입니다.

char data[6] = {'h', 'a', 'p', 'p', 'y', 0};  //문자개수는 5개이고 끝에 0을 덧붙여야 하므로 배열의 크기는 6
char data[6] = "happy";  //이렇게 쓰면 문자열의 끝에 NULL 문자 0이 자동으로 포함된다

#include <string.h> //문자열 표준 함수를 사용하기 위해 추가함

void main(){
    int data_length;
    char data[10] = {'h','a','p','p','y',0};

    data_length = strlen(data);
    printf("data length = %d", data_length);
}
//결과 -> data length = 5

#include <string.h>   //문자열 표준 함수를 사용하기 위해 추가함

void main(){
    char data[10] = "abc";
    char result[16];

    strcpy(result, data);
    strcat(result, "def");

    printf("%s + \"def\" = %s", data, result);
}
//결과 -> abc + "def" = abcdef

void main(){
    char data[12] = {0,0,2,0,1,1,0,0,2,1,0,2};
    int i, x, y;

    for(i = 0; i < 12; i++){
        x = i % 4 + 1; //열번호 구함
        y = i / 4 + 1; //행번호 구함
        printf("%d행 %d열에", y, x);

        if(data[i] == 1){
            printf("검은 돌이 놓여있습니다\n");
        }else if(data[i] == 2){
            printf("흰 돌이 놓여있습니다\n");
        }else{
            printf("돌이 없습니다.\n");
        }
    }
}
//결과 -> 1행 1열에돌이 없습니다.
//        1행 2열에돌이 없습니다.
//        ...
//        3행 3열에돌이 없습니다.
//        3행 4열에흰 돌이 놓여있습니다

void main(){
    char data[3][4] = { {0,0,2,0,}, {1,1,0,0,}, {2,1,0,2} };
    int x, y;

    for(y = 0; y < 3; y++){
        for(x = 0; x < 4; x++){
            printf("%d행 %d열에 ", y+1, x+1);

            if(data[y][x] == 1){
                printf("검은 돌이 놓여있습니다.\n");
            }else if(data[y][x] == 2){
                printf("흰 돌이 놓여있습니다.\n");
            }else{
                printf("돌이 없습니다.\n");
            }
        }
    }
}
//결과 -> 1행 1열에돌이 없습니다.
//        1행 2열에돌이 없습니다.
//        ...
//        3행 3열에돌이 없습니다.
//        3행 4열에흰 돌이 놓여있습니다

short birthday;
short *ptr; //포인터 변수 선언
ptr = &birthday; //birthday 변수의 주소를 ptr 변수에 대입
*ptr = 1042 //ptr에 저장된 주소에 가서 값 1042를 대입함. 즉 birthday = 1042

short *ptr = &birthday; //포인터 변수를 선언!
*ptr = 1042; //ptr 포인터가 가리키는 대상에 가서 1042 값을 대입하겠다는 의미. 정의!
//위와 아래는 같지 않다.

void Test(short data){
    short soft = 0;
    soft = data;  //soft = 5
    tips = 3;  //오류 발생
}
void main(){
    short tips = 5;
    Test(tips);
}
//data = tips;

void Test(short *ptr){
    short soft = 0;
    soft = *ptr;   //soft = tips;
    *ptr = 3;   //tips = 3;
}
void main(){
    short tips = 5;
    Test(&tips);
}
//ptr = &tips;

void Swap(int *pa, int *pb){
    int temp = *pa; //참조
    *pa = *pb; //복사
    *pb = temp; //참조
}
void main(){
    int start = 96, end = 5;

    if(start > end){
        Swap(&start, &end);
    }

    printf("start : %d, end : %d", start, end);
}
// 결과 -> start : 5, end : 96

short data = 0;
short *p = &data;
p = p+1; //포인터 변수에 저장된 주소 값을 1만큼 증가시킴

char *p1 = (char *)100; //p1에 100번지를 저장함
short *p2 = (short *)100;
int *p3 = (int *)100;
double *p3 = (double *)100;
p1++; //1바이트이기 때문에 p1에 저장된 주소값이 101
p2++; //2바이트라서 102
p3++; //4바이트라서 104
p4++; //8바이트라서 108

int data = 0;
short *p = (short *)&data;
//앞에 두칸만 갖다 사용

void main(){
    int data = 0x12345678, i;
    char *p = (char *)&data;

    for(i = 0; i < 4; i++){
        printf("%x, ", *p);
        p++;
    }
}
// 결과 -> 78, 56, 34, 12,

for(i = 0; i < 4; i++){
    printf("%x, ", *(p + i) );
}

int data = 0;
void *p = &data; //data의 시작 주소를 저장함
*p = 5 //오류 발생. 대상 메모리의 크기가 지정되지 않음.

int data = 0;
void *p = &data;
*(int *)p = 5; //형 변환 문법을 사용하여 대상의 크기를 4바이트로 지정하므로 data 변수에 5가 저장됨

int GetData(void *p_data, char type){
    int result = 0;

    if(type == 1){
        result = *(char *)p_data; 
    }else if(type == 2){
        result = *(short *)p_data;
    }else if(type == 4){
        result = *(int *)p_data;
    }
    return result;
}
void main(){
    int data = 0x12345678;
    printf("%x", GetData(&data, 2));
}
//결과 -> 5678

rewind(stdin); //rewind 함수를 사용하면 입력 버퍼를 초기화 할 수 있음

void main(){
    int input_data;

    input_data = getchar();
    printf("first : %c\n", input_data);

    input_data = getchar();
    printf("second : %c\n", input_data);
}
//결과
//a
//first : a
//second :

void main(){
    char input_string[10];
    gets(input_string);   //gets를 안쓰고 input_string만쓰면 주소값만 출력된다.
    printf("input : %s", input_string);
}

void main(){
    char input_string[10];
    if(NULL != gets(input_string)){
        printf("input : %s", input_string);
    }else{
        printf("input -> cancled");
    }
}

#include <stdlib.h> //atoi 함수를 사용하기 위해 포함
void main(){
    int first_num, second_num;
    char first_string[16], second_string[16];

    printf("input first number : ");
    gets("first_string");

    printf("input second number :");
    gets("second_string");

    first_num = atoi(first_string);
    second_num = atoi(second_string);

    printf("%d + %d = %d", first_num, second_num, first_num + second_num);
}

int data;
scanf("%d", &data);
//scanf 함수의 기본 형태

void main(){
    int int_data;
    float float_data;

    scanf("%d", &int_data);
    scanf("%f", &float_data);

    printf("input : %d, %f", input_data, float_data);
}

char data1 = 5;
short data2 = 6;
int data3 = 7;
printf("%d %d %d", data1, data2, data3) //정상적으로 5,6,7 출력
scanf("%d %d %d", &data1, &data2, &data3); //번역할 때 오류는 없지만 실행할 때 문제 발생. (data1, data2가 자료형이 다름)

void main(){
    int num = 0;

    while(1){   //무한루프
        printf("input age : ");

        if( scanf("%d", &num) == 0 ){   //숫자가 아닌 값을 입력하면 0
            rewind(stdin);
            printf("[Enter] digit number! \n");
        }else{
            if(num > 0 && num < 130){
                break;   //정상적으로 입력되었기 때문에 반복문을 빠져나감
            }else{
                printf("incorrect age!\n"); //나이의 범위가 잘못입력
            }
        }

    }
    printf("your age : %d", num); //입력된 나이 출력
}

void main(){
    //배열
    char data[5];
    data[1] = 5;      //아래의 *(data + 1) = 5; 는 해당 data[1] = 5;와 같음
    *(data + 1) = 5;  //위의 data[1] = 5;는 해당 *(data + 1) = 5;와 같음

    //포인터
    char data;
    char *p = &data; //data 변수의 주소를 p에 저장
    *p = 3; //p가 가리키는data 변수에 3을 대입. 아래줄과 같음
    p[0] = 3;  //*p = 3;과 같음. 위줄과 같음
}

void main(){
    char data[5] = {1,2,3,4,5};
    int result = 0, i;
    char *p = data;

    for(i = 0; i < 5; i++){
        result = result + *p;
        p++;
    }
    printf("data 배열의 각 요소의 합은 %d입니다.", result);
}
// 결과 -> data 배열의 각 요소의 합은 15입니다.

void main(){
    char *p[5];   //char *p1, *p2, *p3, *p4, *p5;라고 선언한것과 같음
}

void main(){
    char data[3][5];
    char (*p)[5]; //char[5] 크기의 대상을 가리킬 수 있는 포인터 선언. 가독성이 떨어져서 교수님도 잘 안씀
    p = data; //포인터 변수 p는 2차원 배열 data 변수의 시작 주소를 저장
    (*p)[1] = 3; // p가 가리키는 대상의 2번재 항목에 3을 대입. p[0][1];과 같음
    (*(p+1))[2] = 4; //p+1이 가리키는 대상의 3번재 항목에 4를 대입. p[1][2]=4;와 같음
    (*(p+2))[4] = 5;  //p+2가 가리키는 대상의 5번째 항목에 5를 대입. p[2][4]=5;와 같음
    
    //-------------------------------------------위는 교재 내용임

    (*p)[5]; //포인터와 배열이 결합해서 2차원됐음. 줄을 의미(가로)
    //p[0] -> p+0 줄로 이동
    //p[1] -> p+1 줄로 이동

    //-------------------------------------------위아래 교수님 내용

    (*p3)[5] // 한줄
    p3 + 1 //다음줄로 이동
    *(p3+1) + x //x 옆으로 이동. 옆으로 이동하고싶으면 별쳐주기
    *(*(p3+1)+x) //해당 값 가져오기. 별 더쳐주면 갑 가져오기    
}

short *p = (short *)malloc(100);
if(p != NULL){
    //메모리 할당에 성공함. 이 시점부터 100바이트 메모리 사용 가능
}else{
    //메모리 할당에 실패
}

int data_size = 3;
int data[data_size]; //배열의 요소 개수는 상수만 명시! 오류발생

int data_size = 12;
int *p = (int *)malloc(data_size); //12바이트의 메모리가 동적 할당됨

#include <malloc.h>

void main(){
    int *p_num_list, count = 0, sum = 0, limit = 0, i;
    
    printf("사용할 최대 개수를 입력하세요 : ");
    scanf("%d", &limit);

    p_num_list = (int *)malloc(sizeof(int)*limit);  //사용자가 입력한 개수만큼 정수를 저장할 수 있는 메모리를 할당

    while(count < limit){
        printf("숫자를 입력하세요 (9999를 누르면 종료) : ");
        scanf("%d", p_num_list + count);
        if(*(p_num_list + count) == 9999){
            break;
        }
        count++;
    }

    for(i = 0; i < count; i++){
        if(i > 0){
            printf(" + ");
        }
        printf("%d", *(p_num_list + i));
        sum = sum + *(p_num_list + i);
    }

    printf(" = %d\n", sum);
    free(p_num_list);
}

short data = 0;
int my_ptr = (int)&data; //&data는 short * 형식의 값을 가지기 때문에 int형 변수인 my_ptr에 저장하기 위해서 형변환한다. 4바이트 크기라서 정상적으로 주소 저장
*my_ptr = 3; //오류 발생. my_ptr은 포인터가 아니라서 * 연산자 사용 할 수 없다.

void main(){
    short data =3;
    short *p = &data;
    short **pp = &p; //1차원 포인터 p변수의 주소 값을 2차원 포인터 p에 저장

    printf("[before] data : %d\n", data);
    *p = 4;
    printf("[use *p] data : %d\n", data);
    **pp = 5;
    printf("[use **pp] data : %d\n", data);

}

void main(){
    short **pp; //2차 포인터만 있기때문에 1차 포인터 공간 만들어줘야 함
    pp = (short **)malloc(sizeof(short *)); //1차 포인터 공간 만들어줌. 4바이트 할당. sizeof short*은 포인터공간이라 무조건 4바이트!. 앞에 short** 별 두개 붙은거는 pp가 2차포인터라서 맞춰줌
    *pp = (short *)malloc(sizeof(short)); //1차 포인터가 가리키는 실제 값 공간 만들어줌. 실제값이 저장되는 공간이라 sizeof 뒤에 별 안붙음. 앞에 short *별 하나 붙는거는 pp가 1차 포인터 별 1개붙은거라 맞춰줌.

    **pp = 10;
    printf("**pp : %d\n", **pp);
    free(*pp); //나중에 만든 것부터 지워야 함!
    free(pp);
}

void GetMyData(int *q){ // 매개변수와 main의 포인터는 둘 다 1차포인터
  q = (int *)malloc(8);
}

void main(){
  int *p; // GetMyData의 매개변수와 이것 둘 다 1차포인터
  GetMyData(p); //주소가 아닌 자기의 값을 넘겨준것. 
  *p = 5; //오류발생. 할당된 메모리의 첫 4바이트에 값 5를 넣음.
  free(p);
}

void GetMyData(int **q){
  *q = (int *)malloc(8);
}
void main(){
  int *p;
  GetMyData(&p);
  *p = 5;
  free(p);
}

  short *p[100];  // short * 형식의 1차원 포인터를 100개 선언

short **pp;
pp = (short **)malloc(sizeof(short *)); //pp = (short **)malloc(4); 와 같은 표현. 뒤에 (short *)로 1차 포인터 공간을 만들어줌. (포인터는 무조건 4바이트)

int n;
short **pp;
scanf("%d", &n);
pp = (short **)malloc(sizeof(short *) * n);

#include <malloc.h>

void main(){
  unsigned char *p_limit_table; //연령별 인원수를 저장할 포인터. 사용자에게 입력받음
  unsigned char **p; //연령별 윗몸 일으키기 횟수를 저장할 2차원 포인터
  int age, age_step, member, temp, sum;

  printf("20대부터 시작해서 연령층이 몇 개 인가요 : ");
  scanf("%d", &age_step);

  p_limit_table = (unsigned char *)malloc(age_step);
  p = (unsigned char **)malloc(sizeof(unsigned char *) * age_step); //!!1차원 포인터 공간 먼저 확보!!

  for(age = 0; age < age_step; age++){ //연령별로 윗몸일으키기 횟수 입력받음
    printf("\n %d 0대 연령의 윗몸 일으키기 횟수 \n", age+2);
    
    printf("이 연령대는 몇 명입니까? : ");
    scanf("%d", &temp);
    *(p_limit_table + age) = (unsigned char)temp;

    *(p + age) = (unsigned char *)malloc(*(p_limit_table + age)); //입력받은 인원수만큼 메모리 할당. !!실제 값이 저장될 공간 만들기!!

    for(member = 0; member < *(p_limit_table + age); member++){
      printf("%d th: ", member + 1);
      scanf("%d", &temp);
      *(*(p + age) + member) = (unsigned char)temp;
    }
  }

  printf("\n\n 연령별 평균 윗몸일으키기 횟수 \n");
  for(age = 0; age <age_step; age++){
    sum = 0;

    printf("%d 0대 : ", age+2); //20대, 30대, 40대라고 출력함
    for(member = 0; member < *(p_limit_table + age); member++){
      sum = sum + *(*(p + age) + member); //해당 연령 사람들의 횟수 합산함
    }

    printf("%5.2f \n", (double)sum / *(p_limit_table + age));
    free(*(p_age));
  }

  free(p);
  free(p_limit_table);
}

void main(){
  char **p;
  int i;
  
  p = (char **)malloc(sizeof(char *) * 2);
  for(i = 0; i < 2; i++){
    *(p + i) = (char *)malloc(sizeof(char) * 3);
  }

  for(i = 0; i < 2; i++){
    free(*(p + i));
  }
  free(p)
}

typedef unsifned short int US;
US temp; //unsigned short int temp;라고 선언한 것과 같음

struct People{
  char name[12]; //이름, 12바이트. 얘네를 멤버라고 부름
  unsigned short int age; //나이 2바이트. 얘네를 멤버라고 부름
  float height; //키 4바이트. 얘네를 멤버라고 부름
  float weight; //몸무게 4바이트. 얘네를 멤버라고 부름
}

typedef struct People{
  char name[12];
  unsigned short int age;
  float height;
  float weight;
}Person;   //첫번째줄 typedef와 맨마지막줄 Person 눈여겨 봐라!

typedef struct People{
  char name[12];
  unsigned short int age;
  float height;
  float weight;
}Person;

void main(){
  Person data; //person 자료형으로 data 변수 선언. 꼭 해줘야 함!

  printf("이름 : ");
  scanf("%s", data.name);

  printf("나이 : ");
  scanf("%hu", &data.age);

  printf("키 : ");
  scanf("%f", &data.height);

  printf("%s : %d세, %.1f cm", data.name, data.age, data.height);
}

Person friends[3]; //person 데이터 3개를 저장할 수 있는 메모리를 할당
friends[1].age = 22; //두번째 요소의 age에 값 22를 대입

Person data; //person 자료형으로 data 변수 선언
Person *p; //person 형식으로 선언한 메모리에 접근할 수 있는 포인터 선언
p = &data; //포인터 변수 p는 data 변수의 주소 값을 저장
(*p).age = 23; //p에 저장된 주소에 가서 age 요소에 값 23 대입
p->age = 23;   //위와 같은 방식. 위에거 불편하니 이거 씀. ->양옆 공백을 띄우지 않음.  

struct Test *p1 = (struct Test *)malloc(16); //설정에 따라 오류가 발생할 수 있음
struct Test *p2 = (struct Test *)malloc(sizeof(struct Test)); // 이렇게 사용해야 함! 고정적으로 사이즈 주지 말고 동적이게. 변경되도 대응 가능하게.

#include <malloc.h>

typedef struct node{
  int number;
  struct node *p_next;    //다음 노드를 기리킬 포인터
}NODE;

void AddNumber(NODE **pp_head, NODE **pp_tail, int data){

  if(NULL != *pp_head){

    (*pp_tail)->p_next = (NODE *)malloc(sizeof(NODE));
    *pp_tail = (*pp_tail)->p_next;    //p_tail(*pp_tail)에 새 노드의 주소 값 저장. 꼬리 새로워짐

  }else{

    //p_head 값이 NULL이라서 첫 노드가 추가됨. p_head 값에 직접 대입함
    *pp_head = (NODE *)malloc(sizeof(NODE));
    *pp_tail = *pp_head;    //새 노드의 주소 값을 p_tail(*pp_tail)에 저장
  }

  
  (*pp_tail)->number = data;    //새 노드의 number에 data 값을 저장
  (*pp_tail)->p_next = NULL;    //다음 노드가 없음을 명시

}

void main(){

  NODE *p_head = NULL, *p_tail = NULL, *p;
  int sum = 0, temp;
  
  while(1){
    printf("숫자를 입력하세요(9999를 누르면 종료) : ");
    scanf("%d", &temp);

    if(9999 == temp){
      break;
    }

    AddNumber(&p_head, &p_tail, temp);
  }

  p = p_head;  
  while(NULL != p){

    if(p != p_head){
      printf(" + ");
    }
    printf("%d", p->number);    //입력한 숫자 출력
    sum = sum + p->number;    //입력한 숫자 합산
    p = p->p_next;    //다음 노드로 이동
  }
  printf(" = %d \n", sum);    //합산 값 출력

  while(NULL != p_head){
    p = p_head;    //현재 노드를 삭제하기 위해 p변수에 노드 주소 값을 저장
    p_head = p_head->p_next;    //시작 위치를 다음 노드로 옮김
    free(p);
  }
  p_tail = p_head;    //반복문을 나오면 p_head 값은 NULL. p_tail값도 NULL로 변함
}

int data_size = sizeof(temp);  //변수 크기를 구함. data_size에는 값 8이 저장됨

int data_size = strlen(temp);  //문자열 길이를 구함. data_size에는 값 3이 저장

char temp[8] = {'a','b','c',0.};
char dest[8];
memcpy(dest, temp, sizeof(temp)); //temp에서 dest로 8바이트 크기만큼 메모리 복사

char temp[8] = {'a','b','c',0.};
char dest[8];
strcpy(dest, temp); //temp에서 dest로 4바이트 크기(NULL 문자 0까지 포함)만큼 복사

FILE *p_file;
//파일열기 생략함
fseek(p_file, 0, SEEK_SET);

FILE *p_file = fopen("tipssoft.dat", "r");   //주소값은 #define or const or 상수로 몰아넣어줘야 한다!!! 무조건!!!
if(p_file != NULL){
  //파일 열기에 성공한 경우
}else{
  //파일 열기에 실패한 경우
}

FILE *p_file = fopen("tips.dat", "rb");  //rb대신 r만 사용해도 됨. 바이너리 파일을 여는 경우

FILE *p_file = fopen("tips.dat", "rt");  //텍스트 파일 열 때.

FILE *p_file = fopen("tips.dat", "wb");  //wb대신 w만 사용해도 됨. 바이너리 파일을 여는 경우

FILE *p_file = fopen("tips.dat", "wt");  //텍스트 파일 열 때.

FILE *p_file = fopen("tips.dat", "ab");  //ab대신 a만 사용해도 됨. 바이너리 파일을 여는 경우

FILE *p_file = fopen("tips.dat", "at");  //텍스트 파일 열 때.

void main(){
  FILE *p_file = fopen("abc.txt", "wt")  //쓰기 모드로 텍스트 파일 오픈
  if(NULL != p_file){  //파일 열기에 성공한 경우
    fprintf(p_file, "HELLO");
    fclose(p_file);  //파일 닫기
  }
}
//해당 파일이 없으면 텍스트파일 자동으로 생성 후 문자열 저장한다.

void main(){
  int num;
  FILE *p_file = fopen("abc.txt", "rt");
  if(NULL != p_file){
    while(EOF != fscanf(p_file, "%d", &num)){  //텍스트 파일의 끝(End Of File). 따라서 EOF를 반환할 때까지 반복하면서 숫자값을 읽어온다.
      printf("%d", num);
    }
    fclose(p_file);
  }
}

void main(){
  char temp[64];
  FILE *p_file = fopen("abc.txt", "rt");
  if(NULL != p_file){
    while(NULL != fgets(temp, sizeof(temp), p_file)){  
      printf("%s", temp);
    }
    fclose(p_file);
  }
}

void main(){
  int data = 0x0000412;
  FILE *p_file = fopen("abc.txt", "wb");
  if(NULL != p_file){
    fwrite(&data, sizeof(int), 1, p_file);
    fclose(p_file);
  }
}

int data[5] = {0,1,2,3,4};
fwrite(data, sizeof(int), 5, p_file); //위아래 같음
fwrite(data, sizeof(int) * 5, 1, p_file); //위아래 같음. 이렇게 사용하는 경우가 더 많음

int (*p)(int, int); //sum 함수를 가리킬 수 있는 함수 포인터를 선언.(함수 원형을 담은 포인터 선언)
p = &Sum //sum 함수의 주소를 p에 저장

int result = (*p)(2,3); //int result = Sum(2,3)l 과 같음. 5 저장