์ƒˆ์†Œ์‹

IN DEPTH CAKE/Coding-WIKI

[C++] reference ๋ณ€์ˆ˜์— ๋Œ€ํ•œ ์ดํ•ด (pointer์™€ ๋น„๊ต)

  • -
๋ฐ˜์‘ํ˜•

๋ธ”๋กœ๊ทธ ๊ธ€ ์ƒ๋‹จ์— ๊ฐ„ํ—์ ์œผ๋กœ ๋œจ๋Š” ๊ด‘๊ณ ๋Š” ๋ธ”๋กœ๊ทธ ๊ฐœ์ธ ์ˆ˜์ต๊ณผ ๊ด€๋ จ ์—†๋Š” ํ‹ฐ์Šคํ† ๋ฆฌ ์ธก ์ˆ˜์ต ๊ด‘๊ณ ์ž…๋‹ˆ๋‹ค

 

 

C์—์„œ ์ฃผ์†Œ๋ฅผ ๋‹ค๋ฃจ๋Š” ๋ฐฉ์‹์œผ๋กœ pointer๊ฐ€ ์ œ๊ณต๋œ๋‹ค. pointer๋Š” ๊ทธ ์ด๋ฆ„๋งŒ์œผ๋กœ๋„ ๊ดœํžˆ ๋งˆ์Œ์„ ๋ถˆํŽธํ•˜๊ฒŒ ํ•œ๋‹ค. ๊ดœํžˆ ์ž˜๋ชป ์“ฐ๋ฉด dangling pointer ๋ฌธ์ œ๊ฐ€ ์ผ์–ด๋‚  ๊ฒƒ ๊ฐ™๊ณ , ๋ง‰ ๊ทธ๋ ‡๋‹ค. C++์—์„œ๋Š” ์ด๋Ÿฐ ๊ฐœ๋ฐœ์ž๋“ค์˜ ์‹ฌ์  ๋ถ€๋‹ด์„ ๋œ์–ด์ฃผ๊ธฐ ์œ„ํ•ด ์ฃผ์†Œ๋ฅผ ํ•ธ๋“ค๋งํ•  ์ˆ˜ ์žˆ๋Š” ๋˜ ๋‹ค๋ฅธ ๋ฐฉ์‹์œผ๋กœ reference๋ผ๋Š” ๋ฐฉ์‹์„ ์ œ๊ณตํ•œ๋‹ค. ๊ทธ๋Ÿฌ๋ฉด, pointer์™€ reference์˜ ์ฐจ์ด๋Š” ๋ฌด์—‡์ผ๊นŒ? ์“ฐ๋Š” ๋ฌธ๋ฒ•์ด ๋‹ค๋ฅด๋‹ค๋Š” ์‹์ƒํ•œ ๋‹ต๋ณ€ ๋ง๊ณ , reference๋งŒ์˜ ์žฅ์ ์„ ๋ถ€๊ฐํ•  ์ˆ˜ ์žˆ๋Š” ์˜ˆ์ œ๋ฅผ ํ•œ๋ฒˆ ๋ณด๊ณ  ๋„˜์–ด๊ฐ€๋ฉด ์ข‹๋‹ค. (๊ทธ๋ž˜์•ผ C++์—์„œ reference๋ผ๋Š” ๊ธฐ๋Šฅ์„ ๋„์ž…ํ•œ ์ด์œ ๋ฅผ ์ œ๋Œ€๋กœ ์ดํ•ดํ•  ์ˆ˜ ์žˆ๋‹ค)

 

 

 

 

๋ชฉ์ฐจ

1. Reference ๋ฌธ๋ฒ• ๋ฐ pointer์™€ ๋น„๊ตํ•˜๊ธฐ

2. Reference ์˜ ํŠน์ง•์„ ๋ณด์—ฌ์ฃผ๋Š” ์˜ˆ์ œ (pointer์™€ ์–ด๋–ป๊ฒŒ ๋‹ค๋ฅธ์ง€ ์ œ๋Œ€๋กœ ํ™•์ธํ•˜๊ณ  ๋„˜์–ด๊ฐ€์ž)

 

 

 

 

