IT

/*
   배열의 첫 번째 인덱스 값은 생략해도 되지만
   두 번째 인덱스부터는 값을 입력해야 한다.
   ex) mat[3][7][4] -> int sum_matrix(int mat[][7][4])
       call = sum_matrix(mat)
*/

#include <stdio.h>

//int sum_matrix(int mat[][3])
int sum_matrix(int (*mat)[3])
{
        int i;
        i = mat[0][0] + mat[1][1] + mat[2][2];
        return i;
}

int main()
{
        int sum, mat[3][3] = {  {13,23,15},
                                           {11,8,25},
                                           {17,14,21}};

        sum = sum_matrix(mat);
        printf("Answer: %d\n",sum);

        return 0;
}

/* 

   배열 식 : 포인터식

   일차원 배열 a[1] = *(a+1)

   이차원 배열 b[2][3] = *(*(b+2)+3)

   
   배열 & 포인터 혼합식

   이차원 배열 b[2][3] = *(b[2]+3)

*/

#include <stdio.h>
int main()
{
        int i,j;
        int array[3][4]={ {15,23,45,56},
                                 {34,52,76,23},
                                 {43,62,91,84}};

        printf("array = %d,p=%08x\n",array[1][1],&array[1][1]);

        printf("pointer = %d,p=%08x\n",*(*(array+1)+1),*(array+1)+1);

        printf("array=%08x\n",array);

        printf("\n");

 
       printf("array[0]=%08x\n",array[0]);

        printf("array[1]=%08x\n",array[1]);

        printf("array[2]=%08x\n",array[2]);

        printf("\n");

        printf("array+0=%08x\n",array+0);

        printf("array+1=%08x\n",array+1);

        printf("array+2=%08x\n",array+2);

       
        printf("\n");

        printf("array[1]+1=%08x\n",array[1]+1);

        printf("*(array[1]+1)=%d\n",*(array[1]+1));

        printf("*(*(array+1)+1)=%d\n",*(*(array+1)+1));

        printf("\n");

        // 행의 이동

        printf("(array+0)+1=%08x\n",(array+0)+1);

        // 열의 이동

        printf("array[0]+1=%08x\n",array[0]+1);

        printf("*(array+0)+1=%08x\n",*(array+0)+1);

        printf("&array[0]+1=%08x\n",&array[0]+1);

        printf("&array+1=%08x\n",&array+1);

        return 0;

}

const int a = 3;
// a는 상수이므로 a=3 (X) 변경할 수 없다.

const int *p = &a;
// *p는 상수이므로 *p=100 (X) 변경할 수 없다.
// p = &b 변경은 가능하다.

int * const p = &a;
// p는 상수이므로 p=&b (X) 변경할 수 없다.
// *p = 100 변경은 가능하다.

const int * const k = &a;
// k = &b (X) 변경 할 수 없다.
// *k = 200 (X) 변경 할 수 없다.

#include <stdio.h>

 int main()
{ 
    int iArray[5]; 
    int iCnt;

    //&iArray[iCnt] 와 iArray+iCnt 같다

    for(iCnt=0;iCnt<sizeof(iArray)/sizeof(iArray[0]);++iCnt) 
    { 
        printf("iArray[%d]=%08x\n",iCnt,&iArray[iCnt]); 
    }

    printf("\n");

 
    for(iCnt=0;iCnt<sizeof(iArray)/sizeof(iArray[0]);++iCnt) 
    { 
        printf("iArray[%d]=%08x\n",iCnt,iArray+iCnt); 
    }

    printf("\n"); 

    // iArray[iCnt] 와 *(iArray+iCnt) 같다 
    for(iCnt=0;iCnt<sizeof(iArray)/sizeof(iArray[0]);++iCnt) 
    { 
        printf("iArray[%d]=%08d\n",iCnt,iArray[iCnt]); 
    } 
    printf("\n");

    for(iCnt=0;iCnt<sizeof(iArray)/sizeof(iArray[0]);++iCnt) 
    { 
        printf("iArray[%d]=%08d\n",iCnt,*(iArray+iCnt)); 
    } 
    printf("iArray+1=%08x\n",iArray+1);

    printf("&iArray+1=%08x\n",&iArray+1);

    return 0;
}

재귀함수

함수를 호출 할 때 마다 스택을 사용

장점 : 코드가 간단해 진다.

단점 : 가독성이 떨어진다, 메모리 효율이 안좋다.(스택 사용이 많기 때문에)