C Programming Language/C

C์–ธ์–ด ํฌ์ธํ„ฐ(pointer)์˜ ๊ฐœ๋… ํ•™์Šตํ•˜๊ธฐ

567Rabbit 2024. 7. 2. 22:47

 

๋ณ€์ˆ˜์™€ ๋ฉ”๋ชจ๋ฆฌ

- ๋ณ€์ˆ˜๋Š” ๋ฉ”๋ชจ๋ฆฌ์— ์ €์žฅ๋œ๋‹ค

- ๋ฉ”๋ชจ๋ฆฌ๋Š” ๋ฐ”์ดํŠธ ๋‹จ์œ„๋กœ ์•ก์„ธ์Šค ๋œ๋‹ค

- ๋ณ€์ˆ˜์˜ ํฌ๊ธฐ์— ๋”ฐ๋ผ์„œ ์ฐจ์ง€ํ•˜๋Š” ๋ฉ”๋ชจ๋ฆฌ ๊ณต๊ฐ„์ด ๋‹ฌ๋ผ์ง„๋‹ค ex) int 4๋ฐ”์ดํŠธ, char 1๋ฐ”์ดํŠธ ,,,

 

 

 

 

๋ณ€์ˆ˜์˜ ์ฃผ์†Œ

- ๋ณ€์ˆ˜์˜ ์ฃผ์†Œ๋ฅผ ๊ณ„์‚ฐํ•˜๋Š” ์—ฐ์‚ฐ์ž : &

- ๋ณ€์ˆ˜ i์˜ ์ฃผ์†Œ : &i

 

 

 

 


ํฌ์ธํ„ฐ๋ž€?

์ฃผ์†Œ๋ฅผ ๊ฐ–๊ณ ์žˆ๋Š” ๋ณ€์ˆ˜   ( = ๋ณ€์ˆ˜์˜ ์ฃผ์†Œ๋ฅผ ๊ฐ€์ง€๊ณ  ์žˆ๋Š” ๋ณ€์ˆ˜)

์ฃผ์†Œ๊ฐ’์„ ๊ฐ€์ง„ ๋ณ€์ˆ˜

 

<ํฌ์ธํ„ฐ์˜ ์„ ์–ธ>

int * p ; 

 

- ์ •์ˆ˜๋ฅผ ๊ฐ€๋ฆฌํ‚ค๋Š” ํฌ์ธํ„ฐ p

 

 

 

 

 

 

ํฌ์ธํ„ฐ์™€ ๋ณ€์ˆ˜์˜ ์—ฐ๊ฒฐ

int i = 10;   // ์ •์ˆ˜ํ˜• ๋ณ€์ˆ˜ i ์„ ์–ธ
int *p;       // ํฌ์ธํ„ฐ ๋ณ€์ˆ˜ p ์„ ์–ธ
p = &i;       // ๋ณ€์ˆ˜ i์˜ ์ฃผ์†Œ๊ฐ€ ํฌ์ธํ„ฐ p๋กœ ๋Œ€์ž…

 

 

 

 

 

 

&์—ฐ์‚ฐ์ž์™€ *์—ฐ์‚ฐ์ž

 

&์—ฐ์‚ฐ์ž : ๋ณ€์ˆ˜์˜ ์ฃผ์†Œ๋ฅผ ๋ฐ˜ํ™˜ํ•œ๋‹ค

*์—ฐ์‚ฐ์ž : ํฌ์ธํ„ฐ๊ฐ€ ๊ฐ€๋ฆฌํ‚ค๋Š” ๊ณณ์˜ ๋‚ด์šฉ์„ ๋ฐ˜ํ™˜ํ•œ๋‹ค

 

 

 

 

 

 

 

๊ฐ„์ ‘ ์ฐธ์กฐ ์—ฐ์‚ฐ์ž *

 

: ํฌ์ธํ„ฐ๊ฐ€ ๊ฐ€๋ฆฌํ‚ค๋Š” ๊ฐ’์„ ๊ฐ€์ ธ์˜ค๋Š” ์—ฐ์‚ฐ์ž