1. Reference ๋ฌธ๋ฒ• ๋ฐ Pointer์™€ ๋น„๊ตํ•˜๊ธฐ

 

 Reference ๋ฌธ๋ฒ•

  • ๋ ˆํผ๋Ÿฐ์Šค ๋ณ€์ˆ˜ ์„ ์–ธ ๋ฌธ๋ฒ•
์ž๋ฃŒํ˜•& ๋ณ€์ˆ˜๋ช…;

 

 Reference ๋ณ€์ˆ˜์™€ Pointer ๋ณ€์ˆ˜ ๋น„๊ตํ•˜๊ธฐ

  • Reference๋Š” ํฌ์ธํ„ฐ์™€ ์œ ์‚ฌํ•˜๊ฒŒ ๋ฉ”๋ชจ๋ฆฌ ์ ‘๊ทผ์„ ๊ฐ€๋Šฅํ•˜๊ฒŒ ํ•œ๋‹ค.
    • ์ผ๋ฐ˜์ ์œผ๋กœ, reference ๋ณ€์ˆ˜๊ฐ€ ์•„๋‹Œ ์ผ๋ฐ˜ ๋ณ€์ˆ˜ (int a)๋ฅผ ์ธ์ž๋กœ ํ•จ์ˆ˜๋ฅผ ํ˜ธ์ถœํ•˜๋Š” ๊ฒฝ์šฐ ์Šคํƒ ๋ฉ”๋ชจ๋ฆฌ์— '๊ฐ’'์ด ๋ณต์‚ฌ๋œ๋‹ค.
    • ์ด ๊ฒฝ์šฐ, ์ „๋‹ฌ๋œ ์ธ์ž๋Š” ๋Œ€์ž… ์—ฐ์‚ฐ์—์„œ R-Value๋กœ๋งŒ ์‚ฌ์šฉ์ด ๊ฐ€๋Šฅํ•˜๋‹ค (๊ฐ’๋งŒ ๊ฐ€์ง€๊ณ  ์˜ค์ง€, ์ฃผ์†Œ์—์˜ ์ ‘๊ทผ์ด ๋ถˆ๊ฐ€๋Šฅํ•˜๊ธฐ ๋•Œ๋ฌธ)
      • // void hello(int a)์ด๊ณ , a = 10์ด๋ผ๊ณ  ํ–ˆ์„ ๋•Œ,
      • 10 = 20; (X) // a = 20;์ด ๋ถˆ๊ฐ€๋Šฅํ•œ ์ด์œ 
      • b = 10; (O)  // b = a;๊ฐ€ ๊ฐ€๋Šฅํ•œ ์ด์œ 
    • ํ•˜์ง€๋งŒ reference ๋ณ€์ˆ˜์˜ ๊ฒฝ์šฐ R-Value ๋ฟ ์•„๋‹ˆ๋ผ, L-Value๋กœ๋„ ์‚ฌ์šฉ์ด ๊ฐ€๋Šฅํ•˜๋‹ค๋Š” ํŠน์ง•์„ ๊ฐ–๋Š”๋‹ค.
      • ์ด๋Ÿฌํ•œ ์ ์—์„œ pointer์™€ ์œ ์‚ฌํ•˜๋‹ค. 
        • // void hello(int* a)์ด๊ณ , *a = 10์ด๋ผ๊ณ  ํ–ˆ์„ ๋•Œ,
        • *a = 20; // a๊ฐ€ ๊ฐ€๋ฆฌํ‚ค๊ณ  ์žˆ๋Š” ๋ฉ”๋ชจ๋ฆฌ (10์ด ์ €์žฅ๋˜์–ด์žˆ๋Š”)์— 20์„ ๋„ฃ์–ด๋ผ
        • b = *a;  // b์— a๊ฐ€ ๊ฐ€๋ฅดํ‚ค๊ณ ์žˆ๋Š” ๋ฉ”๋ชจ๋ฆฌ ๊ฐ’ (10)์„ ๋„ฃ์–ด๋ผ
      • ํ•˜์ง€๋งŒ, pointer์™€๋„ ๋‹ค๋ฅธ๋ฐ, ๋Œ€ํ‘œ์ ์ธ ์ฐจ์ด์ ์ด "๋ฌธ๋ฒ•์ ์œผ๋กœ ํŠน๋ณ„ํžˆ ์–ด๋–ค ์ผ์„ ํ•  ํ•„์š”๊ฐ€ ์—†๋‹ค"๋Š” ๊ฒƒ
        • // void hello (int& a)์ด๊ณ , a = 10์ด๋ผ๊ณ  ํ–ˆ์„ ๋•Œ,
        • a = 20;
        • b = a;
  • reference ๋ณ€์ˆ˜๋Š” pointer ๋ณ€์ˆ˜์™€๋Š” ๋‹ค๋ฅด๋‹ค.
    • ์—„๋ฐ€ํ•˜๊ฒŒ ๋งํ•˜์ž๋ฉด reference ๋ณ€์ˆ˜๋Š” ์ฃผ์†Œ ๊ฐ’์„ ๋ฐ”๊ฟ€ ์ˆ˜ ์—†๋Š” (const) ํฌ์ธํ„ฐ์ด๋‹ค. ์˜ˆ๋ฅผ ๋“ค์–ด, int v = 10; ์ผ ๋•Œ,
      • int& p = v;
      • int* const q = &v; // q๊ฐ€ ๊ฐ€๋ฆฌํ‚ค๋Š” ๊ฐ’์€ ๋ณ€๊ฒฝ ๊ฐ€๋Šฅํ•˜์ง€๋งŒ, q์— ๋“ค์–ด๊ฐ€๋Š” ์ฃผ์†Œ ๊ฐ’์€ ๋” ์ด์ƒ ๋ณ€๊ฒฝ ๋ถˆ๊ฐ€
    • ๊ทธ๋ฆฌ๊ณ , ๋ฌธ๋ฒ•์ ์œผ๋กœ ํŠน๋ณ„ํžˆ ์–ด๋–ค ์ผ์„ ํ•  ํ•„์š”๊ฐ€ ์—†๋‹ค๋Š” ๊ฒƒ์ด reference ๋ณ€์ˆ˜์™€ pointer์˜ ์šฉ๋ฒ•์„ ๊ฐ€๋ฅด๋Š” ํฐ ํŠน์ง•์ด๋‹ค.
    • '๊ทธ๊ฒŒ ๋ญ ๊ทธ๋ฆฌ ํฐ ํŠน์ง•์ด๋ผ๊ณ ?'๋ผ๊ณ  ์ƒ๊ฐํ•  ์ˆ˜ ์žˆ๋‹ค. ์•„๋ž˜์˜ ์˜ˆ์ œ๋ฅผ ๋ณด์‹œ๋ฉด ์™œ ์ด๋Ÿฐ ๋ง์„ ํ–ˆ๋Š”์ง€ ์ดํ•ด๊ฐ€ ๋˜์‹ค ๊ฑฐ์˜ˆ์š”.

 

