포인터와 함수, 포인터 배열

포인터와 함수

• Call by value ( 값 전달 )
  • 복사본 개념 생각 - 기존 값은 변하지 않지만 복사본의 값은 변함

// x 와 y의 값을 바꾸는 함수
void swap(int x, int y) {

    int temp;

    temp = x; 

    x = y;

    y = temp;
}


int main(void) {

    // 함수는 복사본을 만드는 것 이기 때문에  swap 을 해준다 해도 기존에 있던 값은 바뀌지 않는다.
    int x = 3, y = 5;

    printf("기존 값 =>  x 는 %d 이고 y 는 %d 이다 \n", x, y);

    swap(x, y);

    printf("바뀐 값 =>  x 는 %d 이고 y 는 %d 이다 \n", x, y);

    // 포인터 함수로 바꿔서 값 출력

    return 0;
}

// 기존 값도 3, 5 출력 바뀐 값도 3, 5 가 출력 된다. 

• Call by address ( 주소 전달 )
  • 주소 자체를 바꾸는 것이기 때문에 기본 값이 변함

void swap(int* x, int* y) {

    int temp;

    // temp는 포인터x 를 역참조 한다.
    temp = *x; 

    *x = *y;

    *y = temp;
}

int main(void){

    int x = 3, y = 5;

    printf("기존 값 =>  x 는 %d 이고 y 는 %d 이다 \n", x, y);

    // x 와 y 의 주소값을 넣어준다.
    swap(&x, &y);

    printf("바뀐 값 =>  x 는 %d 이고 y 는 %d 이다 \n", x, y);

    // 포인터 함수로 바꿔서 값 출력

    return 0;
}

// 기존 값은 3,5. 주소 안에 있는 값을 바꾸기 때문에
// 바뀐 값은 5,3 이 된다. 

포인터 배열

• 포인터의 배열도 포인터 참조랑 똑같다
• 배열은 하나의 인덱스 마다 하나의 주소값을 가진다
• 배열을 선언 후 포인터 배열을 만들어서 인덱스를 지정한다.
• 포문으로 포인터 배열에 배열의 주소값을 하나씩 넣어준다.
• 출력할 때는 포문으로 하나씩 역참조 하면서 출력한다.
• 배열의 길이를 구할 때는 sizeof(배열) / sizeof(int) 이지만 포인터 배열의 길이를 구할 때는 sizeof(포인터배열) / sizeof(int*) 로 구해준다.
  • int* (인트 포인터) 안해주면 길이가 달라지니 주의 할 것.

int array[10] = { 1,2,3,4,5 };

int* ptrArray[10];

for (int i = 0; i < sizeof(array) / sizeof(int); i++) {

    // 포인터 배열에 각 주소 값 저장;
    ptrArray[i] = &array[i];
}

printf("길이가 몇 인데? :  %d \n", sizeof(ptrArray) / sizeof(int*));

for (int i = 0; i < sizeof(ptrArray) / sizeof(int*); i++) {

    // 배열을 역참조 해서 하나씩 값을 출력한다.
    printf("ptrArray[%d]의 값은 : %d 다 \n", i, *ptrArray[i]);

}

• 배열의 이름은 포인터
  • 배열이라는 자료 구조는 포인터를 1씩 증가하면서 만들어 진 자료 구조
  • int a[5]; 에서 a = &a[0] ( 배열의 이름 a 는 a의 첫번째 인덱스의 주소와 같다. )

int a[5] = {1, 2, 3, 4, 5}; 

int * p ;  // 인트형 주소를 포인터

p = a; //  포인터를 배열의 시작 주소를 가리키는게 가능하다.

* 배열의 이름은 포인터 *

배열의 이름은 배열의 시작 주소를 가리키는 포인터 

배열의 이름 a는  &a[0] 와 같다 

int a = 5;
int *p = &a;
*p = 10;
p[0] 10; 

*(p+1] =>  a[1]
*(p+2] =>  a[2]
*(p+3] =>  a[3]

• p가 100번지라고 가정하면
  • int 형 p + 1 = 104 번지가 된다.
  • double 형 이면 p + 1 = 108 번지가 된다.
  • char 형 이면 p + 1 = 101 번지가 된다.
  • 따라서 포인터는 연산할 때 가리키는 데이터의 크기 만큼 증감하는 크기가 달라진다.

실습

    int iArray[5] = { 1,2,3,4,5 };

    printf("%d, %d \n", iArray[0], iArray[1]);

    printf("%p, %p \n", &iArray[0], &iArray[1]);

    printf("%p \n", iArray);


    // iArray[0] 하고 iArray 의 주소값이 똑같은걸 확인할 수 있다. 

    // 실습 6 1차원 배열명의 포인터 타입 

    int* iPtr;

    // 포인터가 배열의 이름이면   배열의 시작점이 된다 즉 iPtr[0] = iArray[0] 이랑 같음 
    iPtr = iArray;

    // 기존 배열 출력
    printf("%d, %d, %d \n", iArray[0], iArray[1], iArray[4]);

    printf("%d, %d, %d \n", iPtr[0], iPtr[1], iPtr[4]);

    // 실습 7 포인터 연산 ( 주소 값 증감 ) 

    char c = 'b';
    int i = 3;
    double d = 3.14;

    char* cp = &c;
    int* ip = &i;
    double* dp = &d;

    printf("증감 전 %p, %p, %p \n", cp, ip, dp);

    cp++, ip++, dp++; 

    printf("증감 후 %p, %p, %p \n", cp, ip, dp);  // 주소값이 타입형 만큼 증가 한걸 확인 할 수 있다.

    cp += 3;  ip += 3, dp += 3;

    printf("한번 더 증감 후 %p, %p, %p \n", cp, ip, dp);  // 주소값이  타입형 * 수  즉 + 3 일 때 char = 3 int = 12  double = 24 만큼 증가