: ์ง€์ •๋œ ์œ„์น˜์—์„œ ํฌ์ธํ„ฐ์˜ ํƒ€์ž…์— ๋”ฐ๋ผ ๊ฐ’์„ ์ฝ์–ด๋“ค์ธ๋‹ค.

int i = 10;
int *p;
p = &i;
printf("%d", *p);

// 10์ด ์ถœ๋ ฅ๋œ๋‹ค.

 

#include <stdio.h>
int main(void)
{
    int i = 10;
    int *p;
    
    p = &i;
    printf("i = %d\n", i);  // 10 ์ถœ๋ ฅ
    
    *p = 20;          // ํฌ์ธํ„ฐ๋ฅผ ํ†ตํ•˜์—ฌ ๋ณ€์ˆ˜์˜ ๊ฐ’์„ ๋ณ€๊ฒฝํ•จ
    printf("i = %d\n", i);  // 20 ์ถœ๋ ฅ
    return 0;
]

 

 

 

 

 

 

ํฌ์ธํ„ฐ ์‚ฌ์šฉ์‹œ ์ฃผ์˜์  (1) ์“ฐ๋ ˆ๊ธฐ๊ฐ’(data)

 

- ์ดˆ๊ธฐํ™”๊ฐ€ ์•ˆ๋œ ํฌ์ธํ„ฐ๋ฅผ ์‚ฌ์šฉํ•˜๋ฉด ์•ˆ๋œ๋‹ค.

- ํฌ์ธํ„ฐ๊ฐ€ ํ•˜๋“œ์›จ์–ด๋กœ ๊ฐ์ง€๋  ๊ฒฝ์šฐ, ํ•ดํ‚น๋  ์œ„ํ—˜์„ฑ์ด ์žˆ๋‹ค. 

int main(void)
{
    int *p;    // ํฌ์ธํ„ฐ p๋Š” ์ดˆ๊ธฐํ™”๊ฐ€ ์•ˆ๋˜์–ด์žˆ์Œ
    *p = 100;  // ์œ„ํ—˜ํ•œ ์ฝ”๋“œ
    return 0;
}

// ํฌ์ธํ„ฐ๊ฐ€ ์•„๋ฌด๊ฒƒ๋„ ๊ฐ€๋ฆฌํ‚ค๊ณ  ์žˆ์ง€ ์•Š๋Š” ๊ฒฝ์šฐ์—๋Š” null๋กœ ์ดˆ๊ธฐํ™” ํ•ด์•ผ ํ•จ
// null ํฌ์ธํ„ฐ๋ฅผ ๊ฐ€์ง€๊ณ  ๊ฐ„์ ‘ ์ฐธ์กฐํ•˜๋ฉด ํ•˜๋“œ์›จ์–ด๋กœ ๊ฐ์ง€ํ•  ์ˆ˜ ์žˆ๋‹ค

int *p = NULL;

 

 

 

 

 

ํฌ์ธํ„ฐ ์‚ฌ์šฉ์‹œ ์ฃผ์˜์  (2) ํฌ์ธํ„ฐ์˜ ํƒ€์ž…๊ณผ ๋ณ€์ˆ˜์˜ ํƒ€์ž…์€ ์ผ์น˜ํ•˜์—ฌ์•ผ ํ•œ๋‹ค

#include <stdio.h>

int main(void)
{
    int i;
    double *pd;
    
    pd = &i;  // ์˜ค๋ฅ˜! doubleํ˜• ํฌ์ธํ„ฐ์— intํ˜• ๋ณ€์ˆ˜์˜ ์ฃผ์†Œ๋ฅผ ๋Œ€์ž…ํ–ˆ๋‹ค
    *pd = 36.5;
    
    return 0;
}

 

- ๋ณ€์ˆ˜์˜ ํฌ๊ธฐ์— ๋”ฐ๋ผ์„œ ์ฐจ์ง€ํ•˜๋Š” ๋ฉ”๋ชจ๋ฆฌ ๊ณต๊ฐ„์ด ๋‹ฌ๋ผ์ง„๋‹ค ex) int 4๋ฐ”์ดํŠธ, char 1๋ฐ”์ดํŠธ ,,,