2. Reference ๋ณ€์ˆ˜์˜ ํŠน์ง•์„ ๋ณด์—ฌ์ฃผ๋Š” ์˜ˆ์ œ (pointer์™€ ์–ด๋–ป๊ฒŒ ๋‹ค๋ฅธ์ง€ ์ œ๋Œ€๋กœ ํ™•์ธํ•˜๊ณ  ๋„˜์–ด๊ฐ€์ž)

Reference ๋ณ€์ˆ˜์˜ ํšจ์šฉ์„ฑ์„ ์ž˜ ๋ณด์—ฌ์ฃผ๋Š” ์˜ˆ๋Š” ๋ฐ”๋กœ operator overloading์ด๋‹ค. (C++์˜ ํฐ ํŠน์ง• ์ค‘ ํ•˜๋‚˜์ด๋‹ค - C๋ž‘ ๋น„๊ตํ–ˆ์„ ๋•Œ)

Array indexing ์—ฐ์‚ฐ์ž๋ฅผ overloading ํ•œ๋‹ค๊ณ  ์ƒ๊ฐํ•ด ๋ณด์ž. Arr๋ผ๋Š” ํด๋ž˜์Šค๋ฅผ ์ •์˜ํ–ˆ๊ณ , ๊ทธ ํด๋ž˜์Šค ์•ˆ์—๋Š” pInt๋ผ๋Š” Int array pointer๊ฐ€ ์žˆ๋‹ค๊ณ  ๊ฐ€์ •ํ•˜์ž. ๊ทธ๋ ‡๋‹ค๋ฉด [] operator overloading ํ•จ์ˆ˜์˜ ๋ฐ˜ํ™˜ ํ˜•์€ ์–ด๋–ป๊ฒŒ ๋˜์–ด์•ผ ํ• ๊นŒ?

 

  • ํ•จ์ˆ˜ ๋ฐ˜ํ™˜ ํ˜•์œผ๋กœ int ํƒ€์ž…์„ ์‚ฌ์šฉํ•˜๋Š” ๊ฒฝ์šฐ 
    • (๊ฒฐ๋ก ) Lvalue๋กœ indexing ๊ฒฐ๊ณผ๋ฅผ ์‚ฌ์šฉํ•  ์ˆ˜ ์—†๋‹ค. (์ด๋ ‡๊ฒŒ ์“ฐ๋ฉด ์•ˆ ๋œ๋‹ค)
    • Arr k;๋ผ๊ณ  ํ•˜์ž, ์ด๋•Œ
    • int a = k[10]; ์€ ๊ฐ€๋Šฅํ• ์ง€ ๋ชฐ๋ผ๋„
    • k[10] = 10;์€ ๋ถˆ๊ฐ€๋Šฅํ•˜๋‹ค. (๋ฐ˜ํ™˜ ๊ฐ’์ด int ๊ฐ’์ด๋‹ˆ๊นŒ)