- ๊ทธ๋Ÿฌ๋ฏ€๋กœ ํ• ๋‹น๋œ ์ฃผ์†Œ์— ๋ณ€์ˆ˜์˜ ํƒ€์ž…์ด ์ผ์น˜ํ•˜์ง€ ์•Š์œผ๋ฉด ๋ฐ์ดํ„ฐ๊ฐ€ ๋ง๊ฐ€์ง€๋Š” ๋“ฑ์˜ ๋ฌธ์ œ(์˜ค๋ฅ˜)๊ฐ€ ์ƒ๊ธด๋‹ค.

 

 

 

 

 

 

ํฌ์ธํ„ฐ ์—ฐ์‚ฐ

 

- ๊ฐ€๋Šฅํ•œ ์—ฐ์‚ฐ : ์ฆ๊ฐ€, ๊ฐ์†Œ, ๋ง์…ˆ, ๋บ„์…ˆ ์—ฐ์‚ฐ

 

- ์ฆ๊ฐ€ ์—ฐ์‚ฐ์˜ ๊ฒฝ์šฐ ์ฆ๊ฐ€๋˜๋Š” ๊ฐ’์€ (ํฌ์ธํ„ฐ๊ฐ€ ๊ฐ€๋ฆฌํ‚ค๋Š” ๊ฐ์ฒด์˜ ํฌ๊ธฐ)์—์„œ ์ฆ๊ฐ€๋œ๋‹ค. 

- ๋ฐ”์ดํŠธ๋กœ ์ฆ๊ฐ€๋œ๋‹ค.

 

ํฌ์ธํ„ฐ๋ฅผ ๋ง์…ˆํ•œ๋‹ค์˜ ์˜๋ฏธ ์•Œ์•„๋ณด๊ธฐ

ex) *(p + 1)

์ฃผ์†Œ๋ฅผ ํ•œ์นธ์„ ๋” ๊ฐ”๋‹ค(1๋งŒํผ ๋”ํ•œ๋‹ค์˜ ์˜๋ฏธ) -> ํ•œ์นธ์— โ˜…๋ฐ”์ดํŠธ -> โ˜…๋ฐ”์ดํŠธ๋ฅผ ๋”ํ•ด์ค€๋‹ค

ex)  *(p + 2)

์ฃผ์†Œ๋ฅผ ๋‘์นธ์„ ๋” ๊ฐ”๋‹ค(2๋งŒํผ ๋”ํ•œ๋‹ค์˜ ์˜๋ฏธ) -> ํ•œ์นธ์— 2xโ˜…๋ฐ”์ดํŠธ -> 2xโ˜…๋ฐ”์ดํŠธ๋ฅผ ๋”ํ•ด์ค€๋‹ค

ex)  *(p + 3) 

์ฃผ์†Œ๋ฅผ ์„ธ์นธ์„ ๋” ๊ฐ”๋‹ค(3๋งŒํผ ๋”ํ•œ๋‹ค์˜ ์˜๋ฏธ) -> ํ•œ์นธ์— 3xโ˜…๋ฐ”์ดํŠธ -> 3xโ˜…๋ฐ”์ดํŠธ๋ฅผ ๋”ํ•ด์ค€๋‹ค

 

 

 

 

 

๊ฐ„์ ‘ ์ฐธ์กฐ ์—ฐ์‚ฐ์ž์™€ ์ฆ๊ฐ ์—ฐ์‚ฐ์ž

 

*p++;

: p๊ฐ€ ๊ฐ€๋ฆฌํ‚ค๋Š” ์œ„์น˜์—์„œ ๊ฐ’์„ ๊ฐ€์ ธ์˜จ ํ›„ p๋ฅผ ์ฆ๊ฐ€ํ•œ๋‹ค.

: ์›๋ณธ๊ฐ’์€ ๊ทธ๋Œ€๋กœ ์žˆ๊ณ , ํฌ์ธํ„ฐ๊ฐ€ ๊ฐ€์ ธ์˜จ ๊ฐ’๋งŒ ์ฆ๊ฐ€ํ•œ๋‹ค.

 

(*p)++;