int Arr::operator[](int idx){
	return pInt[idx];
}



  • ํ•จ์ˆ˜ ๋ฐ˜ํ™˜ ํ˜•์œผ๋กœ int* ํƒ€์ž…์„ ์‚ฌ์šฉํ•˜๋Š” ๊ฒฝ์šฐ
    • (๊ฒฐ๋ก ) ์‚ฌ์šฉ์€ ๊ฐ€๋Šฅํ•˜์ง€๋งŒ, ์ผ๋ฐ˜์ ์ธ indexing ์šฉ๋ฒ•์œผ๋กœ ์‚ฌ์šฉ์ด ๋ถˆ๊ฐ€๋Šฅํ•˜๋‹ค.
    • Arr k;๋ผ๊ณ ํ•˜์ž, ์ด๋•Œ ๋ฌธ๋ฒ•์ ์œผ๋กœ ๋‹ค์Œ๊ณผ ๊ฐ™์ด ์จ์ค˜์•ผํ•œ๋‹ค.
    • int a = *k[10];
    • int* b= k[10];
    • *k[10] = 10;
int* Arr:operator[](int idx){
	return pInt + idx;
}

 

  • ๊ทธ๋ž˜์„œ ์ •๋‹ต์€ reference ๋ณ€์ˆ˜ ํ˜•์œผ๋กœ ๋ฐ˜ํ™˜ int &๋กœ ์‚ฌ์šฉํ•˜๋Š” ๊ฒƒ์ด๋‹ค. 
    • (๊ฒฐ๋ก ) ์ด ํ•จ์ˆ˜์—๋Š” reference ๋ณ€์ˆ˜ ํƒ€์ž… ๋ฐ–์— ์‚ฌ์šฉํ•  ์ˆ˜ ์—†๋‹ค.
    • Arr k; ๋ผ๊ณ  ํ•˜์ž, ์ด ๋•Œ ๋‹ค์Œ๊ณผ ๊ฐ™์ด ์‚ฌ์šฉํ•  ์ˆ˜ ์žˆ๋‹ค.
    • int a = k[10];
    • k[10] = 20;
int& Arr::operator[] (int idx){
	return pInt[idx];
}

 

 