: p๊ฐ€ ๊ฐ€๋ฆฌํ‚ค๋Š” ์œ„์น˜์˜ ๊ฐ’์„ ์ฆ๊ฐ€ํ•œ๋‹ค.

: ์›๋ณธ๊ฐ’์ด ๋‹ฌ๋ผ์ง„๋‹ค.

 

 

 

 

 

ํฌ์ธํ„ฐ์˜ ํ˜•๋ณ€ํ™˜

 

- c์–ธ์–ด์—์„œ๋Š” ๊ผญ ํ•„์š”ํ•œ ๊ฒฝ์šฐ์—, ๋ช…์‹œ์ ์œผ๋กœ ํฌ์ธํ„ฐ์˜ ํƒ€์ž…์„ ๋ณ€๊ฒฝํ•  ์ˆ˜ ์žˆ๋‹ค.

double *pd = &f;
int *pi;

pi = (int *)pd;  //pd๋ฅผ intํ˜•์œผ๋กœ ๋ณ€ํ™˜ํ•˜์—ฌ์„œ ์ €์žฅํ•˜๊ฒ ๋‹ค

 

 

 

 

 

 

 

์ธ์ˆ˜ ์ „๋‹ฌ ๋ฐฉ๋ฒ•

 

- ํ•จ์ˆ˜ ํ˜ธ์ถœ ์‹œ์— ์ธ์ˆ˜ ์ „๋‹ฌ ๋ฐฉ๋ฒ•

 

 

(1) ๊ฐ’์— ์˜ํ•œ ํ˜ธ์ถœ (call by value)

- ํ•จ์ˆ˜๋กœ ๋ณต์‚ฌ๋ณธ์ด ์ „๋‹ฌ๋œ๋‹ค

- ๊ธฐ๋ณธ์ ์ธ ๋ฐฉ๋ฒ•

- ๋ฐ์ดํ„ฐ๊ฐ€ ํฌ๋ฉด ์ž˜ ์•ˆ์“ด๋‹ค. ๋ณต์‚ฌ๊ฐ€ ๋˜๋ฉด ์šฉ๋Ÿ‰์„ ๋งŽ์ด ์ฐจ์ง€ํ•˜๋ฏ€๋กœ.

 

 

 

(2) ์ฐธ์กฐ์— ์˜ํ•œ ํ˜ธ์ถœ (call by reference)

- ํ•จ์ˆ˜๋กœ ์›๋ณธ์ด ์ „๋‹ฌ๋œ๋‹ค

- C์—์„œ๋Š” ํฌ์ธํ„ฐ๋ฅผ ์ด์šฉํ•˜์—ฌ ํ‰๋‚ด๋‚ผ ์ˆ˜ ์žˆ๋‹ค

 

 

*px, *py๋ฅผ 

(์ฃผ์†Œ๋กœ ๊ฐ€์„œ)

&a, &b

swap (๋ฐ”๋€Œ๋ฏ€๋กœ) ๋˜๋ฏ€๋กœ,

์›๋ณธ์ด ๋ฐ”๋€Œ๋Š” ๊ฒƒ์ด๋‹ค.

 

 

 

 

 

 

 

scanf() ํ•จ์ˆ˜ ๋‹ค์‹œ ์ดํ•ดํ•ด๋ณด๊ธฐ : ํฌ์ธํ„ฐ์˜ ๊ฐœ๋…

 

scanf("%d", &x

 

: ๋ณ€์ˆ˜์— ๊ฐ’์„ ์ €์žฅํ•˜๊ธฐ ์œ„ํ•˜์—ฌ ๋ณ€์ˆ˜์˜ ์ฃผ์†Œ๋ฅผ ๋ฐ›๋Š”๋‹ค

: ์ „๋‹ฌ๋œ ์ฃผ์†Œ๋ฅผ ์ด์šฉํ•ด ๋ณ€์ˆ˜์— ์‚ฌ์šฉ์ž๋กœ๋ถ€ํ„ฐ ๋ฐ›์€ ๊ฐ’์„ ์ €์žฅํ•œ๋‹ค.

 

 

 

 

 

 

 

 

 

ํฌ์ธํ„ฐ์™€ ๋ฐฐ์—ด

 

- ๋ฐฐ์—ด๊ณผ ํฌ์ธํ„ฐ๋Š” ์•„์ฃผ ๋ฐ€์ ‘ํ•œ ๊ด€๊ณ„๋ฅผ ๊ฐ€์ง€๊ณ  ์žˆ๋‹ค.

- ๋ฐฐ์—ด ์ด๋ฆ„์ด ๋ฐ”๋กœ ํฌ์ธํ„ฐ์ด๋‹ค.

- ํฌ์ธํ„ฐ๋Š” ๋ฐฐ์—ด์ฒ˜๋Ÿผ ์‚ฌ์šฉ์ด ๊ฐ€๋Šฅํ•˜๋‹ค.

- ์ธ๋ฑ์Šค ํ‘œ๊ธฐ๋ฒ•์„ ํฌ์ธํ„ฐ์— ์‚ฌ์šฉํ•  ์ˆ˜ ์žˆ๋‹ค.

 

 

 

 

%u๋Š” ์ฃผ์†Œ๋ฅผ ์˜๋ฏธํ•œ๋‹ค.

 

 

 

 

 

 

int b[]

int *b

- ๊ฐ™์€ํ‘œํ˜„์ด๋‹ค.

 

void sub(int b[], int size)
{
    *b = 4;
    *(b+1) = 5;
    *(b+2) = 6;
    
    // ํฌ์ธํ„ฐ b๋ฅผ ํ†ตํ•˜์—ฌ ์›๋ณธ ๋ฐฐ์—ด์„ ๋ณ€๊ฒฝํ•  ์ˆ˜ ์žˆ๋‹ค.
}

 

ํฌ์ธํ„ฐ๋ฅผ ํ†ตํ•œ ๋ฐฐ์—ด์˜ ๋ณ€๊ฒฝ์€ ์ฐธ์กฐ์— ์˜ํ•œ ํ˜ธ์ถœ (call by reference)๋กœ ์›๋ณธ์ด ๋ฐ”๋€Œ๊ฒŒ ๋œ๋‹ค.

 

 

 

 

 

 

 

ํฌ์ธํ„ฐ๋ฅผ ์‚ฌ์šฉํ•œ ๋ฐฉ๋ฒ•์˜ ์žฅ์ 

 

- ํฌ์ธํ„ฐ๊ฐ€ ์ธ๋ฑ์Šค ํ‘œ๊ธฐ๋ฒ•๋ณด๋‹ค ๋น ๋ฅด๋‹ค.

- ์ธ๋ฑ์Šค๋ฅผ ์ฃผ์†Œ๋กœ ๋ณ€ํ™˜ํ•  ํ•„์š”๊ฐ€ ์—†๋‹ค.

=> ์†๋„๊ฐ€ ์—„์ฒญ ๋น ๋ฅธ๊ฒƒ์€ ์•„๋‹ˆ๋‹ˆ, ํ•„์š”์— ๋”ฐ๋ผ ์‚ฌ์šฉํ•˜๋ฉด ๋œ๋‹ค.

 

 

 

 

 

 

 

ํฌ์ธํ„ฐ๋ฅผ ๋ฐ˜ํ™˜ํ•  ๋•Œ ์ฃผ์˜์ 

 

- ํ•จ์ˆ˜๊ฐ€ ์ข…๋ฃŒ๋˜๋”๋ผ๋„ ๋‚จ์•„ ์žˆ๋Š” ๋ณ€์ˆ˜์˜ ์ฃผ์†Œ๋ฅผ ๋ฐ˜ํ™˜ํ•˜์—ฌ์•ผ ํ•œ๋‹ค.

- ์“ฐ๋ ˆ๊ธฐ๊ฐ’์ด ๋‚จ์•„์žˆ๋Š” ๊ฒƒ์„ ๋ฐฉ์ง€ํ•˜๊ธฐ ์œ„ํ•จ์ด๋‹ค.

- ์ง€์—ญ ๋ณ€์ˆ˜์˜ ์ฃผ์†Œ๋ฅผ ๋ฐ˜ํ™˜ํ•˜๋ฉด ํ•จ์ˆ˜๊ฐ€ ์ข…๋ฃŒ๋˜๋ฉด ์‚ฌ๋ผ์ง€๊ธฐ ๋•Œ๋ฌธ์— ์˜ค๋ฅ˜๊ฐ€ ๋ฐœ์ƒํ•œ๋‹ค.

 

 

> ์ž˜๋ชป๋œ ์˜ˆ์ œ์ด๋‹ค.

#include <stdio.h>

int* getLocalVariableAddress() {
    int localVar = 10; // ์ง€์—ญ ๋ณ€์ˆ˜
    return &localVar; // ์ง€์—ญ ๋ณ€์ˆ˜์˜ ์ฃผ์†Œ๋ฅผ ๋ฐ˜ํ™˜ (๋ฌธ์ œ ๋ฐœ์ƒ)
}

int main() {
    int* p = getLocalVariableAddress();
    // ํ•จ์ˆ˜ ์ข…๋ฃŒ ํ›„ ์ง€์—ญ ๋ณ€์ˆ˜๋Š” ์‚ฌ๋ผ์ง€๋ฏ€๋กœ p๋Š” ์œ ํšจํ•˜์ง€ ์•Š์€ ์ฃผ์†Œ๋ฅผ ๊ฐ€๋ฆฌํ‚ด
    printf("Value at p: %d\n", *p); // ์ž˜๋ชป๋œ ์ ‘๊ทผ (์˜ˆ์ƒ์น˜ ๋ชปํ•œ ๊ฒฐ๊ณผ ๋ฐœ์ƒ)
    return 0;
}

 

 

> ์˜ฌ๋ฐ”๋ฅธ ์˜ˆ์ œ์ด๋‹ค.

#include <stdio.h>
#include <stdlib.h>

int* getDynamicMemoryAddress() {
    int* ptr = (int*)malloc(sizeof(int)); // ๋™์  ๋ฉ”๋ชจ๋ฆฌ ํ• ๋‹น
    if (ptr == NULL) {
        printf("Memory allocation failed\n");
        exit(1);
    }
    *ptr = 10; // ๋™์  ๋ฉ”๋ชจ๋ฆฌ์— ๊ฐ’ ํ• ๋‹น
    return ptr; // ๋™์  ๋ฉ”๋ชจ๋ฆฌ์˜ ์ฃผ์†Œ๋ฅผ ๋ฐ˜ํ™˜ (๋ฌธ์ œ ์—†์Œ)
}

int main() {
    int* p = getDynamicMemoryAddress();
    printf("Value at p: %d\n", *p); // ์˜ฌ๋ฐ”๋ฅธ ์ ‘๊ทผ
    free(p); // ๋™์  ๋ฉ”๋ชจ๋ฆฌ ํ•ด์ œ
    return 0;
}

 

 

 

 

 

 

์˜ˆ์ œ) 5x5 ์ด๋ฏธ์ง€ ๋˜๋Š” ์˜์ƒ์˜ ํ–‰๋ ฌ์˜ ๋ฐ๊ธฐ๋ฅผ 10๋งŒํผ ์ฆ๊ฐ€์‹œํ‚ค๋Š” ์˜ˆ์ œ

 

#include <stdio.h>
#define SIZE 5

void print_image(int image[][SIZE])
{
    int r, c;
    for (r = 0; r < size; r++){
        for (c = 0; c < size; c++){
            printf("%03d", image[r][c]);
        }
        printf("\n");
    }
    printf("\n");
}

void Brightn_image(int image[][SIZE])
{
    int r, c;
    int *p;
    p = &image[0][0];
    for (r = 0; r < size; r++){
        for (c = 0; c < size; c++){
            *p += 10;
            p++;
        }
    }
}

int main(void)
{
    int image[5][5] = {
        {10, 20, 30, 40, 50},
        {10, 20, 30, 40, 50},
        {10, 20, 30, 40, 50},
        {10, 20, 30, 40, 50},
        {10, 20, 30, 40, 50}};

    print_image(image);
    brighten_image(image);
    print_image(image);

    return 0;
}