๋Œ€์ž… ์—ฐ์‚ฐ์ž overloading๋„ reference ๋ณ€์ˆ˜์˜ ํšจ์šฉ์„ฑ์„ ๋ณด์—ฌ์ฃผ๋Š” ์ข‹์€ ์˜ˆ์‹œ์ด๋‹ค.

 

 

์—ฌ๋‹ด์ด์ž ๋งบ์Œ๋ง

์ตœ๊ทผ์—๋Š” '์™œ?'์— ๋Œ€ํ•ด์„œ ์งˆ๋ฌธ์„ ๊ฐ€์งˆ๋งŒํ•œ ๊ฒƒ๋“ค์— ๋Œ€ํ•ด ๊ธ€์„ ์จ๋ณด์ž๋ผ๋Š” ์ƒ๊ฐ์ด ๋“ค์—ˆ๋‹ค. ๋‹จ์ˆœํžˆ '์ด๋Ÿฌ๋‹ˆ๊นŒ ๋ฐ›์•„๋“ค์—ฌ'๋ผ๋Š” ๊ฒƒ๋“ค์—์„œ ํƒˆํ”ผํ•˜๋Š” ๊ฒƒ์ด ์ข‹์€ ์—”์ง€๋‹ˆ์–ด๊ฐ€ ๋˜๋Š” ๊ธธ์ด์ž, ์ข‹์€ ์—ฐ๊ตฌ์ž๊ฐ€ ๋˜๋Š” ๊ธธ์ด๋‹ค. ๊ทธ๋Ÿฐ ๊ด€์ ์—์„œ ๋ณธ ๊ธ€์„ ์จ๋ณด์•˜๋‹ค. "C++ ๋ฌธ๋ฒ•์— reference ๋ณ€์ˆ˜๋ผ๋Š” ๊ฒŒ ์žˆ์–ด, pointer๋ž‘ ๋น„์Šทํ•˜๊ฒŒ ์ฃผ์†Œ์— ์ ‘๊ทผ์ด ๊ฐ€๋Šฅํ•œ๋ฐ ์“ธ ๋•Œ ํ›จ์”ฌ ํŽธํ•ด!"๋ผ๊ณ  reference ๋ณ€์ˆ˜๋ฅผ ๋ฐฐ์› ๋‹ค๋ฉด, ์–˜์˜ ์šฉ๋ฒ•์— ๋Œ€ํ•ด์„œ 8ํ• ๋ฐ–์— ๋ชจ๋ฅด๋Š” ๊ฒƒ์ด๋‹ค. ๊ทธ๋Ÿฌ๋ฉด ๋ฌด์—‡์ด pointer์™€ ๋น„์Šทํ•˜๊ณ , ์–ด๋–ค ๊ฒŒ ๋‹ค๋ฅธ์ง€, ๋น„์Šทํ•˜๋‹ค๋ฉด ๊ตณ์ด ์™œ reference ๋ณ€์ˆ˜๋ผ๋Š” ๊ฒƒ์„ ๋„์ž…ํ–ˆ๋Š”์ง€ ์ •๋„๋Š” ์งˆ๋ฌธํ•ด ๋ณด๊ณ  ์ด์— ๋Œ€ํ•ด ๋‹ต์„ ์ƒ๊ฐํ•ด ๋ณด๋Š” ์—”์ง€๋‹ˆ์–ด๊ฐ€ ๋˜์ž ๐Ÿค

 

 

๋ โ—ผ๏ธŽ

๋ฐ˜์‘ํ˜•
Contents

ํฌ์ŠคํŒ… ์ฃผ์†Œ๋ฅผ ๋ณต์‚ฌํ–ˆ์Šต๋‹ˆ๋‹ค

์ด ๊ธ€์ด ๋„์›€์ด ๋˜์—ˆ๋‹ค๋ฉด ๊ณต๊ฐ ๋ถ€ํƒ๋“œ๋ฆฝ๋‹ˆ๋‹ค.

# ๋กœ๋”ฉ ํ™”๋ฉด ๋™์ž‘ ์ฝ”๋“œ(Code) ์„ค์ •ํ•˜๊ธฐ