U E D R , A S I H C RSS

More EffectiveC++/Techniques2of3

1. Item 29: Reference counting

  • Item 29: ์ฐธ์กฐ ์„ธ๊ธฐ

1.1. ์†Œ๊ฐœ

Reference counting(์ดํ•˜ ์ฐธ์กฐ ์„ธ๊ธฐ, ๋‹จ์–ด๊ฐ€ ๊ธธ์–ด ์˜์–ด ํ˜ผ์šฉ ํ•˜์ง€ ์•Š์Œ)๋Š” ๊ฐ™์€ ๊ฐ’์œผ๋กœ ํ‘œํ˜„๋˜๋Š” ์ˆ˜๋งŽ์€ ๊ฐ์ฒด๋“ค์„ ํ•˜๋‚˜์˜ ๊ฐ’์œผ๋กœ ๊ณต์œ ํ•ด์„œ ํ‘œํ˜„ํ•˜๋Š” ๊ธฐ์ˆ ์ด๋‹ค. ์ฐธ์กฐ ์„ธ๊ธฐ๋Š” ๋‘๊ฐ€์ง€์˜ ์ผ๋ฐ˜์ ์ธ ๋™๊ธฐ๋กœ ์ œ์•ˆ๋˜์—ˆ๋Š”๋ฐ, ์ฒซ๋ฒˆ์งธ๋กœ heap ๊ฐ์ฒด๋“ค์„ ์ˆ˜์šฉํ•˜๊ธฐ ์œ„ํ•œ ๊ธฐ๋ก์˜ ๋‹จ์ˆœํ™”๋ฅผ ์œ„ํ•ด์„œ ์ด๋‹ค. ํ•˜๋‚˜์˜ ๊ฐ์ฒด๊ฐ€ ๋งŒ๋“ค์–ด ์ง€๋Š”๋ฐ, new๊ฐ€ ํ˜ธ์ถœ๋˜๊ณ  ์ด๊ฒƒ์€ delete๊ฐ€ ๋ถˆ๋ฆฌ๊ธฐ ์ „๊นŒ์ง€ ๋ฉ”๋ชจ๋ฆฌ๋ฅผ ์ฐจ์ง€ํ•œ๋‹ค. ์ฐธ์กฐ ์„ธ๊ธฐ๋Š” ๊ฐ™์€ ์ž๋ฃŒ๋“ค์˜ ์ค‘๋ณต๋œ ๊ฐ์ฒด๋“ค์„ ํ•˜๋‚˜๋กœ ๊ณต์œ ํ•˜์—ฌ, new์™€ delete๋ฅผ ํ˜ธ์ถœํ•˜๋Š” ์ŠคํŠธ๋ ˆ์Šค๋ฅผ ์ค„์ด๊ณ , ๋ฉ”๋ชจ๋ฆฌ์— ๊ฐ์ฒด๊ฐ€ ๋“ฑ๋ก๋˜์–ด ์œ ์ง€๋˜๋Š” ๋น„์šฉ๋„ ์ค„์ผ์ˆ˜ ์žˆ๋‹ค. ๋‘๋ฒˆ์งธ์˜ ๋™๊ธฐ๋Š” ๊ทธ๋ƒฅ ์ผ๋ฐ˜์ ์ธ ์ƒ๊ฐ์—์„œ ๋‚˜์™”๋‹ค. ์ค‘๋ณต๋œ ์ž๋ฃŒ๋ฅผ ์—ฌ๋Ÿฌ ๊ฐ์ฒด๊ฐ€ ๊ณต์œ ํ•˜์—ฌ, ๋น„์šฉ ์ ˆ์•ฝ ๋ฟ์•„๋‹ˆ๋ผ, ์ƒ์„ฑ, ํŒŒ๊ดด์˜ ๊ณผ์ •์˜ ์ƒ๋žต์œผ๋กœ ํ”„๋กœ๊ทธ๋žจ ์ˆ˜ํ–‰ ์†๋„๊นŒ์ง€ ๋†’์ด๊ณ ์ž ํ•˜๋Š” ๋ชฉ์ ์ด๋‹ค.

์ด๋Ÿฐ ๊ฐ„๋‹จํ•œ ์ƒ๊ฐ๋“ค์˜ ์ ์šฉ์„ ์œ„ํ•ด์„œ๋Š” ๋งŽ์ด ์“ฐ์ด๋Š” ์ž๋ฃŒํ˜•ํƒœ๋ฅผ ์ฐพ์•„ ์˜ˆ์ œ์‚ผ์•„ ๋ณด์—ฌ์ฃผ๋Š” ๊ฒƒ์ด ์ดํ•ด์— ๋„์›€์ด ๋„๋ฆฌ๊ฒƒ์ด๋‹ค. ์ด๋Ÿฐ ๋ฉด์—์„œ ๋‹ค์Œ์˜ ์˜ˆ๋Š” ์ ํ•ฉํ•  ๊ฒƒ์ด๋‹ค.

~cpp 
class String {                      // ํ‘œ์ค€ ๋ฌธ์ž์—ด ํ˜•์€ ์ด๋ฒˆ ์•„์ดํ…œ์˜ ์ฐธ์กฐ์„ธ๊ธฐ๋ฅผ ๊ฐ–์ถ”๊ณ 
public:                             // ์žˆ์„ํ…Œ์ง€๋งŒ, ๊ทธ๊ฒƒ์„ ๋ฐฐ์ œํ–ˆ๋‹ค๊ณ  ๊ฐ€์ •ํ•˜์ž
    String(const char *value = "");
    String& operator=(const String& rhs);
    ...
private:
    char *data;
};
String a, b, c, d, e;

a = b = c = d = e = "Hello";
a~e๊นŒ์ง€ ๋ชจ๋‘ "Hello"๋ผ๋Š” ๊ฐ™์€ ๊ฐ’์„ ๊ฐ€์ง€๊ณ  ์žˆ๋Š” ๋‹ค๋ฅธ ๊ฐ์ฒด์ด๋‹ค. ์ด ํด๋ž˜์Šค๋Š” ์ฐธ์กฐ ์„ธ๊ธฐ๊ฐ€ ์ ์šฉ๋˜์ง€ ์•Š์•˜๊ธฐ ๋•Œ๋ฌธ์— ๋ชจ๋‘ ๊ฐ๊ฐ์˜ ๊ฐ’์„ ๊ฐ€์ง€๊ณ  ์žˆ๋‹ค. ๋ฌธ์ž์—ด์˜ ํ• ๋‹น(assignment) ์—ฐ์‚ฐ์ž๋Š” ์•„๋งˆ ๋‹ค์Œ๊ณผ ๊ฐ™์ด ๊ตฌํ˜„๋˜์–ด ์žˆ์„ ๊ฒƒ์ด๋‹ค.

~cpp 
String& String::operator=(const String& rhs)
{
    if (this == &rhs) return *this;         // Item E17 ์ฐธ๊ณ 

    delete [] data;
    data =   new char[strlen(rhs.data) + 1];
    strcpy(data, rhs.data);

    return *this;                           // Item E15 ์ฐธ๊ณ 
}
์ด ์ฝ”๋“œ์˜ ์˜๋ฏธ๋ฅผ ๊ทธ๋ฆผ์œผ๋กœ ํ‘œํ˜„ํ•˜๋ฉด ๋‹ค์Œ๊ณผ ๊ฐ™๋‹ค.



์ด๋Ÿฌํ•œ ๊ทธ๋ฆผ์„ ์ฐธ์กฐ ์„ธ๊ธฐ์—์„œ ๋งํ•˜๋Š” ์ค‘๋ณต ๊ฐ์ฒด์— ๋Œ€ํ•œ ์ž๋ฃŒ์˜ ๊ณต์œ ๋ฅผ ์ ์šฉ์‹œํ‚จ ๊ทธ๋ฆผ์€ ๋‹ค์Œ๊ณผ ๊ฐ™์„ ๊ฒƒ์ด๋‹ค.


"Hello"๋ผ๋Š” ๊ฐ’์€ ํ•˜๋‚˜๋งŒ ์ €์žฅ๋˜์–ด ์žˆ๋Š” ๊ฒƒ์ด๊ณ , ์ด๋ฅผ ๋ฌธ์ž์—ด๋“ค์ด ๊ณต์œ ํ•ด์„œ ํ‘œํ˜„์‹œ ๊ฐ€์ง€๊ณ  ์žˆ๋Š” ๊ฒƒ์ด๋‹ค. ํ•˜์ง€๋งŒ ์‹ค์งˆ์ ์œผ๋กœ "Hello"์˜ ํ• ๋‹น ์‹œ์ ์€ ์†์‰ฝ๊ฒŒ ์•Œ์ˆ˜ ์žˆ์ง€๋งŒ, ํŒŒ๊ดด ์‹œ์ ์„ ์•Œ์ˆ˜ ์žˆ๋Š”๊ฒƒ์€ ๋งŒ๋งŒ์น˜ ์•Š๋‹ค. ๊ทธ๋ž˜์„œ ํŒŒ๊ดด ์‹œ์ ์„ ์•Œ๊ธฐ ์œ„ํ•ด์„œ "Hello" ๊ฐ’์— ๊ทธ๊ฒƒ์„ ์ฐธ์กฐํ•˜๋Š” ์ •๋„๋ฅผ ๊ธฐ๋กํ•˜๊ณ , ๊ทธ ์ฐธ์กฐ๊ฐ€ 0๊ฐ€ ๋˜๋Š” ์‹œ์ ์„ ๊ฐ’์˜ ํŒŒ๊ดด ์‹œ์ ์œผ๋กœ ์‚ผ์•„์•ผ ํ•˜๋Š”๋ฐ, ์ด๋Ÿฐ ์ƒ๊ฐ์„ ์•„๊นŒ ๊ทธ๋ฆผ์— ๋‹ค์‹œ ๋„ฃ์œผ๋ฉด ๋‹ค์Œ๊ณผ ๊ฐ™๋‹ค.


๊ทธ๋ฆฌ๊ณ  ์—ฌ๊ธฐ์˜ 5์— ํ•ด๋‹น ํ•˜๋Š” ์ˆซ์ž๋ฅผ Reference count ๋ผ๊ณ  ๋ถ€๋ฅธ๋‹ค. ํ˜น์ž๋Š” use count๋ผ๊ณ  ๋ถ€๋ฅด๊ธฐ๋„ ํ•˜๋Š”๋ฐ, ํ•™์ˆ  ์šฉ์–ด์˜ ๋‹นํŒŒ์— ๋”ฐ๋ฅธ๊ฑฐ๋‹ˆ ๋ณ„ ์ƒ๊ด€ ์•ˆํ•œ๋‹ค. ํ•˜์ง€๋งŒ ๋‚˜(scott mayer) ๊ทธ๋ ‡๊ฒŒ ์•ˆ๋ถ€๋ฅธ๋‹ค.

1.2. Implementing Reference Counting : ์ฐธ์กฐ ์„ธ๊ธฐ ์ ์šฉ

์ฐธ์กฐ ์„ธ๊ธฐ๋ฅผ ํ•˜๋Š” String ํด๋ž˜์Šค๋ฅผ ๋งŒ๋“œ๋Š”๊ฑด ์–ด๋ ต์ง€๋Š” ์•Š์ง€๋งŒ, ์„ธ์„ธํ•œ ๋ถ€๋ถ„์— ์ฃผ๋ชฉํ•ด์„œ ์–ด๋–ป๊ฒŒ ๊ทธ๋Ÿฌํ•œ ํด๋ž˜์Šค๊ฐ€ ๊ตฌํ˜„๋˜๋Š”์ง€ ์ฃผ๋ชฉํ•ด ๋ณด์ž. ์ผ๋‹จ, ์ž๋ฃŒ๋ฅผ ์ €์žฅํ•˜๋Š” ์ €์žฅ์†Œ๊ฐ€ ์žˆ๊ณ , ์ฐธ์กฐ๋ฅผ ์…€์ˆ˜ ์žˆ๋Š” ์นด์šดํ„ฐ๊ฐ€ ์žˆ์–ด์•ผ ํ•˜๋Š”๋ฐ, ์ด ๋‘˜์„ ํ•˜๋‚˜๋กœ ๋ฌถ์–ด์„œ StringValue ๊ตฌ์กฐ์ฒด๋กœ ์žก๋Š”๋‹ค. ๊ตฌ์กฐ์ฒด๋Š” String์˜ ์‚ฌ์—ญ(private)์— ์œ„์น˜ํ•œ๋‹ค.

์ง€๊ธˆ๊นŒ์ง€ ๋งํ•œ ์‚ฌํ•ญ์˜ ๊ธฐ๋ณธ์€ ๋‹ค์Œ๊ณผ ๊ฐ™๋‹ค.

~cpp 
class String {
public:
    ...                         // String member๋“ค ์œ„์น˜
private:
    struct StringValue { ... }; // ์ฐธ์กฐ๋ฅผ ์„ธ๋Š” ์ธ์ž์™€, String์˜ ๊ฐ’์„ ์ €์žฅ.
    StringValue *value;         // ์œ„์˜ ๊ตฌ์กฐ์ฒด์˜ ๊ฐ’
};
๋ฌผ๋ก  ์ด์˜ ์ด๋ฆ„์€ String๊ณผ ๋‹ค๋ฅธ ์ด๋ฆ„์„ ๋งค๊ฒจ์•ผ ํ•˜๊ฒ ์ง€๋งŒ,(์•„๋งˆ RCString์ •๋„?) ํ•˜์ง€๋งŒ String์ž์ฒด๋ฅผ ๊ตฌํ˜„ํ•œ๋‹ค๋Š” ์˜๋ฏธ๋กœ ๊ทธ๋ƒฅ ์ด๋ฆ„์€ ์œ ์ง€ํ•˜๊ณ , ์•ž์œผ๋กœ ๋งํ•  ์ฐธ์กฐ์„ธ๊ธฐ๋ฅผ ์ ์šฉ์‹œํ‚จ String ๊ฐ์ฒด๋ฅผ ๋งŒ๋“ค์–ด ๋‚˜๊ฐ€๊ฒ ๋‹ค.

์œ„์˜ ๊ธฐ๋ณธ ๋””์ž์ธ์„ ๊ตฌํ˜„ํ•ด ๋ณธ๋‹ค.

~cpp 
class String {
private:
    struct StringValue {
        int refCount;       // ์ฐธ์กฐ๋ฅผ ์„ธ๊ธฐ์œ„ํ•จ ์นด์šดํ„ฐ
        char *data;         // ๊ฐ’ ํฌ์ธํ„ฐ

        StringValue(const char *initValue);
        ~StringValue();
    };
    ...
};
// StringValue์˜ ๋ณต์‚ฌ ์ƒ์„ฑ์ž, ์ดˆ๊ธฐํ™” ๋ชฉ๋ก์œผ๋กœ refCount ์ธ์ž 1๋กœ ์ดˆ๊ธฐํ™”
String::StringValue::StringValue(const char *initValue): refCount(1)
{
    data = new char[strlen(initValue) + 1];     // ์ƒˆ๋กœ์šด ๊ฐ’ ํ• ๋‹น(์•„์ง ์ฐธ์กฐ์„ธ๊ธฐ ์ ์šฉ x
    strcpy(data, initValue);                    // ์ŠคํŠธ๋ง ๋ณต์‚ฌ
}
// StringValue์˜ ํŒŒ๊ดด์ž
String::StringValue::~StringValue()
{
    delete [] data;     // ์ŠคํŠธ๋ง ์‚ญ์ œ
}
์ด๊ฒƒ์œผ๋กœ StringValue์˜ ๊ตฌํ˜„์€ ์ผ๋‹จ ๋์ด๋‹ค. ์ด๋ฅผ ์‚ฌ์šฉํ•˜๋Š” String ๊ฐ์ฒด์˜ ๊ตฌํ˜„์— ๋“ค์–ด๊ฐ€์•ผ ํ•œ๋‹ค.

๋จผ์ € ์ƒ์„ฑ์ž๋ฅผ ๊ตฌํ˜„ํ•œ๋‹ค.

~cpp 
class String {
public:
    String(const char *initValue = "");
    String(const String& rhs);
  ...
};

~cpp 
// String์˜ ๋ณต์‚ฌ ์ƒ์„ฑ์ž, ์ดˆ๊ธฐํ™” ๋ชฉ๋ก์œผ๋กœ StringValue์— ๊ฐ’์„ ํ• ๋‹นํ•œ๋‹ค.
String::String(const char *initValue): value(new StringValue(initValue))
{}
ํด๋ผ์ด์–ธํŠธ์˜ ์ฝ”๋“œ๋Š” ๋ณดํ†ต ๋‹ค์Œ๊ณผ ๊ฐ™๋‹ค.

~cpp 
String s("More Effective C++");
์ด๋ฅผ ์ฒ˜์Œ ์ฐธ์กฐ์„ธ๊ธฐ ์„ค๋ช…์— ๋‚˜์˜จ ๊ทธ๋ฆผ์‹์œผ๋กœ ์„ค๋ช…ํ•˜์ž๋ฉด ๋‹ค์Œ๊ณผ ๊ฐ™๋‹ค.


๊ทธ๋Ÿผ String๊ฐ์ฒด์˜ ์ƒ์„ฑ์‹œ ์„œ๋กœ ๊ณต์œ ํ•˜์ง€ ์•Š์€ ๋ฐ์ดํ„ฐ ๊ตฌ์กฐ๋ฅผ ๊ฐ€์ง€๋„๋ก ํด๋ผ์ด์–ธํŠธ๊ฐ€ ์ฝ”๋“œ๋ฅผ ์ž‘์„ฑํ•˜๋ฉด ๋‹ค์Œ๊ณผ ๊ฐ™๋‹ค.

~cpp 
String s1("More Effective C++");
String s2("More Effective C++");
์ด๋ ‡๊ฒŒ ๋˜๋Š”๋ฐ, ์ด๋Š” ๊ทธ๋ฆผ์œผ๋กœ ํ‘œํ˜„ํ•˜๋ฉด,


๋‹ค์Œ๊ณผ ๊ฐ™๋‹ค. ์—ฌ๊ธฐ์—์„œ "More Effective C++" ๋ผ๋Š” ๋ฌธ์ž์—ด์„ ๊ณต์œ ํ•œ๋‹ค๋ฉด, ์ฐธ์กฐ์„ธ๊ธฐ๊ฐ€ ์ด๋ฃจ์–ด ์ง€๋Š” ๊ฒƒ์ผ ๊ฑฐ๋‹ค. ๊ทธ๋Ÿฌ๊ธฐ ์œ„ํ•ด์„œ String์˜ ๋ณต์‚ฌ ์ƒ์„ฑ์ž๋Š”, ์ฐธ์กฐ ์นด์šดํ„ฐ๋ฅผ ์˜ฌ๋ฆฌ๊ณ , ์ž๋ฃŒ๋ฅผ ์ƒˆ๋กœ ์ƒ์„ฑํ• ๊ฒƒ์ด ์•„๋‹ˆ๋ผ, ๊ทธ๋ƒฅ ํฌ์ธํ„ฐ๋งŒ ์„ธํŒ…ํ•ด ์ฃผ๋Š” ์ผ์„ ํ•ด์•ผ ํ•œ๋‹ค. ์ด๋Ÿฐ ๊ณผ์ •์„ ๊ตฌํ˜„ํ•˜๋ฉด

~cpp 
// String ํด๋ž˜์Šค์˜ ๋ณต์‚ฌ ์ƒ์„ฑ์ž, ์ดˆ๊ธฐํ™” ๋ชฉ๋ก์œผ๋กœ StringValue์˜ ํฌ์ธํ„ฐ๋ฅผ ์„ธํŒ…ํ•œ๋‹ค.
String::String(const String& rhs): value(rhs.value)
{
    ++value->refCount;  // ์ฐธ์กฐ ์นด์šดํ„ฐ๋ฅผ ์˜ฌ๋ฆฐ๋‹ค.
}
์ด ์ฝ”๋“œ๋ฅผ ์‚ฌ์šฉํ•˜๋Š” ์ƒํ™ฉ์€ ๋‹ค์Œ๊ณผ ๊ฐ™๊ณ ,

~cpp 
String s1("More Effective C++");
String s2 = s1;
์ด๋ฒˆ์— ๊ทธ๋ฆผ์œผ๋กœ ํ‘œํ˜„ํ•˜๋ฉด


์—ฌ๊ธฐ์„œ์˜ ์š”์ ์€ ์ฐธ์กฐ์„ธ๊ธฐ๊ฐ€ ์ ์šฉ๋˜์ง€ ์•Š์€ String ํด๋ž˜์Šค๋ณด๋‹ค ๋” ํšจ์œจ์ด ๋†’์•„ ์ง„๋‹ค๋Š” ์ ์ด๋‹ค. ์ด ์ฑ… ์ „๋ฐ˜์— ๊ณ„์† ์–ธ๊ธ‰ํ–ˆ๋“ฏ์ด, ์ƒ์„ฑ๊ณผ ํŒŒ๊ดด ๊ฐ™์€ ์‹œ๊ฐ„๊ณผ, ๊ณต๊ฐ„์˜ ๋งŽ์€ ๋น„์šฉ์„ ์†Œ๋ชจํ•˜๋Š” ์‹์ด ์•„๋‹Œ, ํ•ด๋‹น ํฌ์ธํ„ฐ๋งŒ์„ ๋ณต์‚ฌํ•˜๋ฏ€๋กœ, ์ผ๋‹จ, ์ƒ์„ฑ์‹œ์˜ ๋น„์šฉ์„ ์•„๋‚€๋‹ค.

์ƒ์„ฑ์ž์˜ ์†์‰ฌ์šด ๊ตฌํ˜„๊ฐ™์ด ํŒŒ๊ดด์ž ๊ตฌํ˜„๋„ ๊ทธ๋ฆฌ ์–ด๋ ค์šด ์ผ์ด ์•„๋‹ˆ๋‹ค. StringValue์˜ ํŒŒ๊ดด๋Š”, ์„œ๋กœ๊ฐ€ ์ตœ๋Œ€ํ•œ ์‚ฌ์šฉํ•˜๊ณ , ๊ฐ’์ด ํŒŒ๊ดด ์‹œ์ ์€ ์ฐธ์กฐ ์นด์šดํ„ฐ๊ฐ€(reference counter:์ดํ•˜ ์ฐธ์กฐ ์นด์šดํ„ฐ๋งŒ) 1์ธ ๊ฒฝ์šฐ ๋”์ด์ƒ ์‚ฌ์šฉํ•˜๋Š” ๊ฐ์ฒด๊ฐ€ ์—†์œผ๋ฏ€๋กœ ํŒŒ๊ดดํ•˜๋„๋ก ๊ตฌ์„ฑํ•œ๋‹ค.

~cpp 
class String {
public:
    ~String();
    ...
};
String::~String()
{
    if (--value->refCount == 0) delete value;   // ์ฐธ์กฐ ์นด์šดํ„ฐ๊ฐ€ 1์ธ ์ƒํƒœ
}
ํŒŒ๊ดด์ž์˜ ํšจ์œจ์„ ๋น„๊ตํ•ด๋„ ์—ญ์‹œ, ๋งˆ์ฐฌ๊ฐ€์ง€์ด๋‹ค. delete๊ฐ€ ๋ถˆ๋ฆฌ๋Š” ์‹œ์ ์€ ํ•ด๋‹น ๊ฐ์ฒด๊ฐ€ ๋” ์ด์ƒ ํ•„์š” ์—†์„๋•Œ๋งŒ ์ œ๊ฑฐํ•˜๋Š” ๊ฒƒ์ด๊ธฐ ๋•Œ๋ฌธ์— ๋น„์šฉ์„ ์•„๋‚„์ˆ˜ ์žˆ๋‹ค.

๋‹ค์Œ์— ๊ตฌํ˜„ํ•ด์•ผํ•  ์‚ฌํ•ญ์€ ํ• ๋‹น(assignment)๊ด€๋ จํ•œ ๊ตฌํ˜„ ์ฆ‰ operator= ์ด๋‹ค. ๋ณต์‚ฌ ์ƒ์„ฑ์ž(copy constructor)๋ฅผ ํ˜ธ์ถœ์ด ์•„๋‹Œ ํ• ๋‹น์€ ๋‹ค์Œ๊ณผ ๊ฐ™์ด ์„ ์–ธ๋˜๊ณ ,

~cpp 
class String {
public:
    String& operator=(const String& rhs);
    ...
};
๋‹ค์Œ๊ณผ ๊ฐ™์ด ์‚ฌ์šฉ๋˜๋ฉฐ

~cpp 
s1 = s2;
์ด๊ฒƒ์˜ ๊ตฌํ˜„์€ ์•ฝ๊ฐ„์€ ๋ณต์žกํ•œ๋ฐ, ์ด์œ ๋Š” ์ƒ์„ฑ๊ณผ ํŒŒ๊ดด๊ฐ€ ๋™์‹œ์— ์žˆ์–ด์•ผ ํ•˜๋Š” ์ƒํ™ฉ์„ ๊ณ ๋ คํ•ด์•ผ ํ•˜๊ธฐ ๋•Œ๋ฌธ์ด๋‹ค. ๊ทธ๋ž˜๋„ ์•„์ง ์•ž์œผ๋กœ ๋‹ค๋ฃจ์–ด์•ผํ•  ๋‚ด์šฉ์— ๋น„ํ•ด ์ƒ๋‹นํžˆ ๊ฐ„๋‹จํ•œ ํŽธ์ด๋‹ค. ์ž์„ธํ•œ ์„ค๋ช…์€ ์†Œ์Šค์— ์ฃผ์„์„ ์ฐธ๊ณ ํ•˜๋ผ

~cpp 
String& String::operator=(const String& rhs)
{
    if (value == rhs.value) {           // ์ด๋ฏธ ๋‘ ๊ฐ์ฒด๊ฐ€ ๊ฐ™์€ ๊ฐ’์„ ๊ฐ€๋ฆฌํ‚จ๋‹ค๋ฉด,
        return *this;                   // ํŠน๋ณ„ํžˆ ํ• ์ผ์€ ์—†๋‹ค.
    }                                     

    if (--value->refCount == 0) {       // ํ˜„์žฌ ๊ฐ’์ด ์ž์‹  ์™ธ์— ์•„๋ฌด๋„ ์ฐธ์กฐํ•˜๊ณ 
        delete value;                   // ์žˆ์ง€ ์•Š๋‹ค๋ฉด ์‚ญ์ œ ํ•œ๋‹ค.
    }
    value = rhs.value;                  // ์ž๋ฃŒ๋ฅผ ๊ณต์œ ํ•œ๋‹ค.
    ++value->refCount;                  // ์ฐธ์กฐ ์นด์šดํ„ฐ๋ฅผ ์˜ฌ๋ฆฐ๋‹ค.
    return *this;                       // ์ด๊ฑด ์•Œ์•„์„œ --+
}

1.3. Copy-on-Write : ์“ฐ๊ธฐ์— ๊ธฐ๋ฐ˜ํ•œ ๋ณต์‚ฌ

์ฐธ์กฐ์„ธ๊ธฐ๊ฐ€ ์ ์šฉ๋œ ๋ฌธ์ž์—ด์— ๋Œ€ํ•˜์—ฌ ๋‘˜๋Ÿฌ ๋ดค๋Š”๋ฐ, ์ด๋ฒˆ์—๋Š” ๋ฐฐ์—ด์— ๊ด€ํ•œ(array-bracket) ์—ฐ์‚ฐ์ž๋“ค "[]" ์ด๋…€์„๋“ค์— ๊ด€ํ•ด์„œ ์ƒ๊ฐํ•ด ๋ณด์ž. ํด๋ž˜์Šค์˜ ์„ ์–ธ์€ ๋‹ค์Œ๊ณผ ๊ฐ™๋‹ค.

~cpp 
class String {
public:
    const char& operator[](int index) const;    // const String์— ๋Œ€ํ•˜์—ฌ

    char& operator[](int index);                // non-const String์— ๋Œ€ํ•˜์—ฌ
    ...
};
const String์— ๋Œ€ํ•œ ๊ฐ’์„ ์ฃผ๋Š” ๊ฒƒ์€ ์•„๋ž˜์™€ ๊ฐ™์ด ๊ฐ„๋‹จํžˆ ํ•ด๊ฒฐ๋œ๋‹ค. ๋‚ด๋ถ€ ๊ฐ’์ด ์•„๋ฌด๋Ÿฐ ์˜ํ–ฅ์„ ๋ฐ›์„ ๊ฒƒ์ด ์—†์„ ๊ฒฝ์šฐ์ด๊ธฐ ๋–„๋ฌธ์ด๋‹ค.

~cpp 
const char& String::operator[](int index) const
{
  return value->data[index];
}
(์ด ํ•จ์ˆ˜๋Š” ์›๋ž˜์˜ C++์—์„œ ๋ฐฐ์—ด์˜ ์‚ฌ์šฉ ๊ฐœ๋…๊ณผ ๊ฐ™์ด, index์˜ ์œ ํšจ์„ฑ์„ ์ ๊ฒ€ํ•˜์ง€ ์•Š๋Š”๋‹ค. ์ด์— ๋Œ€ํ•œ ๊ฐ์€์€ ์ฐธ์กฐ ์„ธ๊ธฐ์˜ ์ฃผ์ œ์— ๋–จ์–ด์ ธ ์žˆ๊ณ , ์ถ”๊ฐ€ํ•˜๋Š” ๊ฒƒ๋„ ๊ทธ๋ฆฌ ์–ด๋ ค์šด์ผ์ด ์•„๋‹ˆ๋ผ ์ผ๋‹จ์€ ์ œ์™ธํ•œ๋‹ค.)

ํ•˜์ง€๋งŒ non-const์˜ operator[]๋Š” ์ด๊ฒƒ(const operator[])์™€ ์™„์ „ํžˆ ๋‹ค๋ฅธ ์ƒํ™ฉ์ด ๋œ๋‹ค. ์ด์œ ๋Š” non-const operator[]๋Š” StringValue๊ฐ€ ๊ฐ€๋ฆฌํ‚ค๊ณ  ์žˆ๋Š” ๊ฐ’์„ ๋ณ€๊ฒฝํ• ์ˆ˜ ์žˆ๋Š” ๊ถŒํ•œ์„ ๋‚ด์ฃผ๊ธฐ ๋•Œ๋ฌธ์ด๋‹ค. ์ฆ‰, non-const operator[]๋Š” ์ž๋ฃŒ์˜ ์ฝ๊ธฐ(Read)์™€ ์“ฐ๊ธฐ(Write)๋ฅผ ๋‹ค ํ—ˆ์šฉํ•œ๋‹ค.

~cpp 
String s;
...
cout << s[3];       // ์ด๊ฑด ์ฝ๊ธฐ(Read)
s[5] = 'x';         // ์ด๊ฑด ์“ฐ๊ธฐ(Write)

์ฐธ์กฐ ์„ธ๊ธฐ๊ฐ€ ์ ์šฉ๋œ String์€ ์ˆ˜์ •ํ• ๋•Œ ์กฐ์‹ฌํ•˜๊ฒŒ ํ•ด์•ผ ๋œ๋‹ค. ๊ทธ๋ž˜์„œ ์ผ๋‹จ ์•ˆ์ „ํ•œ non-const operator[]๋ฅผ ์ˆ˜ํ–‰ํ•˜๊ธฐ ์œ„ํ•˜์—ฌ ์•„์˜ˆ operator[]๋ฅผ ์ˆ˜ํ–‰ํ• ๋•Œ ๋งˆ๋‹ค ์ƒˆ๋กœ์šด ๊ฐ์ฒด๋ฅผ ์ƒ์„ฑํ•ด ๋ฒ„๋ฆฌ๋Š” ๊ฒƒ์ด๋‹ค. ๊ทธ๋ž˜์„œ ๋งŒ๋“  ๊ฒƒ์ด ๋‹ค์Œ๊ณผ ๊ฐ™์€ ๋ฐฉ๋ฒ•์œผ๋กœ ํ•˜๊ณ , ์„ค๋ช…์€ ์ฃผ์„์— ๋” ์ž์„ธํžˆ

~cpp 
char& String::operator[](int index)     // non-const operator[]
{
  // if we're sharing a value with other String objects,
  // break off a separate copy of the value for ourselves
    // ๋งŒ์•ฝ ๋‹ค๋ฅธ ๊ฐ์ฒด์™€ ์ž๋ฃŒ๋ฅผ ๊ณต์œ ํ•˜์ง€ ์•Š๊ณ  ์žˆ๋‹ค๋ฉด, ์ž๋ฃŒ๋ฅผ ๋…ธ์ถœ ์‹œ์ผœ๋„ 
    // ์ƒ๊ด€์ด ์—†๋‹ค. 
    if (value->refCount > 1) {          // if ์•ˆ์ชฝ์€ ์ƒˆ๋กœ์šด ๊ฐ์ฒด๋ฅผ ์ƒ์„ฑํ•ด์•ผ ํ•  ๊ฒฝ์šฐ
        --value->refCount;              // ์ƒˆ๋กœ์šด ๊ฐ์ฒด์˜ ์ƒ์„ฑ์„ ์œ„ํ•ด์„œ ํ˜„์žฌ ์ฐธ์กฐํ•˜๋Š”
                                        // ์ž๋ฃŒ์˜ refCount๋ฅผ ๊ฐ์†Œ ์‹œํ‚จ๋‹ค.
    value = new StringValue(value->data);   // ํ˜„์žฌ ์ž๋ฃŒ์˜ ์‚ฌ๋ณธ์„ ๋งŒ๋“ค์–ด
                                            // ์ด๊ฒƒ์„ ๊ฐ€๋ฆฌํ‚จ๋‹ค.
    }

    // ์ด์ œ, ์•„๋ฌด๋„ ๊ณต์œ ํ•˜๊ณ  ์žˆ์ง€ ์•Š์€ StringValue์˜ ๊ฐ์ฒด
    // ๋‚ด๋ถ€์˜ ๋ฌธ์ž์—ด์˜ ํ•œ ๋ถ€๋ถ„์„ ๋ฐ˜ํ™˜ํ•œ๋‹ค.
    return value->data[index];
}
์ด๊ฒƒ์€ ๋ถ€์กฑํ•œ ์ ์ด ์žˆ๋‹ค. ๋‹ค์Œ ๊ณผ์ •์—์„œ ๋ณด๊ฐ•ํ•œ๋‹ค.

์ด๋Ÿฌํ•œ ์ƒ๊ฐ์€ ์ปดํ“จํ„ฐ ๊ณผํ•™์—์„œ ์˜ค๋žซ๋™์•ˆ ๋‹ค๋ฃจ์–ด ์ ธ์žˆ๋˜ ๊ฒƒ์ด๋‹ค. ํŠนํžˆ๋‚˜ OS(operating system)์„ค๊ณ„์‹œ์— Process๊ฐ€ ๊ณต์œ ํ•˜๊ณ  ์žˆ๋˜ ๋ฐ์ดํ„ฐ๋ฅผ ๊ทธ๋“ค์ด ์ˆ˜์ •ํ•˜๊ณ ์ž ํ•˜๋Š” ๋ถ€๋ถ„์„ ๋ณต์‚ฌํ•ด์„œ ์ ‘๊ทผ์„ ํ—ˆ๋ฝ ๋ฐ›๋Š” ๋ฃจํ‹ด์—์„œ ๋งŽ์ด ์“ฐ์ธ๋‹ค. ํ”์ด ์ด๋Ÿฌํ•œ ๊ธฐ์ˆ ์— ๊ด€ํ•ด์„œ copy-on-write(์“ฐ๊ธฐ์— ๊ธฐ๋ฐ˜ํ•œ ๋ณต์‚ฌ, ์ดํ›„ copy-on-write๋ฅผ ๊ทธ๋ƒฅ ์“ด๋‹ค.) ๋ผ๊ณ  ๋ถ€๋ฅธ๋‹ค.

1.4. Pointers, References, and Copy-on-Write : ํฌ์ธํ„ฐ, ์ฐธ์กฐ, ์“ฐ๊ธฐ์— ๊ธฐ๋ฐ˜ํ•œ ๋ณต์‚ฌ

copy-on-write๋ฅผ ๊ตฌํ˜„ํ• ๋•Œ ์ •ํ™•์„ฑ๊ณผ ํšจ์œจ์„ฑ, ๋‘˜๋‹ค ๋งŒ์  ์‹œํ‚ค๋Š” ํŽธ์ด๋‹ค. ํ•˜์ง€๋งŒ ํ•ญ์ƒ๋”ฐ๋ผ๋‹ค๋‹ˆ๋Š”๋ฌด๋„บ๊ฐ€ ์žˆ๋Š”๋ฐ, ๋‹ค์Œ ์ฝ”๋“œ๋ฅผ ์ƒ๊ฐํ•ด ๋ณด์ž.

~cpp 
String s1 = "Hello";
char *p = &s1[1];
์ด๋ฅผ ๋Œ€๊ฐ• ๊ทธ๋ฆผ์„ ๋‚˜ํƒ€๋‚ด ๋ณด๋ฉด p๊ฐ€ Hello์˜ e๋ฅผ ๊ฐ€๋ฆฌํ‚ค๋Š” ์ด์ •๋„์˜ ๋А๋‚Œ์ผ ๊ฒƒ์ด๋‹ค.


๊ทธ๋Ÿฌ๋ฉด ์ด๋ฒˆ์—๋Š” ์—ฌ๊ธฐ์— ํ•œ์ค„๋งŒ ๋ง๋ถ™์—ฌ ๋ณธ๋‹ค.

~cpp 
String s2 = s1;
String ๋ณต์‚ฌ ์ƒ์„ฑ์ž๊ฐ€ ์•„๋งˆ s2๊ฐ€ s1์˜ StringValue๋ฅผ ๊ณต์œ ํ•˜๊ฒŒ ๋งŒ๋“ค๊ฒƒ์ด๋‹ค. ๊ทธ๋ž˜์„œ ๋‹น์Œ๊ณผ ๊ฐ™์€ ๊ทธ๋ฆผ์œผ๋กœ ํ‘œํ˜„๋  ๊ฒƒ์ด๋‹ค.


๊ทธ๋ž˜์„œ ๋‹ค์Œ๊ณผ ๊ฐ™์€ ๊ตฌ๋ฌธ์„ ์‹คํ–‰ํ•œ๋‹ค๋ฉด

~cpp 
p = 'x';                     // ์ด ๊ฒƒ์€ s1, s2๋ฅผ ๋ชจ๋‘ ๋ณ€๊ฒฝ!
String์˜ ๋ณต์‚ฌ ์ƒ์„ฑ์ž๋Š” ์ด๋Ÿฌํ•œ ์ƒํƒœ๋ฅผ ๊ฐ์ง€ํ•  ๋ฐฉ๋ฒ•์ด ์—†๋‹ค. ์œ„์—์„œ ๋ณด๋“ฏ์ด, s2๊ฐ€ ์ฐธ๊ณ ํ• ์ˆ˜ ์žˆ๋Š” ์ •๋ณด๋Š” ๋ชจ๋‘ s1์˜ ๋‚ด๋ถ€์— ์žˆ๋Š”๋ฐ, s1์—๊ฒŒ๋Š” non-const operator[]๋ฅผ ์ˆ˜ํ–‰ํ•˜์˜€๋Š”์ง€์— ๊ด€ํ•œ ๊ธฐ๋ก์€ ์—†๋‹ค.

์ด๋Ÿฐ๊ฒƒ์„ ํ•ด๊ฒฐํ• ์ˆ˜ ์žˆ๋Š” ๋ฐฉ๋ฒ•์œผ๋กœ๋Š” ์ตœ์†Œํ•œ ์„ธ๊ฐ€์ง€๋ฅผ ์ƒ๊ฐํ• ์ˆ˜ ์žˆ๋Š”๋ฐ, ์ฒซ๋ฒˆ์งธ๋Š” ์ด๊ฒƒ์„ ์—†๋Š”๊ฑธ๋กœ ์ทจ๊ธ‰ํ•˜๊ณ , ๋ฌด์‹œ ํ•ด ๋ฒ„๋ฆฌ๋Š” ๊ฒƒ์ด๋‹ค. ์ด๋Ÿฌํ•œ ์ ‘๊ทผ ๋ฐฉํ–ฅ์€ ์ฐธ์กฐ ์„ธ๊ธฐ๊ฐ€ ์ ์šฉ๋˜์–ด ์žˆ๋Š” ํด๋ž˜์Šค ๋ผ์ด๋ธŒ๋Ÿฌ๋ฆฌ์— ์ƒ๋‹นํ•œ ๊ดด๋กœ์›€์„ ๋œ์–ด ์ฃผ๋Š”๊ฒƒ์ด๋‹ค. ํ•˜์ง€๋งŒ ์ด๋Ÿฌํ•œ ๋ฌธ์ œ๋ฅผ ๊ตฌํ˜„์ƒ์—์„œ ์™„์ „ํžˆ ๋ฌด์‹œํ• ์ˆ˜๋Š” ์—†๋Š” ๋…ธ๋ฆ‡์ด๋‹ค. ๋‘๋ฒˆ์งธ๋กœ ์ƒ๊ฐํ• ์ˆ˜ ์žˆ๋Š” ๋ฐฉ๋ฒ•์€ ์ด๋Ÿฌํ•œ๊ฒƒ์„ ํ•˜์ง€ ๋ง๋„๋ก ๋ช…์‹œํ•˜๋Š” ๊ฒƒ์ธ๋ฐ, ์—ญ์‹œ๋‚˜ ๋ณต์žกํ•˜๋‹ค. ์„ธ๋ฒˆ์งธ๋กœ, ๋ญ ๊ฒฐ๊ตญ ์ œ๊ฑฐ์•ผ๋งŒ ํ• ๊ฒƒ์ด๋‹ค. ์ด๋Ÿฌํ•œ ๋ถ„์ œ์˜ ์ œ๊ฑฐ๋Š” ๊ทธ๋ฆฌ ์–ด๋ ต์ง€๋Š” ์•Š๋‹ค. ๋ฌธ์ œ๋Š” ํšจ์œจ์ด๋‹ค. ์ด๋Ÿฐ ์ค‘๋ณต์— ๊ด€๋ จํ•œ ๋ฌธ์ œ๋ฅผ ์ œ๊ฑฐํ•˜๊ธฐ ์œ„ํ•ด์„œ๋Š”, ์ƒˆ๋กœ์šด ์ž๋ฃŒ ๊ตฌ์กฐ๋ฅผ ๋งŒ๋“ค์–ด ๋‚ด์•ผํ•˜๊ณ , ์ด๊ฒƒ์˜ ์˜๋ฏธ๋Š” ๊ฐ์ฒด๊ฐ„์— ์„œ๋กœ ๊ณต์œ ํ•˜๋Š” ์ž๋ฃŒ๊ฐ€ ์ค„์–ด ๋“ ๋‹ค๋Š” ์˜๋ฏธ์ด๋‹ค. ์ฆ‰, ๋น„์šฉ์ด ๋งŽ์ด ๋“ค์–ด๊ฐ„๋‹ค. ํ•˜์ง€๋งŒ ์–ด์ฉ”์ˆ˜ ์—†์ง€ ์•Š์„๊นŒ?

๊ฐ„๋‹จํ•œ ํ”Œ๋ž˜๊ทธ ํ•˜๋‚˜๋ฅผ ์ถ”๊ฐ€ํ•˜๋Š” ๊ฒƒ์œผ๋กœ ์ด ๋ฌธ์ œ๋Š” ํ•ด๊ฒฐ๋œ๋‹ค. ์ด๋ฒˆ ์ˆ˜์ • ๋ฒ„์ „์€ ๊ณต์œ ์˜ ์—ฌ๋ถ€๋ฅผ ํ—ˆ๋ฝํ•˜๋Š” sharable ์ธ์ž๋ฅผ ๋”ํ•œ ๊ฒƒ์ด๋‹ค. ์ฝ”๋“œ๋ฅผ ๋ณด์ž.

~cpp 
class String {
private:
    struct StringValue {
        int refCount;
        bool shareabl;              // ์ด ์ธ์ž๊ฐ€ ๋”ํ•ด ์กŒ๋‹ค.
        char *data;
        StringValue(const char *initValue);
        ~StringValue();
    };
    ...
};
String::StringValue::StringValue(const char *initValue)
:   refCount(1),
    shareable(true)                 // ์ดˆ๊ธฐํ™”์‹œ์—๋Š” ๊ณต์œ ๋ฅผ ํ—ˆ๋ฝํ•œ๋‹ค.
{
    data = new char[strlen(initValue) + 1];
    strcpy(data, initValue);
}
String::StringValue::~StringValue()
{
    delete [] data;
}
๋ณต์‚ฌ ์ƒ์„ฑ์ž์—์„œ๋Š” ์ฐธ์กฐ ๋ฟ๋งŒ ์•„๋‹ˆ๋ผ. ๊ณต์œ ๋ฅผ ๊ฑฐ๋ถ€ํ• ๋•Œ ์—ญ์‹œ ๊ฐ์•ˆํ•ด์•ผ ํ•˜๋ฏ€๋กœ, ์ˆ˜์ •ํ•ด์•ผ ํ•œ๋‹ค.

~cpp 
String::String(const String& rhs)
{
  if (rhs.value->shareable) {       // ๊ณต์œ ๋ฅผ ํ—ˆ๋ฝํ•  ๊ฒฝ์šฐ
    value = rhs.value;
    ++value->refCount;
  }
  else {                            // ๊ณต์œ ๋ฅผ ๊ฑฐ๋ถ€ํ•  ๊ฒฝ์šฐ
    value = new StringValue(rhs.value->data);
  }
}
๊ทธ๋ฆฌ๊ณ  ์ด shareable์ธ์ž๋Š” non-const operator[]๊ฐ€ ํ˜ธ์ถœ๋ ๋•Œ false๋กœ ๋ณ€๊ฒฝ๋˜์–ด์„œ ์ดํ›„, ํ•ด๋‹น ์ž๋ฃŒ์˜ ๊ณต์œ ๋ฅผ ๊ธˆ์ง€ํ•œ๋‹ค.

~cpp 
char& String::operator[](int index)
{
    if (value->refCount > 1) {
        --value->refCount;
        value = new StringValue(value->data);
    }
    value->shareable = false;           // ์ด์ œ ์ž๋ฃŒ์˜ ๊ณต์œ ๋ฅผ ๊ธˆ์ง€ํ•œ๋‹ค.
    return value->data[index];
}
๋งŒ์•ฝ Item 30์— ์–ธ๊ธ‰๋˜๋Š” proxy ํด๋ž˜์Šค ๋ฐฉ๋ฒ•์„ ์‚ฌ์šฉํ•ด์„œ ์ฝ๋Š” ์ž‘์—…๊ณผ, ์“ฐ๋Š” ์ž‘์—…์— ๋Œ€ํ•œ ๊ฒƒ์„ ๊ตฌ๋ถ„ํ•œ๋‹ค๋ฉด StringValue ๊ฐ์ฒด์˜ ์ˆซ์ž๋ฅผ ์ข€๋” ์ค„์ผ์ˆ˜ ์žˆ์„ ๊ฒƒ์ด๋‹ค. ๊ทธ๊ฑด ๋‹ค์Œ ์žฅ์—์„œ ๋ณด์ž.

1.5. A Reference-Counting Base Class : ์ฐธ์กฐ-์„ธ๊ธฐ ๊ธฐ์ดˆ ํด๋ž˜์Šค

์ฐธ์กฐ์„ธ๊ธฐ๋Š” ๋‹จ์ง€ string์˜ ๊ฒฝ์šฐ์—๋งŒ ์œ ์šฉํ•œ๊ฑธ๊นŒ? ๋‹ค๋ฅธ ๊ฐ์ฒด ์—ญ์‹œ ์ฐธ์กฐ์„ธ๊ธฐ๋ฅผ ์ ์šฉํ•ด์„œ ์‚ฌ์šฉํ• ์ˆ˜๋Š” ์—†์„๊นŒ? ์ƒ๊ฐํ•ด ๋ณด๋ฉด ์ฐธ์กฐ์„ธ๊ธฐ๋ฅผ ๊ตฌํ˜„ํ•˜๊ธฐ ์œ„ํ•ด์„œ๋Š” ์ง€๊ธˆ๊นŒ์ง€์˜ ์–ธ๊ธ‰์˜ ๊ธฐ๋Šฅ์„ ๋ฌถ์–ด์„œ ์žฌ์‚ฌ์šฉ ๊ฐ€๋Šฅํ•˜๊ฒŒ ๋งŒ๋“ค๋ฉด ์ข‹์„๊ฒƒ ๊ฐ™์€๋ฐ, ํ•œ๋ฒˆ ๋งŒ๋“ค์–ด ๋ณด๋„๋ก ํ•˜์ž.

์ œ์ผ ์ฒ˜์Œ์— ํ•ด์•ผ ํ• ์ผ์€ ์ฐธ์กฐ์„ธ๊ธฐ๊ฐ€ ์ ์šฉ๋œ ๊ฐ์ฒด๋ฅผ ์œ„ํ•œ (reference-counded object) RCObject๊ฐ™์€ ๊ธฐ์ดˆ ํด๋ž˜์Šค๋ฅผ ๋งŒ๋“œ๋Š” ๊ฒƒ์ด๋‹ค. ์–ด๋– ํ•œ ํด๋ผ์Šค๋ผ๋„ ์ด ํด๋ž˜์Šค๋ฅผ ์ƒ์†๋ฐ›์œผ๋ฉด ์ž๋™์ ์œผ๋กœ ์ฐธ์กฐ์„ธ๊ธฐ์˜ ๊ธฐ๋Šฅ์ด ๊ตฌํ˜„๋˜๋Š” ํ˜•์‹์„ ๋ฐ”๋ผ๋Š” ๊ฒƒ์ด๋‹ค. ๊ทธ๋Ÿฌ๊ธฐ ์œ„ํ•ด์„œ๋Š” RCObject๊ฐ€ ๊ฐ€์ง€๊ณ  ์žˆ์–ด์•ผ ํ•˜๋Š” ๋Šฅ๋ ฅ์€ ์นด์šดํ„ฐ์— ๋Œ€ํ•œ ์ฆ๊ฐ์— ๋Œ€ํ•œ ๋Šฅ๋ ฅ์ผ ๊ฒƒ์ด๋‹ค. ๊ฒŒ๋‹ค๊ฐ€ ๋” ์ด์ƒ, ์‚ฌ์šฉ์ด ํ•„์š” ์—†๋Š” ์‹œ์ ์—์„œ๋Š” ํŒŒ๊ดด๋˜์–ด์•ผ ํ•œ๊ฒƒ์ด๋‹ค. ๋‹ค์‹œ๋งํ•ด, ํŒŒ๊ดด๋˜๋Š” ์‹œ์ ์€ ์นด์šดํ„ฐ์˜ ์ธ์ž๊ฐ€ 0์ด ๋ ๋•Œ์ด๋‹ค. ๊ทธ๋ฆฌ๊ณ  ๊ณต์œ  ํ—ˆ์šฉ ํ”Œ๋ž˜๊ทธ์— ๋Œ€ํ•œ(shareable flag) ๊ด€ํ•œ ๊ฒƒ์€, ํ˜„์žฌ๊ฐ€ ๊ณต์œ  ๊ฐ€๋Šฅํ•œ ์ƒํƒœ์ธ์ง€ ๊ฒ€์ฆํ•˜๋Š” ๋ฉ”์†Œ๋“œ์™€, ๊ณต์œ ๋ฅผ ๋ฌถ์–ด ๋ฒ„๋ฆฌ๋Š” ๋ฉ”์†Œ๋“œ, ์ด๋ ‡๊ฒŒ๋งŒ ์žˆ์œผ๋ฉด ๋ ๊ฒƒ์ด๋‹ค. ๊ณต์œ ๋ฅผ ํ‘ผ๋‹ค๋Š” ๊ฒƒ์€ ์ง€๊ธˆ๊นŒ์ง€์˜ ์ƒ๊ฐ์œผ๋กœ๋Š” ๋ถˆ๊ฐ€๋Šฅํ•œ ๊ฒƒ์ด๊ธฐ ๋•Œ๋ฌธ์ด๋‹ค.

์ด๋Ÿฌํ•œ ์ •์˜๋ฅผ ๋ชจ์•„๋ชจ์•„ ๋ผˆ๋Œ€๋ฅผ ๋งŒ๋“ค๋ฉด ๋‹ค์Œ๊ณผ ๊ฐ™๋‹ค.

~cpp 
class RCObject {
public:
    RCObject();
    RCObject(const RCObject& rhs);
    RCObject& operator=(const RCObject& rhs);
    virtual ~RCObject() = 0;

    void addReference();
    void removeReference();
    void markUnshareable();
    bool isShareable() const;
    bool isShared() const;
private:
    int refCount;
    bool shareable;
};

RCObject๋Š” ์ƒ์„ฑ๋˜๊ณ , ํŒŒ๊ดด๋˜์–ด ์งˆ์ˆ˜ ์žˆ์–ด์•ผ ํ•œ๋‹ค. ์ƒˆ๋กœ์šด ์ฐธ์กฐ๊ฐ€ ์ถ”๊ฐ€๋˜๋ฉด ํ˜„์žฌ์˜ ์ฐธ์กฐ๋Š” ์ œ๊ฑฐ๋˜์–ด์•ผ ํ•œ๋‹ค. ๊ณต์œ  ์ƒํƒœ์— ๋Œ€ํ•ด ์—ฌ๋ถ€๋ฅผ ์•Œ์ˆ˜ ์žˆ์–ด์•ผ ํ•˜๋ฉฐ, disable๋กœ ์„ค์ •ํ• ์ˆ˜ ์žˆ์–ด์•ผ ํ•œ๋‹ค. ํŒŒ๊ดด์ž์— ๋Œ€ํ•œ ์‹ค์ˆ˜๋ฅผ ๋ฐฉ์ง€ํ•˜๊ธฐ ์œ„ํ•˜์—ฌ ๋ฒ ์ด์Šค ํด๋ž˜์Šค๋Š” ํŒŒ๊ดด์ž๋ฅผ ๊ฐ€์ƒ ํ•จ์ˆ˜๋กœ์„ ์–ธํ•ด์•ผ ๋œ๋‹ค. ์—ฌ๊ธฐ์—์„œ๋Š” ์ˆœ์ˆ˜ ๊ฐ€์ƒ ํ•จ์ˆ˜(pure virtual function)๋กœ ์„ ์–ธํ•œ๋‹ค.

๋‹ค์Œ ์ฝ”๋“œ๊ฐ€ RCObject๋ฅผ ๋ณ„ ์˜ˆ์™ธ ์—†๋‹ค๋Š” ์ „์ œ๋กœ, ์ง€๊ธˆ๊นŒ์ง€์˜ ์ƒ๊ฐ๋“ค์„ ๊ฐ„๋‹จํžˆ ๊ตฌํ˜„ํ•œ ์ฝ”๋“œ์ด๋‹ค.


~cpp 
RCObject::RCObject()
: refCount(0), shareable(true) {}

RCObject::RCObject(const RCObject&)
: refCount(0), shareable(true) {}

RCObject& RCObject::operator=(const RCObject&)
{ return *this; }

RCObject::~RCObject() {}                // ํŒŒ๊ดด์ž๋Š” ๊ทธ๊ฒƒ์ด ์ˆœ์ˆ˜ ๊ฐ€์ƒ ํ•จ์ˆ˜๋ผ๋„
                                        // ํ•ญ์ƒ ๊ตฌํ˜„๋˜์–ด ์žˆ์–ด์•ผ ํ•œ๋‹ค.

void RCObject::addReference() { ++refCount; }

void RCObject::removeReference()
{   if (--refCount == 0) delete this; }

void RCObject::markUnshareable()
{ shareable = false; }

bool RCObject::isShareable() const
{ return shareable; }

bool RCObject::isShared() const
{ return refCount > 1; }
์˜๋ฌธ ํ•˜๋‚˜, ํฅ๋ฏธ๋กญ๊ฒŒ๋„ ์ฒ˜์Œ์— refCount๋ฅผ 0์œผ๋กœ ์„ธํŒ…ํ•œ๋‹ค. ์ด๊ฑด ์ง๊ด€์ ์ด์ง€ ๋ชปํ•˜๊ฒŒ ๋ณด์ด๋Š”๋ฐ, ํ™•์‹คํžˆ ์ƒˆ๋กœ ๋งŒ๋“ค์–ด์ง€๋Š” RCObject์˜ ์ƒ์„ฑ์ž๋Š” ์ƒˆ๋กœ ๋งŒ๋“ค์–ด์ง„ RCObject๋ฅผ ์ฐธ์กฐํ•˜๊ณ  ์žˆ์„ ๊ฒƒ์ด๊ธฐ ๋•Œ๋ฌธ์ด๋‹ค. ํ•˜์ง€๋งŒ ์ด๋Ÿฌํ•œ ์ด์œ ๋Š”, ์ƒˆ๋กœ์šด ๊ฐ์ฒด๊ฐ€ ํ• ๋‹น๋œ ๋’ค์— ์œ ๋„๋œ ํด๋ž˜์Šค ์Šค์Šค๋กœ, refCount๋ฅผ ์ฆ๊ฐ€ ์‹œ์ผœ์ฃผ๊ธฐ์œ„ํ•ด์„œ ์ด๋‹ค. ์ด๊ฒƒ์ด ์‚ฌ์šฉ์ž์—๊ฒŒ ๋” ๋ช…์‹œ์ ์ธ ์ฝ”๋“œ๋ฅผ ์ž‘์„ฑํ•˜๊ฒŒ ๋œ๋‹ค.

์˜๋ฌธ ๋‘˜, ๋ณต์‚ฌ ์ƒ์„ฑ์ž๋Š” refCount๋ฅผ ํ•ญ์ƒ 0์œผ๋กœ ์„ธํŒ…ํ•ด ๋ฒ„๋ฆฐ๋‹ค. ์‚ฌ์‹ค ๋ณต์‚ฌํ• ๋•Œ๋Š” refCount๋Š” ์ƒ๊ด€์ด ์—†๋‹ค. ์ด์œ ๋Š” ์ƒˆ๋กœ์šด ๊ฐ์ฒด์˜ ๊ฐ’์ด๋ผ, ์ด๊ฒƒ์€ ํ•ญ์ƒ ์–ด๋–ค ๊ฐ์ฒด์™€๋„ ๊ณต์œ ํ•˜๊ณ  ์žˆ์ง€ ์•Š๊ธฐ ๋•Œ๋ฌธ์— refCount๋ฅผ ์ดˆ๊ธฐํ™” ์‹œํ‚จ๋‹ค.

์˜๋ฌธ ์…‹, ํ• ๋‹น(assignment) ์—ฐ์‚ฐ์ž๋Š” ์•„๊นŒ ๊ณต์œ  ๋ฌธ์ œ๋ฅผ ๋’ค์ง‘์–ด ๋ฒ„๋ฆฌ๋Š” ๊ฒƒ ์ฒ˜๋Ÿผ ๋ณด์ธ๋‹ค. ํ•˜์ง€๋งŒ ์ด ๊ฐ์ฒด๋Š” ๊ธฐ์ดˆ ํด๋ž˜์Šค์ด๋‹ค. ์–ด๋–ค ์ƒํ™ฉ์—์„œ ์ด๋ฅผ ์œ ๋„ํ•˜๋Š” ๋‹ค๋ฅธ ํด๋ž˜์Šค๊ฐ€ ๊ณต์œ  flag๋ฅผ ๋น„ํ™œ์„ฑํ™” ์‹œํ‚ค๋Š”์ง€ ํ™•์‹  ํ• ์ˆ˜ ์—†๊ธฐ ๋•Œ๋ฌธ์—, ์ผ๋‹จ ์•„๋ฌด๊ฒƒ๋„ ํ•˜์ง€ ์•Š๊ณ , ํ˜„์žฌ์˜ ๊ฐ์ฒด๋ฅผ ๋ฐ˜ํ™˜ํ•˜๊ฒŒ ํ•ด ๋‘์—ˆ๋‹ค.

๊ณ„์† ํ•ด๊น”๋ฆด์ˆ˜ ์žˆ๋Š”๋ฐ, ๋‹ค์Œ๊ณผ ๊ฐ™์€ ์ฝ”๋“œ๋ฅผ ๋ณด๋ฉด

~cpp 
sv1 = sv2;          // ์–ด๋–ป๊ฒŒ sv1๊ณผ sv2์˜ ์ฐธ์กฐ ์นด์šดํ„ฐ๊ฐ€ ์˜ํ–ฅ ๋ฐ›์„๊นŒ?
์ž, RCObject๋Š” ๊ธฐ์ดˆ ํด๋ž˜์Šค์ด๋ฉฐ, ์ฐจํ›„ ๋ฐ์ดํ„ฐ๋ฅผ ์ €์žฅํ•˜๋Š” ๊ณต๊ฐ„์€ RCObject์˜ ์ž์‹์—๊ฒŒ์„œ ๊ตฌํ˜„๋˜์–ด ์ง„๋‹ค. ๊ทธ๋ž˜์„œ opreator=์€ ์œ ๋„ ๋œ ํด๋ž˜์Šค์—์„œ ์›ํ• ๋•Œ ์ด ์ฐธ์กฐ ๊ฐ์ฒด๋ฅผ ๋ฐ”๊พธ๊ธฐ ์œ„ํ•˜์—ฌ, RCObject::operator= ํ˜•์‹์œผ๋กœ ๋ถˆ๋Ÿฌ์•ผ ํ•œ๋‹ค. ์ดํ•˜, ๊ฑฐ์˜๋‹ค ์†Œ์Šค ์ž์ฒด๋ฅผ ์ดํ•ดํ•ด์•ผ ํ•œ๋‹ค. ํ•ด๋‹น RCObject๋ฅผ ์ด์šฉํ•ด์„œ ์œ ๋„๋œ ํด๋ž˜์Šค์˜ ๋ชจ์–‘์€ ๋‹ค์Œ๊ณผ ๊ฐ™์œผ๋ฉฐ, ๋ชจ๋“  ์ฝ”๋“œ๋Š” ๊ตฌํ˜„ํ•˜์ง€ ์•Š๊ฒ ์ง€๋งŒ, ์ง€๊ธˆ๊นŒ์ง€์˜ ๊ฐœ๋…์œผ๋กœ ์ดํ•ดํ• ์ˆ˜ ์žˆ์„ ๊ฒƒ์ด๋‹ค.

~cpp 
class String {
private:
  struct StringValue: public RCObject {
    char *data;

    StringValue(const char *initValue);
    ~StringValue();

  };

...

};

String::StringValue::StringValue(const char *initValue)
{
  data = new char[strlen(initValue) + 1];
  strcpy(data, initValue);
}

String::StringValue::~StringValue()
{
  delete [] data;
}
์ด StringValue๋ฒ„์ „์€ ์ด์ „์— ๋ณด๋˜๊ฒƒ๊ณผ ๊ฑฐ์˜ ๋™์ผํ•œ ํ˜•ํƒœ๋ฅผ ๋ณด์ธ๋‹ค.๋‹จ, refCount๋ฅผ ๋‹ค๋ฃจ๋Š” ๊ฒƒ๋งŒ์ด RCObject์˜ ๋ฉค๋ฒ„ ํ•จ์ˆ˜๋กœ์„œ ๋ชจ๋“  ๊ธฐ๋Šฅ์„ ํ›„ํ–‰ํ•˜๋Š” ๊ฒƒ์ด๋‹ค. ์ด ๊ฒƒ์˜ ๋” ๊ตฌ์ฒด์ ์ธ ์ฝ”๋“œ๋Š” ๋‹ค์Œ ์žฅ์—์„œ ๋ณด์ด๋Š” ์Šค๋งˆํŠธ ํฌ์ธํ„ฐ๋ฅผ ์ด์šฉํ•œ ์ž๋™ ์ฐธ์กฐ ์นด์šดํŒ… ๊ธฐ๋Šฅ์„ ๋ง๋ถ™์ด๋ฉด์„œ ์–ด์ฐจํ”ผ ๋ชจ๋“  ์ฝ”๋“œ๋ฅผ ์„œ์ˆ ํ•  ๊ฒƒ์ด๋‹ค.

์ด๋ฒˆ ์ฃผ์ œ์˜ nested class์˜ ๋ชจ์Šต์„ ๋ณด๋ฉด ๊ทธ๋ฆฌ ์ข‹์™€ ๋ณด์ด์ง€๋Š” ์•Š์„ ๊ฒƒ์ด๋‹ค.์ฒ˜์Œ์—๋Š” ์ƒ์†Œํ•˜๊ฒ ์ง€๋งŒ, ์ด๋Ÿฌํ•œ ๋ฐฉ๋ฒ„์€ ์ •๋‹นํ•œ ๊ฒƒ์ด๋‹ค. nestedํด๋ž˜์Šค์˜ ๋ฐฉ๋ฒ•์€ ์ˆ˜๋งŽ์€ ํด๋ž˜์Šค์˜ ์ข…๋ฅ˜์ค‘ ๋‹จ์ง€ ํ•˜๋‚˜ ๋ฟ์ด๋‹ค. ์ด๊ฒƒ์„ ํŠน๋ณ„ํžˆ ์ทจ๊ธ‰ํ•˜์ง€๋Š” ๋ง์•„๋ผ.

1.6. Automating Reference Count Manipulations : ์ž๋™ ์ฐธ์กฐ ์„ธ๊ธฐ ๋ฐฉ๋ฒ•

RCObject๋Š” ์ฐธ์กฐ ์นด์šดํ„ฐ๋ฅผ ๋ณด๊ด€ํ•˜๊ณ , ์นด์šดํ„ฐ์˜ ์ฆ๊ฐ์„ ํ•ด๋‹น ํด๋ž˜์Šค์˜ ๋ฉค๋ฒ„ ํ•จ์ˆ˜๋กœ ์ง€์›ํ•œ๋‹ค. ํ•˜์ง€๋งŒ ์ด๊ฑด ์œ ๋„๋˜๋Š” ๋‹ค๋ฅธ ํด๋ž˜์Šค์— ์˜ํ•˜์—ฌ, ์†์ˆ˜ ์ฝ”๋”ฉ์ด ๋˜์–ด์•ผ ํ•œ๋‹ค. ์ฆ‰, ์œ„์˜ ๊ฒฝ์šฐ๋ผ๋ฉด, StirngValue ํด๋ž˜์Šค์—์„œ addReference, removeReference ๋ฅผ ํ˜ธ์ถœํ•˜๋ฉด์„œ, ์ผ์ผ์ด ์ฝ”๋”ฉํ•ด ์ฃผ์–ด์•ผ ํ•œ๋‹ค. ์ด๊ฒƒ์€ ์žฌ์‚ฌ์šฉ ํด๋ž˜์Šค๋กœ์„œ ๋ณด๊ธฐ ์•Š์ข‹์€๋ฐ, ์ด๊ฒƒ์„ ์–ด๋–ป๊ฒŒ ์ž๋™ํ™” ํ• ์ˆ˜๋Š” ์—†์„๊นŒ? C++๋Š” ์ด๋Ÿฐ ์žฌ์‚ฌ์šฉ์„ ์ง€์›ํ• ์ˆ˜ ์žˆ์„๊นŒ.

์œ ๋„ ๋ฐ›์€ ํด๋ž˜์Šค์—์„œ ์ฐธ์กฐ ์นด์šดํ„ฐ์— ๊ด€๋ จํ•œ ์ฝ”๋“œ๋ฅผ ์—†์• ๊ธฐ, ๋ง์ฒ˜๋Ÿผ ์‰ฌ์šด ์ผ์€ ์•„๋‹Œ๊ฒƒ ๊ฐ™๋‹ค. ๊ฑฐ๊ธฐ์—๋‹ค๊ฐ€ String๊ฐ™์€ ํ˜•์˜ ๊ตฌํ˜„์„ ์œ„ํ•ด์„œ๋Š” non-const operator[]์— ๋”ฐ๋ฅธ ๊ณต์œ  ์—ฌ๋ถ€๊นŒ์ง€ ๋”ฐ์ ธ ์ค˜์•ผ ํ•˜์ง€ ๋”์šฑ ๋ณต์žกํ•ด ์ง€๋Š” ๋ฌธ์ œ์ด๋‹ค. ํ˜„์žฌ String์˜ ๊ฐ’์„ ๋ณด๊ด€ํ•˜๋Š”๊ฒƒ์€ StringValue์ธ๋ฐ ์ด๋ ‡๊ฒŒ ํ‘œํ˜„๋˜์–ด ์žˆ๋‹ค.

~cpp 
class String {
private:
  struct StringValue: public RCObject { ... };
  StringValue *value;                // ์ด String์˜ ๊ฐ’
  ...
};
StringValue ๊ฐ์ฒด์˜ refCount์˜ ์ฆ๊ฐ์„ ์œ„ํ•ด์„œ๋Š” ์ƒ๋‹นํžˆ ๋งŽ์€ ์–‘์˜ ์ฝ”๋”ฉ์ด ๋“ค์–ด๊ฐ€์•ผ ํ• ๊ฒƒ์ด๋‹ค. ๋ณต์‚ฌํ• ๋•Œ, ์žฌ ํ• ๋‹น ๋ฐ›์„๋•Œ, ๊ทธ๋ฆฌ๊ณ  ํ•ด๋‹น ๊ฐ’์ด ํŒŒ๊ดด๋˜์–ด ์งˆ๋•Œ, ์ด๋Ÿฐ ๋ชจ๋“ ๊ฒƒ์„ ์ž๋™ํ™” ์‹œํ‚ค๋Š” ๊ฒƒ์ด ์ด๋ฒˆ ์žฅ์˜ ๋ชฉ์ ์ด๋‹ค. ์—ฌ๊ธฐ์„œ StringValue๋ฅผ ์ „์žฅ์— ์–ธ๊ธ‰ํ–ˆ๋˜ ์Šค๋งˆํŠธ ํฌ์ธํ„ฐ ๊ธฐ์ˆ ์„ ์ ์šฉํ•ด์„œ ์ด๋Ÿฐ ์ฐธ์กฐ ์„ธ๊ธฐ์— ๊ด€ํ•ด์„œ ์žฌ์‚ฌ์šฉ์„ ๋„˜์–ด ์ž๋™ํ™”๋ฅผ ์‹œ์ผœ ๋ณด์ž.

์Šค๋งˆํŠธ ํฌ์ธํ„ฐ์— ๋Œ€ํ•œ ์„ค๋ช…์€ ๋„ˆ๋ฌด ๋ฐฉ๋Œ€ํ•˜๋‹ค. ํ•˜์ง€๋งŒ ์—ฌ๊ธฐ RCObject๋ฅผ ๊ฐ€๋ฆฌํ‚ฌ ์Šค๋งˆํŠธ ํฌ์ธํ„ฐ๊ฐ€ ๊ฐ€์ง€๊ณ  ์žˆ์„ ๋Šฅ๋ ฅ์€ ๋ฉค๋ฒ„ ์„ ํƒ(->), ์—ญ์ฐธ์กฐ(deferencing, *) ์—ฐ์‚ฐ์ž ์ •๋„๋งŒ ์žˆ์œผ๋ฉด ์ถฉ๋ถ„ํ•˜๋‹ค. ๋ฌผ๋ก  ๋ณต์‚ฌ๋‚˜, ์ƒ์„ฑ์€ ๊ธฐ๋ณธ์ด๊ณ  ๋ง์ด๋‹ค. ์ฐธ์กฐ ์„ธ๊ธฐ๋ฅผ ์œ„ํ•œ ์Šค๋งˆํŠธ ํฌ์ธํ„ฐ ํ…œํ”Œ๋ฆฟ์„ RCPtr์ด๋ผ๊ณ  ๋ช…๋ช…ํ•˜๊ณ , ๊ธฐ๋ณธ์ ์ธ ๋ผˆ๋Œ€๋ฅผ ๋‹ค์Œ๊ณผ ๊ฐ™์ด ๊ตฌ์„ฑํ•œ๋‹ค.

~cpp 
// T ๊ฐ์ฒด๋ฅผ ๊ฐ€๋ฆฌํ‚ค๊ธฐ ์œ„ํ•œ ์Šค๋งˆํŠธ ํฌ์ธํ„ฐ ํด๋ž˜์Šค ํ…œํ”Œ๋ฆฟ
// ์—ฌ๊ธฐ์—์„œ T๋Š” RCObject๋‚˜, ์ด๊ฒƒ์„ ์ƒ์† ๋ฐ›๋Š” ํด๋ž˜์Šค์ด๋‹ค.
template<class T>
class RCPtr {
public:
    RCPtr(T* realPtr = 0);
    RCPtr(const RCPtr& rhs);
    ~RCPtr();
    RCPtr& operator=(const RCPtr& rhs);
    T* operator->() const;              // Item 28 ์ฐธ๊ณ 
    T& operator*() const;               // Item 28 ์ฐธ๊ณ 
private:
    T *pointee;                         // ์›๋ž˜์˜ ํฌ์ธํ„ฐ๋ฅผ ๊ฐ€๋ฆฌํ‚ค๊ธฐ์œ„ํ•œ
                                        // ๋”๋ฏธ(dumb) ํฌ์ธํ„ฐ pointer this
    void init();                        // ๋ณดํ†ต์˜ ์ดˆ๊ธฐํ™” ๋ฃจํ‹ด
};
์œ„์—์„œ ์–ธ๊ธ‰ํ–ˆ๋“ฏ์ด, ํ…œํ”Œ๋ฆฟ์˜ ๋ชฉ์ ์€ RCObject์˜ refCount์˜ ์ฆ๊ฐ์„ ์ž๋™ํ™”ํ•˜๊ธฐ ์œ„ํ•œ ๊ฒƒ์ด๋‹ค. ์˜ˆ๋ฅผ ๋“ค์–ด์„œ, RCPtr์ด ์ƒ์„ฑ๋ ๋•Œ ๊ฐ์ฒด๋Š” ์ฐธ์กฐ ์นด์šดํ„ฐ๋ฅผ ์ฆ๊ฐ€์‹œํ‚คํ‚ค ์›ํ•  ๊ฒƒ์ด๊ณ , RCPtr์˜ ์ƒ์„ฑ์ž๊ฐ€ ์ด๋ฅผ ์ˆ˜ํ–‰ํ•˜๊ธฐ ๋•Œ๋ฌธ์— ์ด์ „์ฒ˜๋Ÿผ ์ผ์ผ์ด ์ฝ”๋”ฉํ•  ํ•„์š”๊ฐ€ ์—†์„ ๊ฒƒ์ด๋‹ค. ์ผ๋‹จ, ์ƒ์„ฑ ๋ถ€๋ถ„์—์„œ์˜ ์ฆ๊ฐ€๋งŒ์„ ์ƒ๊ฐํ•ด ๋ณธ๋‹ค.

~cpp 
template<class T>
RCPtr<T>::RCPtr(T* realPtr): pointee(realPtr)
{
    init();
}
template<class T>
RCPtr<T>::RCPtr(const RCPtr& rhs): pointee(rhs.pointee)
{
    init();
}
template<class T>
void RCPtr<T>::init()
{
    if (pointee == 0) {                // ๋งŒ์•ฝ ๋”๋ฏธ(dumb)ํฌ์ธํ„ฐ๊ฐ€ null์ด๋ผ๋ฉด
        return;                          
    }
    if (pointee->isShareable() == false) {      // ๊ณต์œ ๋ฅผ ํ—ˆ์šฉํ•˜์ง€ ์•Š์œผ๋ฉด
        pointee = new T(*pointee);              // ๋ณต์‚ฌ๋ฅผ ํ•œ๋‹ค.     
    }
    pointee->addReference();             // ์ƒˆ๋กœ์šด ์ฐธ์กฐ ์นด์šดํ„ฐ๋ฅผ ์˜ฌ๋ฆฐ๋‹ค.
}
๊ณตํ†ต๋œ ์ฝ”๋“œ๋ฅผ init()์œผ๋กœ ๋ฌถ์—ˆ๋Š”๋ฐ, ์ด๋Ÿฐ ๊ฒฝ์šฐ ์ •ํ™•ํžˆ ๋™์ž‘ํ•˜์ง€ ์•Š์„์ˆ˜ ์žˆ๋‹ค. initํ•จ์ˆ˜๊ฐ€ ์ƒˆ๋กœ์šด ๋ณต์‚ฌ๋ณธ์„ ํ•„์š”๋กœ ํ• ๋•Œ๊ฐ€ ๊ทธ๊ฒƒ์ธ๋ฐ, ๊ณต์œ ๋ฅผ ํ—ˆ์šฉํ•˜์ง€ ์•Š์„ ๊ฒฝ์šฐ์— ๋ณต์‚ฌํ•˜๋Š” ๋ฐ”๋กœ ์ด๋ถ€๋ถ„,

~cpp 
pointee = new T(*pointee);
opintee์˜ ํ˜•์€ pointer-to-T์ด๋‹ค. ์•„๋งˆ Stringํด๋ž˜์Šค์—์„œ๋Š” ์ด๊ฒƒ์ด String::StringValue์˜ ๋ณต์‚ฌ ์ƒ์„ฑ์ž ์ผ๊ฒƒ์ธ๋ฐ, ์šฐ๋ฆฌ๋Š” StringValue์˜ ๋ณต์‚ฌ ์ƒ์„ฑ์ž๋ฅผ ์„ ์–ธํ•ด ์ฃผ์ง€ ์•Š์•˜๋‹ค. ๊ทธ๋ž˜์„œ ์ปดํŒŒ์ผ๋Ÿฌ๊ฐ€ ์ž๋™์ ์œผ๋กœ C++๋‚ด์˜ ๊ทœ์น™์„ ์ง€ํ‚ค๋ฉด์„œ ๋ณต์‚ฌ ์ƒ์„ฑ์ž๋ฅผ ๋งŒ๋“ค์–ด ๋‚ผ๊ฒƒ์ด๋‹ค. ๊ทธ๋ž˜์„œ ๋ณต์‚ฌ๋Š” ์˜ค์ง StringValue์˜ data ํฌ์ธํ„ฐ์— ํ•ด๋‹นํ•˜๋Š” ๊ฒƒ๋งŒ์ด ์ด๋ฃจ์–ด ์งˆ๊ฒƒ์ด๋‹ค. data๋Š” ๋ณต์‚ฌ๊ฐ€ ์•„๋‹Œ ์ฐธ์กฐ๊ฐ€ ํ–‰ํ•ด ์งˆ๊ฒƒ์ด๋‹ค. ์ด๋Ÿฌํ•œ ์ด์œ ๋กœ ์ดํ›„, ์ž‘์„ฑ๋˜๋Š” ๋ชจ๋“  ํ‹€๋ž˜์Šค์— ๋ณต์‚ฌ ์ƒ์„ฑ์ž๊ฐ€ ์ถ”๊ฐ€๋˜์–ด์•ผ ํ•œ๋‹ค.

RCPtr<T>์˜ ์ •ํ™•ํ•œ ์ˆ˜ํ–‰์„ ์œ„ํ•ด์„œ T๋Š” ๋ณต์‚ฌ ์ƒ์„ฑ์ž๋ฅผ ๊ฐ€์ง€๊ณ  ์žˆ์–ด์„œ, ๋…๋ฆฝ์ ์œผ๋กœ ๋ณต์‚ฌ๋ฅผ ์ˆ˜ํ–‰ํ•ด์•ผ ํ•œ๋‹ค.(๋‹ค๋ฅธ ๋ง๋กœ deep copy๊ฐ€ ์ด๋ฃจ์–ด ์ ธ์•ผ ํ•œ๋‹ค.)

~cpp 
class String {
private:
    struct StringValue: public RCObject {
        StringValue(const StringValue& rhs);
        ...
    };
    ...
};
String::StringValue::StringValue(const StringValue& rhs)
{
    data = new char[strlen(rhs.data) + 1];      // ์ด ๋ถ€๋ถ„์ด deep copy์˜ 
    strcpy(data, rhs.data);                     // ์ˆ˜ํ–‰ ๋ถ€๋ถ„์ด๋‹ค.
}
์ด๋Ÿฌํ•œ deep-copy ๋ณต์‚ฌ ์ƒ์„ฑ์ž์˜ ์กด์žฌ๋Š” RCPtr<T>๊ฐ€ ๊ฐ€๋ฆฌํ‚ค๋Š” T์— ๊ตญํ•œ ๋˜๋Š” ๊ฒƒ์ด ์•„๋‹ˆ๋ผ, RCObject๋ฅผ ์ƒ์†ํ•˜๋Š” ํด๋ž˜์Šค์—๋„ ์ง€์›๋˜์–ด์•ผ ํ•œ๋‹ค. ์‚ฌ์‹ค RCPtr ๊ฐ์ฒด ๊ด€์ ์—์„œ ๋ณผ๋•Œ๋Š” ์˜ค์ง ์ฐธ์กฐ ์„ธ๊ธฐ๋ฅผ ํ•˜๋Š” ๊ฐ์ฒด๋ฅผ ๊ฐ€๋ฆฌํ‚ค๊ธฐ๋งŒ ํ•˜๋Š” ๊ด€์ ์—์„œ ์ด๊ฒƒ์€ ๋‚ฉ๋“ํ• ์ˆ˜ ์—†๋Š” ์‚ฌ์‹ค์ผ์ง€ ๋ชจ๋ฅธ๋‹ค. ๊ทธ๋ ‡์ง€๋งŒ ์ด๋Ÿฌํ•œ ์‚ฌ์‹ค์ด ๊ผญ ๋ฌธ์„œํ™” ๋˜์–ด ํด๋ผ์ด์–ธํŠธ์—๊ฒŒ ์•Œ๋ ค์ ธ์•ผ ํ•œ๋‹ค.

๋งˆ์ง€๋ง‰ RCPtr<T>์—์„œ์˜ ๊ฐ€์„ฑ์€ T์— ๋Œ€ํ•œ ํ˜•์— ๊ด€ํ•œ ๊ฒƒ์ด๋‹ค. ์ด๊ฒƒ์€ ํ™•์‹คํ•˜๊ฒŒ ๋ณด์ธ๋‹ค. ๊ฒฐ๊ตญ pointee๋Š” T* ํ˜•์œผ๋กœ ์„ ์–ธ๋˜๋Š”๋ฐ, pointee๋Š” ์•„๋งˆ T๋กœ ๋ถ€ํ„ฐ ์œ ๋„๋œ ํด๋ž˜์Šค ์ผ์ง€ ๋ชจ๋ฅธ๋‹ค. ์˜ˆ๋ฅผ ๋“ค์ž๋ฉด ๋งŒ์•ฝ ๋‹น์‹ ์ด SepcialStringValue๋ผ๋Š” String::StringValue์—์„œ ์œ ๋„๋œ ํด๋ž˜์Šค๊ฐ€ ์กด์žฌ ํ•œ๋‹ค๋ฉด

~cpp 
class String {
private:
  struct StringValue: public RCObject { ... };
  struct SpecialStringValue: public StringValue { ... };
  ...
};
์ผ๋‹จ ์šฐ๋ฆฌ๋Š” String์— RCPtr<StingValue> ํฌ์ธํ„ฐ๋กœ SpecialStringValue ๊ฐ์ฒด๋ฅผ ๊ฐ€๋ฆฌํ‚ค๋Š” ์ƒํƒœ๋กœ ๋งŒ๋“ค์–ด์„œ ํฌํ•จ์‹œํ‚ฌ์ˆ˜ ์žˆ๋‹ค. ์ด๋Ÿฌํ•œ ๊ฒฝ์šฐ์— ์šฐ๋ฆฌ๊ฐ€ ์›ํ•˜๋Š” init๊ฐ€ ๋˜์ง€ ์•Š๋Š”๋‹ค.

~cpp 
pointee = new T(*pointee);      // T ๋Š” StringValue์ด๋‹ค, ํ•˜์ง€๋งŒ 
                                // pointee๊ฐ€ ๊ฐ€๋ฆฌํ‚ค๋Š”๊ฑด SpecialStringVale์ด๋‹ค.
์ฆ‰, SepcialStringValue์˜ ๋ณต์‚ฌ ์ƒ์„ฑ์ž๋ฅผ ๋ถ€๋ฅด๊ธธ ์›ํ•˜๋Š”๋ฐ, StringValue์˜ ๋ณต์‚ฌ ์ƒ์„ฑ์ž๊ฐ€ ๋ถˆ๋ฆฐ๋‹ค. ์šฐ๋ฆฌ๋Š” ์ด๋Ÿฌํ•œ ๊ฒƒ์„ ๊ฐ€์ƒ ๋ณต์‚ฌ ์ƒ์„ฑ์ž๋ฅผ ์จ์„œ (Item 25 ์ฐธ๊ณ ) ํ• ์ˆ˜ ์žˆ๋‹ค. ํ•˜์ง€๋งŒ, ์ด๊ฒƒ์€ ๋””์ž์ธ๋•Œ ์˜๋„ํ•œ ๊ฒƒ์ด ์•„๋‹ˆ๊ธฐ ๋•Œ๋ฌธ์—, ์ด๋Ÿฌํ•œ ๊ฒฝ์šฐ์— ๋Œ€ํ•ด์„œ๋Š” ๋‚ฉ๋“ํ• ์ˆ˜๊ฐ€ ์—†๋‹ค.

์ด์ œ, ์ƒ์„ฑ์ž์— ๊ด€ํ•œ ๋‚ด์šฉ์„ ๋ฒ—์–ด๋‚˜, ํ• ๋‹น(assignment) ์—ฐ์‚ฐ์ž์— ๊ด€ํ•œ ๋‚ด์šฉ์„ ๋‹ค๋ฃฌ๋‹ค. ํ• ๋‹น ๊ฒฝ์šฐ๋„ ๊ณต์œ ์˜ ๊ฒฝ์šฐ๋ฅผ ์ƒ๊ฐํ•ด์•ผ ํ•˜๊ธฐ ๋•Œ๋ฌธ์— ๊นŒ๋‹ค๋กญ๊ฒŒ ๋ ์ˆ˜ ์žˆ๋Š”๋ฐ, ๋‹คํ–‰์Šค๋Ÿฝ๊ฒŒ ์ด๋ฏธ ๊ทธ๋Ÿฌํ•œ ๊ณผ์ •์€ init์— ๊ณตํ†ต์ ์œผ๋กœ ๋“ค์–ด ์žˆ๊ธฐ ๋•Œ๋ฌธ์— ์ฝ”๋“œ๊ฐ€ ๊ฐ„๋‹จํ•ด ์ง„๋‹ค.

~cpp 
template<class T>
RCPtr<T>& RCPtr<T>::operator=(const RCPtr& rhs)
{
    if (pointee != rhs.pointee) {       // ๋‘˜์ด ๊ฐ™์€ ๊ฐ์ฒด๋ฅผ ๊ณต์œ ํ•˜๋ฉด 
                                        // ํ• ๋‹น์„ ์ƒ๋žตํ•œ๋‹ค.
        if (pointee) {
            pointee->removeReference(); // ํ˜„์žฌ ์ฐธ์กฐ ๊ฐ์ฒด ์ฐธ์กฐ ์นด์šดํ„ฐ ๊ฐ์†Œ or ํŒŒ๊ดด
        }
        pointee = rhs.pointee;          // ๊ฐ€๋ฆฌํ‚ค๋Š” ์ฐธ์กฐ๋ฅผ ์˜ฎ๊ธด๋‹ค.
        init();                         // ๊ณต์œ ๊ฐ€ ๋ถˆ๊ฐ€๋Šฅ ํ• ๊ฒฝ์šฐ๋Š” ์ž๋ฃŒ๋ฅผ 
                                        // ์ƒ์„ฑํ•˜๊ณ , ์–ด์ฐŒ๋˜์—ˆ๋“  ์ฐธ์กฐ๋ฅผ ์ฆ๊ฐ€
    }
    return *this;
}
ํŒŒ๊ดด์ž๋А ใ„ด๊ฐ„๋‹จํ•˜๋‹ค. ๊ทธ๋ƒฅ ์ฐธ์กฐ ์นด์šดํ„ฐ ํ•˜๋‚˜๋ฅผ ๊ฐ์†Œํ•˜๋ฉด ๋œ๋‹ค.

~cpp 
template<class T>
RCPtr<T>::~RCPtr()
{
    if (pointee)pointee->removeReference(); // ์•Œ์•„์„œ ํŒŒ๊ดด๋จ
}
์ฃผ์„์—์„œ์™€ ๊ฐ™์ด removeReference() ๋Š” ์ฐธ์กฐ ์นด์šดํ„ฐ๊ฐ€ 0์ด๋˜๋ฉด ํ•ด๋‹น ๊ฐ์ฒด๋ฅผ ํŒŒ๊ดดํ•œ๋‹ค.

๋งˆ์ง€๋ง‰์œผ๋กœ, ์ด์ œ ์Šค๋งˆํŠธ ํฌ์ธํ„ฐ์˜ ๋ฐฑ๋ฏธ์ธ ํฌ์ธํ„ฐ ํ‰๋‚ด๋‚ด๋Š” ๋ถ€๋ถ„์ด๋‹ค.

~cpp 
template<class T>
T* RCPtr<T>::operator->() const { return pointee; }
template<class T>
T& RCPtr<T>::operator*() const { return *pointee; }

1.7. Putting it All Together : ์ง€๊ธˆ๊นŒ์ง€์˜ ๋ฐฉ๋ฒ•๋ก  ์ •๋ฆฌ

๋“œ๋””์–ด ๋์ด๋‹ค. ์Šค๋งˆํŠธ ํฌ์ธํ„ฐ์™€, ๊ธฐ์ดˆ ํด๋ž˜์Šค๋กœ ์ด์ œ ์žฌ์‚ฌ์šฉ ๊ฐ€๋Šฅํ•œ ์ฐธ์กฐ์„ธ๊ธฐ๋ฅผ ๊ตฌํ˜„ํ• ์ˆ˜ ์žˆ๋‹ค. ์ง€๊ธˆ๊นŒ์ง€ ํ•˜๋‚˜ํ•˜๋‚˜ ๋งŒ๋“ค์–ด์˜จ ๊ฒƒ์„ ์ด๋ฒˆ์— ๋ชจ๋‘ ํ•ฉ์ณ์„œ ํ‘œํ˜„ํ•ด ๋ณด์ž.

๋จผ์ €, RCObject์™€ RCPtr์„ ์ด์šฉํ•ด์„œ String์— ๊ตฌํ˜„ํ•œ ์ฐธ์กฐ์„ธ๊ธฐ์˜ ๊ฐœ๋…๋„๋ฅผ ์•Œ์•„ ๋ณด์ž.


์ด๋Ÿฌํ•œ ๊ฐœ๋žต๋„๋Š” ๋‹ค์Œ๊ณผ ๊ฐ™์€ ํด๋ž˜์Šค๋กœ ์ •์˜ ๋˜์–ด ์ง„๋‹ค.

~cpp 
template<class T>                       // T๋ฅผ ๊ฐ€๋ฆฌํ‚ค๋Š” ์Šค๋งˆํŠธ ํฌ์ธํ„ฐ
class RCPtr {                           // ์—ฌ๊ธฐ์—์„œ T๋Š” RCObject๋ฅผ ์ƒ์†ํ•ด์•ผ ํ•œ๋‹ค.
public:                                 
    RCPtr(T* realPtr = 0);              // ์ดˆ๊ธฐํ™”, ์ƒ์„ฑ์ž ๊ฒธ(๊ธฐ๋ณธ๊ฐ’ ๋•Œ๋ฌธ์—)
    RCPtr(const RCPtr& rhs);            // ๋ณต์‚ฌ ์ƒ์„ฑ์ž
    ~RCPtr();

    RCPtr& operator=(const RCPtr& rhs); // ํ• ๋‹น ์—ฐ์‚ฐ์ž

    T* operator->() const;              // ํฌ์ธํ„ฐ ํ‰๋‚ด
    T& operator*() const;               // ํฌ์ธํ„ฐ ํ‰๋‚ด

private:
    T *pointee;                         // ๋”๋ฏธ(dumb) ํฌ์ธํ„ฐ
    void init();                        // ์ฐธ์กฐ ์„ธ๊ธฐ ์ดˆ๊ธฐํ™”(์ฐธ์กฐ ์นด์šดํ„ฐ ์ฆ๊ฐ€)
};

class RCObject {                        // ์ฐธ์กฐ์„ธ๊ธฐ์˜ ๊ธฐ์ดˆ ํด๋ž˜์Šค
public:
    void addReference();                // ์ฐธ์กฐ ์นด์šดํ„ฐ ์ฆ๊ฐ€
    void removeReference();             // ์ฐธ์กฐ ์นด์šดํ„ฐ ๊ฐ์†Œ

    void markUnshareable();             // ๊ณต์œ  ๋ง‰๊ธฐ
    bool isShareable() const;           // ๊ณต์œ  ํ•ด๋„ ๋˜๋Š”๊ฐ€ ๋ฌป๊ธฐ
    bool isShared() const;              // ํ˜„์žฌ ๊ณต์œ  ์ค‘์ธ๊ฐ€ ๋ฌป๊ธฐ

protected:
    RCObject();                         // ์ƒ์„ฑ์ž
    RCObject(const RCObject& rhs);      // ๋ณต์‚ฌ ์ƒ์„ฑ์ž
    RCObject& operator=(const RCObject& rhs);   // ํ• ๋‹น ์—ฐ์‚ฐ์ž
    virtual ~RCObject() = 0;            // ์ˆœ์ˆ˜ ๊ฐ€์ƒ ํŒŒ๊ดด์ž
                                        // (์ˆœ์ˆ˜์ง€๋งŒ ๋ฐ˜๋“œ์‹œ ๊ตฌํ˜„๋˜์–ด์•ผ ํ•œ๋‹ค.)
private:
    int refCount;                       // ์ฐธ์กฐ ์นด์šดํ„ฐ
    bool shareable;                     // ๊ณต์œ  ํ”Œ๋ž˜์Šค(๊ณต์œ  ํ—ˆ์šฉ ์—ฌ๋ถ€)
};

// ์ฒ˜์Œ ๋ณด๋‹ค ๋งŽ์ด ๋น ์ง„ String๊ฐ™์ง€ ์•Š์€๊ฐ€? ^^;
class String{                           // application ๊ฐœ๋ฐœ์ž๊ฐ€ ์‚ฌ์šฉํ•˜๋Š” ํด๋ž˜์Šค
public:
    String(const char *value = "");     // ์ƒ์„ฑ์ž, ์ดˆ๊ธฐํ™”

    const char& operator[](int index) const;    // const operator[] 
    char& operator[](int index);                // non-const operator[]

private:
    // ํด๋ž˜์Šค ๋‚ด๋ถ€์— ํ‘œํ˜„์„ ์œ„ํ•œ ๋ฌธ์ž์—ด ๊ฐ’
    struct StringValue: public RCObject {
        char *data;                             // ๋ฐ์ดํ„ฐ ํฌ์ธํ„ฐ

        StringValue(const char *initValue);     // ์ƒ์„ฑ์ž
        StringValue(const StringValue& rhs);    // ๋ณต์‚ฌ ์ƒ์„ฑ์ž
        void init(const char *initValue);       // ์ฐธ์กฐ ์„ธํŒ…
        ~StringValue();                         // ํŒŒ๊ดด์ž
    };

    RCPtr<StringValue> value;                   // StringValue์˜ ์Šค๋งˆํŠธ ํฌ์ธํ„ฐ                
};
๋Œ€๋‹ค์ˆ˜์˜ ๋ถ€๋ถ„์—์„œ ์šฐ๋ฆฌ๋Š” ์ด๋ฏธ ๋งŒ๋“ค ๊ฒƒ์„ ๊ทธ๋Œ€๋กœ ์ผ๋‹ค. ๊ทธ๋ž˜์„œ ํŠน๋ณ„ํžˆ ์‹ ๊ฒฝ์จ์•ผ ํ• ๊ฒƒ์€ ์—†๋‹ค. ์œ ์˜ ํ•ด์•ผ ํ• ๊ฒƒ์€ String::StringValue์— ๋ณด์ด๋Š” init ํ•จ์ˆ˜์—์„œ ์‹ ๊ฒฝ ์จ์•ผ ํ•œ๋‹ค.

์ž ์ค‘์š”ํ•œ ์ด ์•„์ดํ…œ์„ ์ฒ˜์Œ ์‹œ์ž‘ํ• ๋•Œ Stringํด๋ž˜์Šค์˜ ์ธํ„ฐํŽ˜์ด์Šค์™€ ๋‹ค๋ฅธ ์ ์€, ๋ณต์‚ฌ ์ƒ์„ฑ์ž๋Š” ์–ด๋”” ์žˆ๋Š”๊ฐ€? ํ• ๋‹น(assignment) ์—ฐ์‚ฐ์ž๋Š” ์–ด๋”” ์žˆ๋Š”๊ฐ€? ํŒŒ๊ดด์ž๋Š” ์–ด๋”” ์žˆ๋Š”๊ฐ€? ์ •๋ง ์‹ฌ๊ฐํ•œ ์ž˜๋ชป์œผ๋กœ ๋ณด์ด์ง€ ์•Š๋Š”๊ฐ€?ํ•˜์ง€๋งŒ ๊ฑฑ์ • ํ• ๊ฒƒ์—†๋‹ค. ์‚ฌ์‹ค ์ด ๊ตฌํ˜„ ํ˜•ํƒœ๋Š” ์™„์ „ํ•˜๋‹ค. ๋งŒ์•ฝ ์ด์œ ๋ฅผ ๋ชจ๋ฅด๊ฒ ์œผ๋ฉด, C++์„ ์ข€๋” ๊ณต๋ถ€ํ•ด๋ผ. (์ž‘์„ฑ์ž์ฃผ:์ด๋Ÿฐ ๊ฑด๋ฐฉ์ง„ ๋งํˆฌ๋กœ ๋ฐ”๊พธ๋Š”..)

์ด์ œ๋Š” ์ด๋Ÿฌํ•œ ํ•จ์ˆ˜๋“ค์ด ๋”์ด์ƒ ํ•„์š” ์—†๋‹ค. ๋ฌผ๋ก  ์•„์ง String๊ฐ์ฒด์˜ ๋ณต์‚ฌ๋Š” ์ง€์›๋œ๋‹ค. ๋ณต์‚ฌ๋Š” ์ฐธ์กฐ์„ธ๊ธฐ๋ฅผ ๊ธฐ๋ฐ˜ํ•œ StringValue๊ฐ์ฒด์—์„œ ์ด๋ฃจ์–ด ์ง€๋Š” ๊ฒƒ์œผ๋กœ, Stringํด๋ž˜์Šค๋Š” ๋‹ค์ด์„ฑ ์ด๋Ÿฐ ๊ฒƒ์„ ์œ„ํ•ด์„œ ํ•œ์ค„๋„ ์ฝ”๋”ฉํ•  ํ•„์š”๊ฐ€ ์—†๋‹ค. ๊ทธ ์ด์œ ๋Š” ์ด์ œ ์ปดํŒŒ์ผ๋Ÿฌ๊ฐ€ ๋งŒ๋“ค ๋ณต์‚ฌ ์ƒ์„ฑ์ž์—๊ฒŒ ๋ชจ๋‘ ๋งก๊ฒจ ๋ฒ„๋ฆฌ๋ฉด ๊ธฐํƒ€์˜ ๊ฒƒ๋“ค์€ ๋ชจ๋‘ ์ž๋™์œผ๋กœ ์ƒ์„ฑ๋œ๋‹ค. RCPtr์€ ์Šค๋งˆํŠธ ํฌ์ธํ„ฐ์ด๋‹ค. ๊ทธ์‚ฌ์‹ค์„ ๊ธฐ์–ตํ•˜๋ผ, ๋ณต์‚ฌ์‹œ ๋ชจ๋‘ ์Šค๋งˆํŠธ ํฌ์ธํ„ฐ๊ฐ€ ์ฐธ์กฐ๋ฅผ ๊ด€๋ฆฌํ•ด์ค€๋‹ค.

์ž, ์ด์ œ ์ „์ฒด์˜ ๊ตฌํ˜„์ฝ”๋“œ๋ฅผ ๋ณด์—ฌ์ค„ ์ฐจ๋ก€์ด๋‹ค. ๋จผ์ € RCObject์˜ ๊ตฌํ˜„ ์ƒํ™ฉ์ด๋‹ค.

~cpp 
RCObject::RCObject()
: refCount(0), shareable(true) {}

RCObject::RCObject(const RCObject&)
: refCount(0), shareable(true) {}

RCObject& RCObject::operator=(const RCObject&)
{ return *this; }

RCObject::~RCObject() {}

void RCObject::addReference() { ++refCount; }

void RCObject::removeReference() 
{ if (--refCount == 0) delete this; }

void RCObject::markUnshareable() { shareable = false; }

bool RCObject::isShareable() const { return shareable; }

bool RCObject::isShared() const { return refCount > 1; }
๋‹ค์Œ์€ RCPtr์˜ ๊ตฌํ˜„ ์ฝ”๋“œ์ด๋‹ค.

~cpp 
template<class T>
void RCPtr<T>::init()
{
    if (pointee == 0) return;
    if (pointee->isShareable() == false) {
        pointee = new T(*pointee);
    }
    pointee->addReference();
}

template<class T>
RCPtr<T>::RCPtr(T* realPtr)
: pointee(realPtr)
{ init(); }

template<class T>
RCPtr<T>::RCPtr(const RCPtr& rhs)
: pointee(rhs.pointee)
{ init(); }

template<class T>
RCPtr<T>::~RCPtr() 
{ if (pointee)pointee->removeReference(); }

template<class T>
RCPtr<T>& RCPtr<T>::operator=(const RCPtr& rhs)
{
    if (pointee != rhs.pointee) {
        if (pointee) pointee->removeReference();
        pointee = rhs.pointee;
        init();
    }
    return *this;
}

template<class T>
T* RCPtr<T>::operator->() const { return pointee; }

template<class T>
T& RCPtr<T>::operator*() const { return *pointee; }
๋‹ค์Œ์€ String::StringValue์˜ ๊ตฌํ˜„ ์ฝ”๋“œ์ด๋‹ค.

~cpp 
void String::StringValue::init(const char *initValue)   // deep copy๋ฅผ ์œ„ํ•ด์„œ 
{
    data = new char[strlen(initValue) + 1];             // ์ž๋ฃŒ๋ฅผ ๋ณต์‚ฌํ•˜๋Š”
    strcpy(data, initValue);                            // ๊ณผ์ • ๊ฐœ๋ฐœ์ž๊ฐ€ ์‹ ๊ฒฝ์จ์•ผ ํ•œ๋‹ค.
}

String::StringValue::StringValue(const char *initValue) // ๋ณต์‚ฌ ์ƒ์„ฑ์ž(์ž๋ฃŒ ๊ธฐ๋ฐ˜)
{ init(initValue); }

String::StringValue::StringValue(const StringValue& rhs)// ๋ณต์‚ฌ ์ƒ์„ฑ์ž(๊ฐ™์€ ๊ฐ์ฒด ๊ธฐ๋ฐ˜)
{ init(rhs.data); }

String::StringValue::~StringValue()
{ delete [] data; }

์ด์ œ ๋ชจ๋“ ๊ฑธ ๊ฐ์‹ธ๋Š” String ํด๋ž˜์Šค์˜ ๊ตฌํ˜„ ์ฝ”๋“œ์ด๋‹ค.

~cpp 
String::String(const char *initValue) 
: value(new StringValue(initValue)) {}      // value๋Š” RCPtr<StringValue> ์ด๋‹ค.

const char& String::operator[](int index) const
{ return value->data[index]; }

char& String::operator[](int index)
{
    if (value->isShared()) {
        value = new StringValue(value->data);
    }
    value->markUnshareable();
    return value->data[index];
}
์ด Stringํด๋ž˜์Šค๋ฅผ ์œ„ํ•œ ์ฝ”๋“œ์™€, ๊ทธ๋ƒฅ ๋”๋ฏธ(dumb)ํฌ์ธํ„ฐ๋ฅผ ์‚ฌ์šฉํ•œ ํด๋ž˜์Šค(์ฒ˜์Œ์— ์ฐธ์กฐ์„ธ๊ธฐ ๊ตฌํ˜„ํ•œ๊ฒƒ)์™€๋Š” ๋‘๊ฐ€์ง€์˜ ํฐ ์ฐจ์ด์ ์ด ์žˆ๋‹ค. ์ฒซ๋ฒˆ์งธ๋กœ ์ด ํด๋ž˜์Šค์˜ ์ฝ”๋“œ๊ฐ€ ๊ต‰์žฅํžˆ ์ ๋‹ค๋Š” ์ ์ด๋‹ค. ์ด์œ ๋Š”, RCPtr์ด ์ฐธ์กฐ์„ธ๋Š” ์ž‘์—…์„ ๋ชจ๋‘ ๋งก์•„์„œ ์ด๋‹ค. ๋‘๋ฒˆ์งธ๋กœ๋Š” ์Šค๋งˆํŠธ ํฌ์ธํ„ฐ๋กœ ๊ต์ฒดํ–ˆ์ง€๋งŒ, String์˜ ์ฝ”๋“œ๊ฐ€ ๊ฑฐ์˜ ์œ ์ง€๋œ๋‹ค๋Š” ์ ์ด๋‹ค. ์‚ฌ์‹ค ๋ณ€ํ™”๋Š” operator[]์—์„œ๋งŒ ๊ณต์œ ์˜ ๊ฒฝ์šฐ๋ฅผ ์ฒดํฌํ•˜๋Š” ๋ฃจํ‹ด ๋•Œ๋ฌธ์— ๋ฐ”๋€Œ์—ˆ๋‹ค. ์ด๋ ‡๊ฒŒ ์Šค๋งˆํŠธ ํฌ์ธํ„ฐ๋กœ์„œ ์†์ˆ˜ ํ•ด์•ผํ•˜๋Š” ์ž‘์—…๋“ค์ด ๋งŽ์ด ์ค„์–ด ๋“ ๋‹ค.

๋Œ€๋‹จํ•˜์ง€ ์•Š์€๊ฐ€? ๋ˆ„๊ฐ€ ๊ฐ์ฒด๋ฅผ ์‚ฌ์šฉํ•˜์ง€ ์•Š์„๊นŒ? ๋ˆ„๊ฐ€ ์บก์Аํ™”๋ฅผ ๋ฐ˜๋Œ€ํ• ๊นŒ? ํ•˜์ง€๋งŒ, ์ด๋Ÿฌํ•œ ์‹ ๊ธฐํ•œ String ํด๋ž˜์Šค์— ๊ด€ํ•œ ๊ธฐ๋ฐ˜ ์ƒ๊ฐ์€ ํด๋ผ์ด์–ธํŠธ ์ธก์—์„œ ์ƒˆ๋ถ€์‚ฌํ•ญ์„ ์•Œํ•„์š”๊ฐ€ ์—†์–ด์•ผ ๋ฐ‘์ด ๋‚˜๋Š” ๊ฒƒ์ด๋‹ค. ์•Œ์•„์•ผ ํ• ๊ฒƒ์ด ์—†์„์ˆ˜๋ก ๋” ์ข‹์€ ์ƒํƒœ์ด๋‹ค. ํ˜„์žฌ, String์„ ์“ฐ๋Š” ๊ธฐ๋ณธ ์ธํ„ฐํŽ˜์ด์Šค๋Š” ๋ฐ”๋€๊ฒƒ์ด ์—†๋‹ค. ๋‹จ์ง€ ์ฐธ์กฐ์„ธ๊ธฐ์˜ ๊ธฐ๋Šฅ์ด ์ถ”๊ฐ€๋˜์—ˆ์„ ๋ฟ์ด๋‹ค. ๊ทธ๋ž˜์„œ ํด๋ผ์ด์–ธํŠธ๋Š” ๊ธฐ์กด ์ฝ”๋“œ๋ฅผ ๊ณ ์น  ํ•„์š”๊ฐ€ ์—†๋‹ค. ๋‹จ, ์žฌ ์ปดํŒŒ์ผ(recompile)๊ณผ ์žฌ๋งํฌ(relink) ๊ณผ์ •๋งŒ์ด ๋‚จ์•„ ์žˆ์„ ๊ฒƒ์ด๋‹ค. ์ด๋Ÿฌํ•œ ๋น„์šฉ์€ ์ฐธ์กฐ์„ธ๊ธฐ๊ฐ€ ์ฃผ๋Š” ์ด๋“์— ๋น„ํ•˜๋ฉด ์ •๋ง ์™„์ „ํžˆ ์—†๋Š” ๋น„์šฉ์ด๋‚˜ ๋งˆ์ฐฌ๊ฐ€์ง€์ด๋‹ค. ์บก์Аํ™”๋Š” ์ •๋ง ์ข‹์€๊ฑฐ๋‹ค. (์ž‘์„ฑ์ž์ฃผ:๋ญ์•ผ ์ด ๊ฒฐ๋ก ์€..)

1.8. Adding Reference Counting to Exitsting Classes : ์ฐธ์กฐ ์„ธ๊ธฐ๋ฅผ ์ด๋ฏธ ์กด์žฌํ•˜๋Š” ํด๋ž˜์Šค์— ๋”ํ•˜๊ธฐ

ํœด, ์šฐ๋ฆฌ๋Š” ์ง€๊ธˆ๊นŒ์ง€ ํฅ๋ฏธ๋กœ์šด ํด๋ž˜์Šค์— ๊ด€ํ•ด์„œ ๋…ผ์˜ ํ–ˆ๋Š”๋ฐ, ์ด๋ฒˆ์—๋Š” Widget๊ฐ™์€ ์ด๋ฏธ ์ •์˜๋˜์–ด ์žˆ๋Š” ํด๋ž˜์Šค๋ฅผ ์ „ํ˜€ ๊ฑด๋“œ๋ฆฌ์ง€ ์•Š๊ณ , ์ฐธ์กฐ ์„ธ๊ธฐ๋ฅผ ์ ์šฉ ์‹œํ‚ฌ์ˆ˜๋Š” ์—†์„๊นŒ? ๊ทธ๋Ÿฌ๋‹ˆ๊นŒ. ๋ผ์ด๋ธŒ๋Ÿฌ๋ฆฌ๋ฅผ ๊ณ ์น˜์ง€ ์•Š๊ณ  ๋ง์ด๋‹ค. Widget์— ์ฐธ์กฐ ์„ธ๊ธฐ๋ฅผ ์ ์šฉ ์‹œ์ผœ์•ผ ํ•˜๋Š”๋ฐ, ์•ž์˜ ๋ฐฉ๋ฒ• ์ฒ˜๋Ÿผ RCObject๋ฅผ Widget์ด ์ƒ์† ์‹œํ‚ฌ ๋ฐฉ๋ฒ•์€ ์ „ํ˜€ ์—†๋‹ค. ๊ทธ๋ž˜์„œ RCPtr๋„ ์ ์šฉํ• ์ˆ˜ ์—†๋‹ค. ๋ฐฉ๋ฒ•์ด ์—†๋Š” ๊ฑธ๊นŒ?

๊ฐ„๋‹จํžˆ ๋งํ•ด ์šฐ๋ฆฌ๋Š” ์กฐ๊ธˆ๋งŒ ์šฐ๋ฆฌ์˜ ๋””์ž์ธ์„ ์†๋ด์•ผ ํ•œ๋‹ค. ์ผ๋‹จ ๋งŒ์•ฝ ์šฐ๋ฆฌ์˜ ๊ธฐ์กด ๋””์ž์ธ์ธ String/StringValue๊ด€๊ณ„๋ฅผ ๊ณ ์ˆ˜ํ•˜๋ฉด์„œ Widget์„ ์ ์šฉ ์‹œํ‚ค๋Š” ๊ฒƒ์„ ๊ฐ€์ •ํ•ด ๋ณด์ž. ๊ทธ๋Ÿฌ๋ฉด ๋””์ž์ธ์€ ๋‹ค์Œ๊ณผ ๊ฐ™์„ ๊ฒƒ์ด๋‹ค.


์ด์ œ ์ปดํ“จํ„ฐ ์šฐํšŒ์ ์œผ๋กœ ๋ฐฉํ–ฅ์„ ๋ฐ”๊พธ๋Š” ๋ถ€๋ถ„(level)์„ ์ถ”๊ฐ€ํ•˜๋Š” ๋ฐฉ๋ฒ•์œผ๋กœ ์ปดํ“จํ„ฐ ๊ณผํ•™์ด ์ฒ˜ํ•œ ์ปค๋‹ค๋ž€ ๋ฌธ์ œ๋ฅผ ํ•ด๊ฒฐํ•ด ๋ณด์ž. ์ƒˆ๋กœ ์ถ”๊ฐ€๋  ContHolder๋Š” ์ฐธ์กฐ ์„ธ๊ธฐ ๊ธฐ๋Šฅ์„ ๊ตฌํ˜„ํ•˜๊ณ  ์žˆ์œผ๋ฉฐ, ๋Œ€์‹  RCPtr ํด๋ž˜์Šค ์—ญ์‹œ RCIPtr ํด๋ž˜์Šค๋กœ ํ•œ๋‹ค.("I"๋Š” indirection(์šฐํšŒ)์˜ ์˜๋ฏธ๋กœ ๋ถ™์€๊ฑฐ๋‹ค.) ์ด๋Ÿฐ ๋””์ž์ธ์€ ๋‹ค์Œ๊ณผ ๊ฐ™์€ ๋ชจ์Šต์„ ๋ณด์ผ ๊ฒƒ์ด๋‹ค.


๊ธฐ๋ณธ ๊ฐœ๋…์€ StringValue์—์„œ ์ ์šฉ๋œ ๋ฐฉ์‹๊ณผ ๋น„์Šทํ•˜๋‹ค. CountHolder๋Š” RCWidget์˜ ํด๋ผ์ด์–ธํŠธ๋กœ ๋ถ€ํ„ฐ ๊ตฌํ˜„ ์ƒํ™ฉ์„ ์ˆจ๊ฒจ ๋ฒ„๋ฆด ๊ฒƒ์ด๋‹ค. ์‚ฌ์‹ค ์ž์„ธํ•œ ๊ตฌํ˜„์€ RCIPtr์— ๊ฑฐ์˜ ๋‹ค๋˜์–ด ์žˆ๋‹ค. ๊ทธ๋ž˜์„œ ์ด ํด๋ž˜์Šค์˜ ๊ตฌํ˜„ ์ƒํ™ฉ์„ ๋ณด์ž.

~cpp 
template<class T>
class RCIPtr {
public:
    RCIPtr(T* realPtr = 0);
    RCIPtr(const RCIPtr& rhs);
    ~RCIPtr();

    RCIPtr& operator=(const RCIPtr& rhs);

    const T* operator->() const;                // ์„ค๋ช…๊ณผ ๊ตฌํ˜„ ์ฝ”๋“œ๋ฅผ ๋ณด์ž.
    T* operator->();                            //  ''
    const T& operator*() const;                 //  ''
    T& operator*();                             //  ''

private:
    struct CountHolder: public RCObject {
        ~CountHolder() { delete pointee; }
        T *pointee;
    };

    CountHolder *counter;

    void init();
    void makeCopy();                                // ๊ตฌํ˜„ ์ฝ”๋“œ๋ฅผ ๋ณด์ž.
};

template<class T>
void RCIPtr<T>::init()
{
    if (counter->isShareable() == false) {
        T *oldValue = counter->pointee;
        counter = new CountHolder;
        counter->pointee = new T(*oldValue);
    }

    counter->addReference();
}

template<class T>
RCIPtr<T>::RCIPtr(T* realPtr)
: counter(new CountHolder)
{
    counter->pointee = realPtr;
    init();
}

template<class T>
RCIPtr<T>::RCIPtr(const RCIPtr& rhs)
: counter(rhs.counter)
{ init(); }

template<class T>
RCIPtr<T>::~RCIPtr()
{ counter->removeReference(); }

template<class T>
RCIPtr<T>& RCIPtr<T>::operator=(const RCIPtr& rhs)
{
    if (counter != rhs.counter) {
        counter->removeReference();
        counter = rhs.counter;
        init();
    }
    return *this;
}

template<class T>
void RCIPtr<T>::makeCopy()                 // copy-on-write ์ƒํ™ฉ์˜ ๊ตฌํ˜„
{
    if (counter->isShared()) {
        T *oldValue = counter->pointee;
        counter->removeReference();
        counter = new CountHolder;
        counter->pointee = new T(*oldValue);
        counter->addReference();
    }
}

template<class T>                           // const ์ ‘๊ทผ;
const T* RCIPtr<T>::operator->() const      // copy-on-write๋ฅผ ๋น„๊ฐ์•ˆํ• 
{ return counter->pointee; }

template<class T>                           // non-const ์ ‘๊ทผ
T* RCIPtr<T>::operator->()                  // copy-on-write ๊ฐ์•ˆ
{ makeCopy(); return counter->pointee; }

template<class T>                           // const ์ ‘๊ทผ;
const T& RCIPtr<T>::operator*() const       // copy-on-write๋ฅผ ๋น„๊ฐ์•ˆํ• 
{ return *(counter->pointee); }

template<class T>                           // non-const ์ ‘๊ทผ
T& RCIPtr<T>::operator*()                   // copy-on-write ๊ฐ์•ˆ
{ makeCopy(); return *(counter->pointee); }
RCPPtr์„ RCPtr๊ณผ ์˜ค์ง ๋‘๊ฐ€์ง€ ์ ์—์„œ ๋‹ค๋ฅธ๋‹ค. ์ฒซ๋ฒˆ์งธ๋Š” RCIPtr์ด ์ค‘๊ฐ„ ์กฐ์ •์ž์ธ CountHolderํ†ตํ•ด์„œ ์ ‘๊ทผํ•˜๋Š” ๊ฒƒ๊ณผ ๋‹ฌ๋ฆฌ RCPtr ๊ฐ์ฒด๋Š” ๊ฐ’์„ ์ง์ ‘ ๊ฐ€๋ฆฌํ‚จ๋‹ค๋Š” ์ ์ด๋‹ค. ๋‘๋ฒˆ์งธ๋กœ๋Š” operator->์™€ operator*์„ ์˜ค๋ฒ„๋กœ๋“œ(overload)ํ•ด์„œ copy-on-write์— ์ž๋™์ ์œผ๋กœ ๋Œ€์‘ํ• ์ˆ˜ ์žˆ๊ฒŒ ํ•˜์˜€๋‹ค.

๊ทธ๋Ÿผ RCIPtr์— ๋น„ํ•˜์—ฌ RCWidget์€ ์ƒ๋‹นํžˆ ๊ตฌํ˜„์ด ๊ฐ„๋‹จํ•˜๋‹ค. ๊ฑฐ์˜ ๋ชจ๋“  ๊ธฐ๋Šฅ์ด RCIPtr์—์„œ ๊ตฌํ˜„๋˜์—ˆ๊ณ , RCWidget์€ ๊ทธ๊ฒƒ์„ ํ†ตํ•ด์„œ ์ธ์ž๋งŒ ์ „๋‹ฌํ•˜๋ฉด ๋˜๊ธฐ ๋•Œ๋ฌธ์ด๋‹ค.(delegate) ๋งŒ์•ฝ Widget์ด ๋‹ค์Œ๊ณผ ๊ฐ™์ด ์ƒ๊ฒผ๋‹ค๋ฉด

~cpp 
class Widget {
public:
    Widget(int size);
    Widget(const Widget& rhs);
    ~Widget();
    Widget& operator=(const Widget& rhs);
    void doThis();
    int showThat() const;
};

RCWidget์€ ์•„๋งˆ ์ด๋ ‡๊ฒŒ ๊ตฌํ˜„๋  ๊ฒƒ์ด๋‹ค.

~cpp 
class RCWidget {
public:
    RCWidget(int size): value(new Widget(size)) {}
    void doThis() { value->doThis(); }                  // delegate์‹œ์ผœ ์ค€๋‹ค.
    int showThat() const { return value->showThat(); }  // delegate์‹œ์ผœ ์ค€๋‹ค.
private:
    RCIPtr<Widget> value;
};
(์ž‘์„ฑ์ž์ฃผ: ๊ธฐํƒ€ ๋‚ด์šฉ์€ ๊ทธ๋ƒฅ ๋‚ด๋ถ€์— ๋Œ€ํ•œ ์„ค๋ช…์ด๋‹ค. ์ƒ๋žตํ•œ๋‹ค. ๋‚˜์ค‘์— ์‹œ๊ฐ„์ด๋˜๋ฉด ์ถ”๊ฐ€)

1.9. Evaluation : ํ‰๊ฐ€

์ง€๊ธˆ๊นŒ์ง€, widget, string, ๊ฐ’(value), ์Šค๋งˆํŠธ ํฌ์ธํ„ฐ(smart pointer), ์ฐธ์กฐ ์„ธ๊ธฐ ๊ธฐ๋ณธ ํด๋ž˜์Šค(reference-counting base class)์— ๊ด€ํ•ด์„œ ๊ตฌ์ฒด์ ์ธ ๋ถ€๋ถ„์„ ๋‹ค๋ฃจ์–ด ์™”๋‹ค. ์ด ๋ชจ๋“  ๊ฒƒ์€ ์šฐ๋ฆฌ์—๊ฒŒ ์ฐธ์กฐ ์„ธ๊ธฐ๋ฅผ ์ ์šฉํ• ์ˆ˜ ์žˆ๋Š” ๋„“์€ ํญ์„ ๊ฐ€์ ธ๋‹ค ์ฃผ์—ˆ๋‹ค. ์ด์ œ ์กฐ๊ธˆ ์ผ๋ฐ˜์ ์ธ ์ด์•ผ๊ธฐ๋กœ, ์งˆ๋ฌธํ•ด ๋ณด์ž. ๋‹ค์‹œ ๋งํ•˜์ž๋ฉด, ๋Œ€์ฒด ์–ธ์ œ ์ฐธ์กฐ ์„ธ๊ธฐ์˜ ๊ธฐ์ˆ ์„ ์ ์šฉ ์‹œ์ผœ์•ผ ํ• ๊นŒ?

์ฐธ์กฐ์„ธ๊ธฐ์˜ ๊ตฌํ˜„์€ ๊ณต์งœ๊ฐ€ ์•„๋‹ˆ๋‹ค. ๋ชจ๋“  ์ฐธ์กฐ์„ธ๊ธฐ๋Š” ์ฐธ์กฐ์„ธ๊ธฐ์— ๋Œ€ํ•œ ๊ทธ๋งŒํ•œ ๋น„์šฉ์„ ์ง€์ถœํ•˜์•ผ ํ•˜๋Š”๋ฐ, ์‚ฌ์šฉ์ž๋Š” ์ด๋Ÿฌํ•œ ๋ฐฉ๋ฒ•๋ก ์˜ ์ ์šฉ์—, ๊ฒ€์ฆ์„ ์›ํ•œ๋‹ค. ๋‹จ์ˆœํžˆ ๋ณด๋ฉด, ์ฐธ์กฐ์„ธ๊ธฐ๋Š” ๋” ๋งŽ์€ ๋ฉ”๋ชจ๋ฆฌ๋ฅผ ์žก์•„๋จน๊ฒŒ๋„ ํ• ์ˆ˜ ์ž‡๊ณ , ๋” ๋งŽ์€ ์ฝ”๋“œ๋ฅผ ์žก์•„ ๋จน๊ฒŒ ํ• ์ˆ˜ ์žˆ๋‹ค. ๊ฑฐ๊ธฐ์—๋‹ค ๋ชจ์ž˜๋ผ, ์ฝ”๋“œ๋ฅผ ๋” ๋ณต์žกํ•˜๊ฒŒ ํ•˜๊ณ , ์ •์„ฑ๋“ค์—ฌ ๋งŒ๋“  ์ฝ”๋“œ์— ๋Œ€ํ•˜์—ฌ ๋ง์ณ ๋ฒ„๋ฆด์ˆ˜๋„ ์žˆ๋‹ค. ๋งˆ์ง€๋ง‰์— ์ตœ์ข… ๊ตฌํ˜„๋œ String(StringValue, RCObject, RCPtr์ด ์ ์šฉ๋œ ๋ฒ„์ „) ํด๋ž˜์Šค ๋ณด๋‹ค๋Š”, ๋ณดํ†ต ์žก์กฐ์„ธ๊ธฐ๊ฐ€ ์ ์šฉ ์•ˆ๋œ ์ฝ”๋“œ๋“ค์„ ์“ด๋‹ค. ์‚ฌ์‹ค ์šฐ๋ฆฌ๊ฐ€ ๋””์ž์ธํ•œ ์ข€๋” ๋ณต์žกํ•œ ๋””์ž์ธ์€ ์ž๋ฃŒ์˜ ๊ณต์œ ๋กœ ๋” ์ข‹์€ ํšจ์œจ์„ ๋Œ์–ด ๋“ค์ธ๋‹ค. ๊ทธ๊ฒƒ์€ ๊ฐ์ฒด์˜ ์†Œ์œ ๊ถŒ๋“ค์„ ์ฃผ๋ฆฌ๊ณ , ์ฐธ์กฐ์„ธ๊ธฐ์˜ ์žฌ์‚ฌ์šฉ ๋ฐฉ๋ฒ•์— ๋Œ€ํ•œ ์ƒ๊ฐ๋“ค์„ ์ œ์‹œํ•œ๋‹ค. ๊ทธ๋Ÿผ์—๋„, ๋„ค๊ฐ€์ง€์˜ ํด๋ž˜์Šค๋ฅผ ์‚ฌ์šฉํ•ด์•ผ ํ•˜๊ณ , ํƒœ์ŠคํŠธํ•˜๊ณ , ๋ฌธ์„œํ™”ํ•˜๊ณ , ์œ ์ง€ ใ…—์Šคํ•˜๋Š”๋ฐ์—๋Š”, ํ•˜๋‚˜์˜ ํด๋ž˜์Šค๋ฅผ ์ž‘์„ฑ,๋ฌธ์„œํ™”,์œ ์ง€๋ณด์ˆ˜ ํ•˜๋Š”๊ฒƒ๋ณด๋‹ค ๋” ๋งŽ์€ ์ผ์„ ๋ถ€๋‹ดํ•˜๊ฒŒ ๋งŒ๋“ ๋‹ค.

์ฐธ์กฐ์„ธ๊ธฐ๋Š” ๋ณดํ†ต์˜ ๊ฐ์ฒด๋“ค์„ ๊ณต์œ ํ•ด์„œ ์‹œ์Šคํ…œ์˜ ๋น„์šฉ์„ ์ค„์ด๊ณ ์ž ํ•˜๋Š” ์ตœ์ ํ™” ๊ธฐ์ˆ ์ด๋‹ค. ์ฆ‰, ๊ณต์œ ๋ฅผ ๋งŽ์ด ํ•˜์ง€ ์•Š์€ ํ”„๋กœ๊ทธ๋žจ ๊ฐ์ฒด์— ๋Œ€ํ•˜์—ฌ ์ด๋ฅผ ์ ์šฉํ•˜๋ฉด ๋” ๋งŽ์€ ๋น„์šฉ๊ณผ, ๋” ๋ณต์žกํ•œ ํ”„๋กœ๊ทธ๋žจ์„ ์ž‘์„ฑํ• ์ˆ˜ ๋ฐ–์— ์—†๋‹ค๋Š” ๊ฒฐ๋ก ์ด ๋‚˜๋Š” ๊ฒƒ์ด๋‹ค. ๊ทธ ๋ฐ˜๋Œ€๋ผ๋ฉด, ์‹œ๊ฐ„, ๊ณต๊ฐ„ ๋น„์šฉ ๋ชจ๋‘๋ฅผ ์•„๋ผ๊ฒŒ ํ•ด์ค„ ๊ฒƒ์ด๋‹ค. ๊ทธ๋Ÿฌํ•œ ์ƒํ™ฉ์„ ์ƒ๊ฐํ•ด ๋ณธ๋‹ค.

  • ์ ์€ ์ž๋ฃŒ๋ฅผ ๋งŽ์€ ๊ฐ์ฒด๋“ค์ด ์‚ฌ์šฉํ•˜๊ณ ์ž ํ•œ๋‹ค. ์ด๋Ÿฌํ•œ ๊ฒฝ์šฐ์—๋Š” ์ƒ์„ฑ์ž์™€ ๋ณต์‚ฌ์— ๊ด€ํ•œ ๋น„์šฉ์ด ๋งŽ์ด ๋“ ๋‹ค. ์ด๋Ÿฐ ๊ฒฝ์šฐ ์ฐธ์กฐ์„ธ๊ธฐ์˜ ์ ์šฉ์ด ๋” ๋†“์€ ํšจ์œจ์„ ๋Œ์–ด ๋‚ผ์ˆ˜ ์žˆ์„ ๊ฒƒ์ด๋‹ค.
    • Relatively few values are shared by relatively many objects.
  • ๊ฐ์ฒด๋ฅผ ์ƒ์„ฑํ•˜๊ณ , ํŒŒ๊ดดํ•˜๋Š”๋ฐ ๋†’์€ ๋น„์šฉ์„ ์ง€๋ถˆํ•ด์•ผ ํ•˜๊ฑฐ๋‚˜, ๋งŽ์€ ๋ฉ”๋ชจ๋ฅผ ์‚ฌ์šฉํ•œ๋‹ค. ์ด๋Ÿฌํ•œ ๊ฒฝ์šฐ ์กฐ์ฐจ ์ฐธ์กฐ์„ธ๊ธฐ๋Š” ๋งŽ์€ ๊ฐ์ฒด๊ฐ€ ๊ณต์œ ํ•˜๋ฉด ํ• ์ˆ˜๋ก ๋น„์šฉ์„ ์ค„์—ฌ ์ค„๊ฒƒ์ด๋‹ค.
    • Object values are expensive to create or destroy, or they use lots of memory.


๊ฐ€์žฅ ํ™•์‹คํ•œ ๋ฐฉ๋ฒ•์€ ํ”„๋กœํŒŒ์ผ(profile)์„ ํ†ตํ•ด์„œ ์ฐธ์กฐ์„ธ๊ธฐ๊ฐ€ ํ•„์š”ํ•œ ๋‚ฉ๋“ํ•  ๋งŒํ•œ ์ด์œ ๋ฅผ ์ฐพ๋Š” ๊ฒƒ์ด๋‹ค. ์ด๋Ÿฌํ•œ ์‹ ๋ขฐ๊ฐ€ ๊ฐ€๋Š” ๋ฐฉ๋ฒ•์€ ์„ฑ๋Šฅ์˜ ๋ณ‘๋ชฉ ํ˜„์ƒ์ด ์ผ์–ด๋‚˜๋Š” ๋ถ€๋ถ„์— ์ฐธ์กฐ์„ธ๊ธฐ์˜ ์ ์šฉ์„ ํ†ตํ•ด์„œ ๋” ๋†’์€ ํšจ์œจ์„ ๊ฐ€์ง€๊ณ  ์˜ฌ์ˆ˜ ์žˆ๋‹ค๋Š” ์ฆ๊ฑฐ๊ฐ€ ๋ ๊ฒƒ์ด๋‹ค. ์˜ค์ง ๊ฐ์œผ๋กœ ์˜์กดํ•˜์—ฌ, ์ฐธ์กฐ์„ธ๊ธฐ์˜ ์ ์šฉ์€ ์—ญํšจ๊ณผ๋ฅผ ๊ฐ€์ ธ๋‹ค ์˜ฌ๋ฟ์ด๋‹ค.

์ง€๊ธˆ๊นŒ์ง€์˜ ๊ตฌํ˜„์œผ๋กœ ์ฐธ์กฐ์„ธ์ด๊ธ” ์ž๋ฃŒ๋Š” heap์˜์—ญ์—๋งŒ ์„ ์–ธํ• ์ˆ˜ ์žˆ๋‹ค. ์•„๋ฌด๋ฆฌ ์ง€์—ญ ๋ณ€์ˆ˜๋กœ ์„ ์–ธํ•œ๋“ค, ๋‚ด๋ถ€์—์„œ ์ž๋ฃŒ๋Š” heap์˜์—ญ์— ์„ ์–ธํ•˜์—ฌ, ๊ด€๋ฆฌ๋œ๋‹ค. ์ •ํ™•ํ•œ ์„ ์–ธ์ด๋œ ํด๋ž˜์Šค๋ฅผ ๋งŒ๋“ค์–ด์•ผ ํ•˜๊ณ , ๊ทธ๋ž˜์„œ ํ™•์‹คํžˆ ๋™์ž‘ํ•˜๋Š”๊ฐ€ ํ™•์‹ ํ• ์ˆ˜ ์žˆ๋Š” ๋ฒ„๊ทธ ์—†๋Š” ์ฝ”๋“œ๋ฅผ ๋งŒ๋“ค์–ด์•ผํ•œ๋‹ค. ๊ทธ๋ฆฌ๊ณ  ์ด ์ฐธ์กฐ์„ธ๊ธฐ ๊ธฐ๋ณธํด๋ž˜์Šค๊ฐ€ ์šฐ๋ฆฌ์˜ ์†์„ ์˜ฌ๋ฐ”๋ฅด๊ฒŒ ๋– ๋‚˜๋Š” ๊ฒƒ์€ ์‚ฌ์šฉ ๋ฐฉ๋ฒ•์— ๋Œ€ํ•˜์—ฌ ์ •ํ™•ํ•œ ๊ธฐ์ˆ ์ด ํ•„์š”ํ•˜๋‹ค.

DeleteMe)์˜์–ด๊ฐ€ ์งง์€์ง€ ๋’ค์˜ ๋‚ด์šฉ์€ ์ง€๋ฃจํ•œ ๊ฐ™์€ ํ† ๋ก ์˜ ์—ฐ์†๊ฐ™๋‹ค. ์ถ”๊ฐ€ํ•  ๊ธฐ์šด๋„ ์•ˆ๋‚œ๋‹ค.

2. Item 30: Proxy

  • Item 30: ๋Œ€๋ฆฌ์ž
๋ณดํ†ต ์šฐ๋ฆฌ๋Š” ์ผ์ฐจ์› ๋ฐฐ์—ด์„ ์‚ฌ์šฉํ•œ๋‹ค. ํ•˜์ง€๋งŒ ์ผ๋ฐ˜์ ์œผ๋กœ ์‹ค์ œ๋กœ ์ž๋ฃŒ์˜ ํ‘œํ˜„์—๋Š” ๊ทธ๋Ÿฌ์ง€๊ฐ€ ๋ชปํ•˜๋‹ค. ๋ถˆํ–‰ํžˆ๋„ C++๋Š” ์ด์ฐจ์› ์ด์ƒ์˜ ์ž๋ฃŒ๊ตฌ์กฐ๋ฅผ ์ž˜ ์ทจ๊ธ‰ํ•˜์ง€ ๋ชปํ•œ๋‹ค. ์ตœ์†Œํ•œ ๋ฐฐ์—ด์— ๋Œ€ํ•œ ์ง€์›์€ ์–ธ์–ด๊ฐ€ ๊ฐ€์ ธ์•ผํ•˜๋Š” ์ตœ์†Œํ•œ์˜ ๋ฐฐ๋ ค์ด๋‹ค.(์ž‘์„ฑ์ž์ฃผ:๋ฉ‹๋Œ€๋กœ ์˜์—ญ) FORTRAN์ด๋‚˜ BASIC, COBOL์—์„œ ์ผ์ฐจ์›, ์ด์ฐจ์›, ... ๋‹ค์ฐจ์› ๋ฐฐ์—ด์„ ๋งŒ๋“ค์ˆ˜ ์žˆ๋‹ค. (๊ทธ๋ž˜, FORTRAN์€ 7์ฐจ์› ๊นŒ์ง€๋ฐ–์— ์•ˆ๋œ๋‹ค. ์ด๊ฑฐ ๋”ด์ง€๋‹ค. ๋„˜์–ด๊ฐ€์ž) ํ•˜์ง€๋งŒ C++์—์„œ ํ• ์ˆ˜ ์žˆ๋‚˜? ๋•Œ๋ก  ์˜ค์ง ์ •๋ ฌ์„ ์œ„ํ•ด์„œ๋งŒ ์ผ๊ฒƒ์ด๋‹ค.

์ด ์ฝ”๋“œ๋Š” ํ•ฉ๋ฒ•์ด๋‹ค.:

~cpp 
int data[10][20];       // 2์ฐจ์› ๋ฐฐ์—ด 10 by 20
ํ•˜์ง€๋งŒ ์ฐจ์›์˜ ํฌ๊ธฐ๋Š” ๋ณ€์ˆ˜๊ฐ€ ๋ ์ˆ˜ ์—†๋‹ค. ์ด๋Ÿฐ๊ฒƒ์ด ์•ˆ๋œ๋‹ค.:

~cpp 
void processInput(int dim1, int dim2)
{
    int data[dim1][dim2];   // ์—๋Ÿฌ! ๋ฐฐ์—ด์˜ ์ฐจ์›์€ ๋‹จ์ง€ ์ปดํŒŒ์ผ ์ค‘์—๋งŒ ๊ฒฐ์ •๋œ๋‹ค.
    ...
}
๊ฑฐ๊ธฐ์— Heap ์˜์—ญ์— ๊ธฐ๋ฐ˜ํ•œ ํ• ๋‹น ์—ญ์‹œ ๊ทœ์น™์— ์–ด๊ธ‹๋‚œ๋‹ค.

~cpp 
int *data =  new int[dim1][dim2];   // ์—๋Ÿฌ!

2.1. Implementing Two-Dimensional Arrays ์ด์ฐจ์› ๋ฐฐ์—ด์˜ ๊ตฌํ˜„

๋‹ค์ฐจ์›์˜ ๋ฐฐ์—ด์€ C++์— ๋ฟ์•„๋‹ˆ๋ผ. ๋‹ค๋ฅธ ์–ธ์–ด์—์„œ๋„ ์œ ์šฉํ•˜๋‹ค. ๊ทธ๋ž˜์„œ ๋‹ค์ฐจ์› ๋ฐฐ์—ด์€ ์ตœ๊ทผ์— ์ด๊ฒƒ๋“ค์— ์ง€์›ํ•˜๋Š” ๋ฐฉ๋ฒ•์— ๋Œ€ํ•œ ์ค‘์š”์„ฑ์ด ๋Œ€๋‘๋˜๊ณ  ์žˆ๋‹ค. ๋ณดํ†ต์˜ ๋ฐฉ๋ฒ•์€ C++์—์„œ ํ‘œ์ค€ ์ค‘์— ํ•˜๋‚˜์ด๋‹ค.(ํ•„์š”๋กœํ•œ ๊ฐ์ฒด๋ฅผ ํ‘œํ˜„ํ•˜๊ธฐ ์œ„ํ•ด ํด๋ž˜์Šค๋ฅผ ๋งŒ๋“ ๋‹ค. ํ•˜์ง€๋งŒ ์•Œ๋งž๊ฒŒ ๊ตฌํ˜„ํ•˜๊ธฐ๊ฐ€ ์–ด๋ ต๋‹ค. ) ๋ฐ”๋กœ ์ด์ฐจ์› ๋ฐฐ์—ด์— ๋Œ€ํ•œ ํ…œํ”Œ๋ฆฟ์„ ์ •์˜ํ• ์ˆ˜ ์žˆ๋‹ค.

~cpp 
template<class T>
class Array2D {
public:
    Array2D(int dim1, int dim2);
    ...

};
์›ํ•˜๋Š”๋ฐ๋กœ ๋ฐฐ์—ด์„ ์ •์˜ํ• ์ˆ˜ ์žˆ๋‹ค.

~cpp 
Array2D<int> data(10, 20);          // ์˜ณ๋‹ค

Array2D<float> *data = new Array2D<float>(10, 20);  // ์˜ณ๋‹ค

void processInput(int dim1, int dim2)
{
    Array2D<int> data(dim1, dim2);  // ์˜ณ๋‹ค
    ...
}
ํ•˜์ง€๋งŒ ์ด๋Ÿฌํ•œ ๋ฐฐ์—ด ๊ฐ์ฒด์˜ ์‚ฌ์šฉ์€ ์™„๋ฒฝํ•˜์ง€ ์•Š๋‹ค. C์™€ C++์ƒ์—์„œ ๊ธฐ๋ณธ ๋ฌธ๋ฒ•์„ ์ ์šฉ์‹œํ‚จ๋‹ค๋ฉด, ๊ด„ํ˜ธ๋ฅผ ์‚ฌ์šฉํ•ด์„œ ๊ฐ์ฒด์˜ index๋ฅผ ์‚ฌ์šฉํ• ์ˆ˜ ์žˆ์–ด์•ผ ํ•œ๋‹ค.

~cpp 
cout << data[3][6];
๊ทธ๋ ‡์ง€๋งŒ Array2D์ƒ์— ์ธํ…์Šค์— ๊ด€ํ•œ์ธ์ž๋ฅผ ์–ด๋–ป๊ฒŒ ์ •์˜ํ•˜๊ณ , ์‚ฌ์šฉํ• ๊นŒ?

์ฒซ๋ฒˆ์งธ ํ•˜๊ณ  ์‹ถ์€๊ฑด ์•„๋งˆ operator[][]๋ฅผ ์„ ์–ธํ•ด ๋ฒ„๋ฆฌ๋Š” ๊ฒƒ์ด๋‹ค. ์ด๋ ‡๊ฒŒ

~cpp 
template<class T>
class Array2D {
public:
    // ์ด๋Ÿฌํ•œ ์„ ์–ธ์€ ์ปดํŒŒ์ผ ํ• ์ˆ˜ ์—†๋‹ค.
    T& operator[][](int index1, int index2);
    const T& operator[][](int index1, int index2) const;
    ...
};
๋ณด์ž๋งˆ์ž ์ด ์—ฐ์‚ฐ์ž์˜ ์˜๋„๋ฅผ ์•Œ๊ฒƒ์ด๋‹ค. ํ•˜์ง€๋งŒ operator[][]๋ž€๊ฑด ์„ ์–ธํ• ์ˆ˜๊ฐ€ ์—†๋‹ค. ๊ทธ๋ฆฌ๊ณ  ๋‹น์‹ ์˜ ์ปดํŒŒ์ผ๋Ÿฌ์—ญ์‹œ ์ด๊ฒƒ์„ ๊ฐ์•ˆํ•˜์ง€ ์•Š์„ ๊ฒƒ์ด๋‹ค. (์˜ค๋ฒ„๋กœ๋“œ(overload)์™€ ๊ด€๋ จํ•œ ์—ฐ์‚ฐ์ž๋“ค์— ๊ด€ํ•œ ์ •๋ณด๋Š” Item 7์„ ์ฐธ๊ณ ํ•˜๋ผ) ์šฐ๋ฆฌ๋Š” ๊ทธ์™ธ์˜ ๋‹ค๋ฅธ ๋ฐฉ์•ˆ์„ ์ฐพ์•„์•ผ ํ•œ๋‹ค.

๋งŒ์•ฝ ๋ฌธ๋ฒ• ๋•Œ๋ฌธ์— ๊ณจ๋จธ๋ฆฌ๊ฐ€ ์•„ํ”„๋‹ค๋ฉด, ๋ฐฐ์—ด์„ ์ง€์›ํ•˜๋Š” ๋งŽ์€ ์–ธ์–ด์—์„œ ์‚ฌ์šฉํ•˜๊ณ  ์žˆ๋Š” ๋ฐฉ๋ฒ•์„ ๋”ฐ๋ผ์„œ, ()๋ฅผ ์ด์šฉํ•˜๋Š” ์ธํ…์Šค์˜ ์ ‘๊ทผ์„ ๋งŒ๋“ค์–ด ๋ณผ์ˆ˜๋„ ์žˆ๋‹ค. ()์˜ ์ด์šฉ์€ ๋‹จ์ง€ operator()๋ฅผ ์˜ค๋ฒ„๋กœ๋“œ(overload)ํ•˜๋ฉด ๋œ๋‹ค.

~cpp 
class Array2D {
public:
    // ์ด๋Ÿฐ ์‚ฌํ•ญ์€ ์ž˜ ์ปดํŒŒ์ผ ๋œ๋‹ค.
    T& operator()(int index1, int index2);
    const T& operator()(int index1, int index2) const;
    ...
};
ํด๋ผ์ด์–ธํŠธ์—์„œ๋Š” ์ด๋ ‡๊ฒŒ ์‚ฌ์šฉํ•œ๋‹ค.

~cpp 
cout << data(3, 6);
์ด๋Ÿฌํ•œ ๊ตฌํ˜„์€ ์‰ฝ๊ณ , ๋‹น์‹ ์ด ์‚ฌ์šฉํ•˜๊ณ ์ž ํ•˜๋Š” ๋งŽ์€ ์ฐจ์›์—์„œ ์ผ๋ฐ˜ํ™” ์‹œํ‚ค๊ธฐ๋„ ์šฉ์ดํ•˜๋‹ค. ํ•˜์ง€๋งŒ ๊ฒฐ์ ์ด ์žˆ๋Š”๋ฐ, Array2D ๊ฐ์ฒด๋Š” built-in ๋ฐฐ์—ด๊ฐ™์ด ๋ณด์ด์ง€ ์•Š๋Š”๋‹ค๋Š” ์ ์ด๋‹ค. ์‚ฌ์‹ค ์œ„์˜, ๊ฐ data์˜ ์ธ์ž๋“ค์— ๋Œ€ํ•˜์—ฌ (3,4)๊ณผ ๊ฐ™์€ ์ ‘๊ทผ ๋ฐฉ๋ฒ•์€ ํ•จ์ˆ˜ ํ˜ธ์ถœ๊ณผ ๊ฐ™์€ ๋ชจ์Šต์„ ํ•˜๊ณ  ์žˆ๋‹ค.

FORTRAN๊ณผ ๊ฐ™์ด ๋ณด์ด๋Š” ์ด๋Ÿฌํ•œ ๋ฐฐ์—ด ํ‘œํ˜„๋ฒ•์ด ๋งˆ์Œ์— ๋“ค์ง€ ์•Š๋Š”๋‹ค๋ฉด, index ์—ฐ์‚ฐ์ž์™€ ๊ฐ™์€ ๊ฐœ๋…์„ ์œผ๋กœ ๋‹ค์‹œ ๋Œ์•„๊ฐ€ ๋ณธ๋‹ค. operator[][]๋ฅผ ์‚ฌ์šฉํ•˜์ง€ ์•Š๊ณ ๋„ ํ•ฉ๋ฒ•์ ์œผ๋กœ ๋‹ค์Œ๊ณผ ๊ฐ™์ด ๋ณด์ด๋Š” ์ฝ”๋“œ๋ฅผ ๊ตฌํ˜„ํ• ์ˆ˜๋Š” ์—†์„๊นŒ?

~cpp int data[10][20];
...
cout << data[3][6];
์–ด๋–ป๊ฒŒ ํ•˜๋ฉด ๋ ๊นŒ? ๋ณ€์ˆ˜์ธ data๋Š” ์‹ค์ œ๋กœ ์ด์ฐจ์› ๋ฐฐ์—ด์ด ๊ฒฐ์ฝ” ์•„๋‹ˆ๋‹ค. ๊ทธ๊ฒƒ์€ 10๊ฐœ-์ธ์ž๊ฐ€ ํ•˜๋‚˜์˜ ์ฐจ์›์œผ๋กœ ๋œ ๋ฐฐ์—ด์œผ๋กœ ์ฃผ์–ด์ง„ ๊ฒƒ์ด๋‹ค. 10๊ฐœ ์ธ์ž๋Š” ๊ฐ๊ธฐ 20๊ฐœ์˜ ์ธ์ž๋ฅผ ๊ฐ€์ง„ ๋ฐฐ์—ด๋กœ ๋˜์–ด ์žˆ๋‹ค. ๊ทธ๋ž˜์„œ data36์€ ์‹ค์ œ๋กœ๋Š” (data3)6๋ฅผ ์˜๋ฏธํ•˜๋Š”๊ฒƒ์ด๋‹ค. ๋‹ค์‹œ ๋งํ•˜์ž๋ฉด, data์˜ ๋„ค๋ฒˆ์งธ ์ธ์ž์ธ ๋ฐฐ์—ด์˜ ์ผ๊ณฑ๋ฒˆ์งธ ์ธ์ž. ์งง๊ฒŒ ๋งํ•ด ๊ฐ’์€ ์ฒ˜์Œ ๊ด„ํ˜ธ์˜ ์˜๋ฏธ๋Š” ๋˜๋‹ค๋ฅธ ๋ฐฐ์—ด์ด๋‹ค. ๊ทธ๋ž˜์„œ ๋‘๋ฒˆ์งธ ๊ด„ํ˜ธ์˜ ์ ์šฉ์€ ๋‘๋ฒˆ์งธ์˜ ๋ฐฐ์—ด๋กœ ๋ถ€ํ„ฐ ์ธ์ž๋ฅผ ๊ฐ€์ง€๊ณ  ์˜ค๋Š” ๊ฒƒ์ด๋‹ค.

๊ฐ™์€ ๋ฐฉ์‹์„ Array2D์— operaotr[]๊ฐ€ ์ƒˆ๋กœ์šด ๊ฐ์ฒด์ธ, Array1D๋ฅผ ๋ฐ˜ํ™˜์‹œํ‚ค๋Š” ๋ฐฉ์‹์œผ๋กœ ํ’€์–ด๋‚˜๊ฐ€ ๋ณด์ž. ์›๋ž˜ ์ด์ฐจ์› ๋ฐฐ์—ด์˜ ์•ˆ์— ์กด์žฌํ•˜๋Š”, ๋ฐ˜ํ™˜๋˜๋Š” ์ธ์ž Array1D์—์„œ operator[]๋ฅผ ์˜ค๋ฒ„๋กœ๋“œํ• ์ˆ˜ ์žˆ๋‹ค.

~cpp 
template<class T>
class Array2D {
public:
    // 2๋ฒˆ์งธ ์ฐจ์›์— ์œ„์น˜ํ•˜๋Š” Array1D
    class Array1D {
    public:
        T& operator[](int index);
        const T& operator[](int index) const;
        ...
    };

    // ์œ„์˜ 1์ฐจ์› ๋ฐฐ์—ด ๊ฐ์ฒด Array1D
    Array1D operator[](int index);  
    const Array1D operator[](int index) const;
    ...

};
์ด๋Ÿฌ๊ฒŒ ํ•˜๋ฉด ๋‹ค์Œ๊ณผ ๊ฐ™์€ ๋ฌธ๋ฒ•์ด ํ•ฉ๋ฒ•์ ์ด๋‹ค.

~cpp 
Array2D<float> data(10, 20);
...
cout << data[3][6];          // ์˜ณ๋‹ค.
์—ฌ๊ธฐ์—์„œ data3์€ Array1D๋ฅผ ์ด์•ผ๊ธฐ ํ•˜๋Š” ๊ฒƒ์ด๊ณ , operator[]๋Š” ๋‘๋ฒˆ์งธ ์ฐจ์›์— ์œ„์น˜ (3,6)์— ์žˆ๋Š” float๋ฅผ ํ˜ธ์ถœํ•œ๋‹ค.

Array2D ํด๋ž˜์Šค์˜ ํด๋ผ์ด์–ธํŠธ๋Š” Array1Dํด๋ž˜์Šค์— ๊ด€ํ•ด์„œ ์‹ ๊ฒฝ ์“ธํ•„์š” ์—†๋‹ค. ์ด๋Ÿฌํ•œ ๊ฐ์ฒด๋Š” 1์ฐจ์›์˜ ๋ฐฐ์—ด์—๋Œ€ํ•œ ๊ฐ์ฒด์˜ ํ‘œ์ค€์ด์ง€๋งŒ, ๊ฐœ๋…์ ์œผ๋กœ๋Š” ์กด์žฌํ•˜์ง€ ์•Š๋Š”๋‹ค. ์ด๊ฒƒ๋“ค์„ ์‹ค์ œ๋กœ ์“ฐ๋Š” ๊ทธ๋Ÿฌํ•œ ํด๋ผ์ด์–ธํŠธ๋“ค์€ ์ด์ฐจ์› ๋ฐฐ์—ด์„ ์ •ํ™•ํžˆ ํ”„๋กœ๊ทธ๋žจ ํ•œ๋‹ค. C++์˜ ์—‰๋šฑํ•œ ์ง“์„ ๋งŒ์กฑ์‹œํ‚ค๊ธฐ ์œ„ํ•˜์—ฌ, ์ผ์ฐจ์› ๋ฐฐ์—ด์„ ๋‹ค๋ฃจ๋Š”๋ฐ ๋ฌธ๋ฒ•์ ์œผ๋กœ ์ •ํ™•ํžˆ ๊ตฌํ˜„ํ•œ Array2D์˜ ํด๋ผ์ด์–ดํŠธ๋“ค์ด ๊ฑฑ์ •ํ•˜๋Š” ์ผ์ด ์—†๋‹ค.

Array2D์˜ ํด๋ผ์ด์–ธํŠธ์— ์˜ํ•ด ์‚ฌ์šฉ๋˜์–ด์ง€๋Š” ๊ฐœ๋…์ ์ธ ๋ชจ๋ธ์˜ ๋ถ€์ œ๋กœ, Array1D ๊ฐ๊ฐ์˜ ๊ฐ์ฒด๋Š” 1์ฐจ์› ๋ฐฐ์—ด์„ ์˜๋ฏธํ•œ๋‹ค. ๋‹ค๋ฅธ ๊ฐ์ฒด๋ฅผ ์œ„ํ•ด ์กด์žฌํ•˜๋Š” ๊ฐ์ฒด๋“ค์„ ๋ณดํ†ต proxy object๋ผ๊ณ  ๋ถˆ๋ฆฌ์ด๊ณ , oproxy๊ฐ์ฒด๋Š” proxy class์— ์˜ํ•ด ํ˜ธ์ถœ๋œ๋‹ค. proxy ํด๋ž˜์Šค or ์˜ ์ธ์Šคํ„ด์Šค๋Š” ์ผ์ฐจ์› ๋ฐฐ์—ด์˜ ๊ทผ๊ฐ„์ด ๋˜๋Š”๋ฐ, ๊ฐœ๋…์ ์œผ๋กœ ์กด์žฌํ•˜์ง€ ์•Š์€๋‹ค. (proxy ๊ฐ์ฒด๋ฅผ ์œ„ํ•œ ๊ธฐ์ˆ ๊ณผ ํด๋ž˜์Šค๋Š” ์ „์ฒด์—์„œ ๋™๋–จ์–ด์ง„ ๋ชจ์Šต์ด๋‹ค.; ๊ทธ๋Ÿฌํ•œ ํด๋ž˜์Šค์˜ ๊ฐ์ฒด ์—ญ์‹œ ๋•Œ๋กœ surrogate(๋Œ€๋ฆฌ์ž) ๋ผ๊ณ ๋„ ๋ถˆ๋ฆด ๊ฒƒ์ด๋‹ค.

2.2. Distinguishing Reads from Writes via operator[] : operator[]์˜ ์“ฐ๊ธฐ์— ๊ธฐ๋ฐ˜ํ•œ ์ฝ๊ธฐ๋ฅผ ๊ตฌ๋ณ„

๋‹ค์ฐจ์› ๋ฐฐ์—ด๊ณผ ๊ฐ™์€ ์ธ์Šคํ„ด์Šค๋ฅผ ๋งŒ๋“œ๋Š” ํ”„๋ก์‹œ์˜ ์‚ฌ์šฉ์€ ์ผ๋ฐ˜์ ์ด๋‹ค. ํ•˜์ง€๋งŒ ํ”„๋ก์‹œ ํด๋ž˜์Šค๋“ค์€ ์ผ๋ฐ˜ ๋ฐฐ์—ด๋ณด๋‹ค ์œ ์—ฐํ•˜์ง€ ๋ชปํ•˜๋‹ค. Item 5์—์„œ ์˜ˆ๋ฅผ ๋“ค์–ด ๋ณด๋ฉด ์–ด๋–ป๊ฒŒ ํ”„๋ก์‹œ ํด๋ž˜์Šค๋“ค์ด ์˜๋„ํ•˜์ง€ ์•Š์€ ์ƒ์„ฑ์ž์˜ ์‚ฌ์šฉ์„ ๋ง‰์„์ˆ˜ ์žˆ๋Š”์ง€ ๋ฐฉ๋ฒ•์„ ๋ณด์—ฌ์ค€๋‹ค. ํ•˜์ง€๋งŒ ํ”„๋ก์‹œ ํด๋ž˜์Šค์˜ ๋‹ค์ฑ„๋กœ์šด ์‚ฌ์šฉ์ด ๊ฐ€์žฅ ์ž˜์•Œ๋ ค์ง„ ๊ฒƒ์€ ๋งˆ๋กœ operator[]์—์„œ write์™€ read๋ฅผ ๊ตฌ๋ถ„ํ•˜๋Š” ๊ฒƒ์ด๋‹ค.

operator[]๋ฅผ ์ง€์›ํ•˜๋Š”, ์ฐธ์กฐ์„ธ๊ธฐ๊ฐ€ ์ ์šฉ๋œ ๋ฌธ์ž์—ด ํ˜•์— ๊ด€ํ•ด์„œ ์ƒ๊ฐํ•ด ๋ณด์ž. ์ž์„ธํ•œ ์„ค๋ช…์€ Item 29๋ฅผ ์ฐธ๊ณ ํ•˜๋ผ, ๋งŒ์•ฝ Item 29์˜ ๋ฐฉ๋ฒ•๋Œ€๋กœ ์ฐธ์กฐ์„ธ๊ธฐ์˜ ๊ฐœ๋…์„ ์ ์šฉํ•ด์„œ, ๊ทธ๊ฒƒ์„ ๋ฐฐ์—ด์— ์ผ๋ฐ˜ํ™” ์‹œํ‚ค๋Š” ๊ฒƒ์€ ์ข‹์€ ์ƒ๊ฐ์ด๋‹ค.

operator[]๋ฅผ ์ง€์›ํ•˜๋Š” ๋ฌธ์ž์—ด ํ˜•์€ ํด๋ผ์ด์–ธํŠธ์—๊ฒŒ ๋‹ค์Œ๊ณผ ๊ฐ™์€ ์ฝ”๋“œ๋ฅผ ํ—ˆ์šฉํ•œ๋‹ค.

~cpp 
String s1, s2;		// ๋ฌธ์ž์—ด๊ณผ ๋น„์Šทํ•œ ํด๋ž˜์Šค;ํ”„๋ก์‹œ์˜ ์“ฐ์ž„์€ 
                    // ํ‘œ์ค€ ๋ฌธ์ž์—ด ์ธํ„ฐํŽ˜์ด์Šค๋ฅผ ๋”ฐ๋ฅด๋Š” ํด๋ž˜์Šค ํ˜•ํƒœ๋ฅผ
					// ์œ ์ง€ํ•œ๋‹ค.
...

cout << s1[5];      // s1 ์ฝ๊ธฐ

s2[5] = 'x';        // s2 ์“ฐ๊ธฐ

s1[3] = s2[8];      // s1 ์“ฐ๊ธฐ, s2 ์ฝ๊ธฐ
operator[] ๋Š” ๊ฐ๊ธฐ ๋‹ค๋ฅธ ๋ชฉ์ ์œผ๋กœ ํ˜ธ์ถœ๋ ์ˆ˜ ์žˆ์Œ์„ ์œ ์˜ํ•˜๋ผ: ๋ฌธ์ž๋ฅผ ์ฝ๊ฑฐ๋‚˜ ํ˜น์€ ๋ฌธ์ž๋ฅผ ์“ฐ๊ฑฐ๋‚˜, ์ฝ๊ธฐ๋Š” rvalue์˜ ํ˜•ํƒœ๋กœ ์“ฐ์—ฌ์ง€๋„๋ก ์•Œ๋ ค์ ธ ์žˆ๋‹ค.; ๊ทธ๋Ÿผ ์“ฐ๊ธฐ๋Š” lvalueํ˜•ํƒœ(r์€ right hand value, l์€ left ์ดํ•˜ ๊ฐ™์Œ) ์ผ๋ฐ˜์ ์œผ๋กœ lvalue์˜ ์˜๋ฏธ๋Š” ๊ฐ์ฒด์—์„œ ๊ทธ๋Ÿฌํ•œ ๊ฐ์ฒด์˜ ์ˆ˜์ •์„ ์˜๋ฏธํ•˜๋ฉฐ, rvalue๋Š” ์ˆ˜์ •์„ ํ• ์ˆ˜ ์—†๋Š” ๊ฒƒ์„ ์˜๋ฏธํ•œ๋‹ค.

์ด๋Ÿฌํ•œ ์ƒํƒœ, ์ฆ‰ perator[]์—์„œ lvalue์™€ rvalue๋ฅผ ๊ตฌ๋ถ„ํ•ด์•ผ๋งŒ ํ•œ๋‹ค. ์™œ๋ƒํ•˜๋ฉด ์ฐธ์กฐ์„ธ๊ธฐ๊ฐ€ ์ ์šฉ๋œ ์ž๋ฃŒ๊ตฌ์กฐ์˜ ๊ฒฝ์šฐ์— ์ฝ๊ธฐ๋Š” ์“ฐ๊ธฐ์— ๋น„ํ•˜์—ฌ ํ›จ์”ฌ ์ ์€ ๋น„์šฉ์„ ์†Œ๋ชจํ•˜๊ธฐ ๋•Œ๋ฌธ์ด๋‹ค. Item 29์—์„œ ์ฐธ์กฐ์„ธ๊ธฐ ๊ฐ์ฒด์˜ ์“ฐ๊ธฐ๋Š” ์•„๋งˆ ์ „์ฒด ์ž๋ฃŒ๊ตฌ์กฐ์˜ ๋ณต์‚ฌ๋ฅผ ์œ ๋„ํ•˜์ง€๋งŒ, ์ฝ๊ธฐ๋Š” ๊ฐ„๋‹จํ•œ ๊ฐ’์˜ ๋ฐ˜ํ™˜์„ ์˜๋ฏธํ•œ๋‹ค๊ณ  ์„ค๋ช…ํ–ˆ๋‹ค. ๋ถˆํ–‰ํžˆ๋„, operator[]์˜ ๋‚ด๋ถ€์—์„œ, ์ด๋“ค์˜ ํ˜ธ์ถœ ๋ชฉ์ ์„ ๊ตฌ๋ถ„ํ•  ๋ฐฉ๋ฒ•์€ ์—†๋‹ค. operator[]๋Š” lvalue์™€ rvalue์˜ ์“ฐ์ž„์˜ ์ฐจ์ด๋ฅผ ๊ตฌ๋ถ„ํ• ์ˆ˜ ์—†๋‹ค.

"๊ทธ๋ ‡์ง€๋งŒ ์ž ์‹œ!" ํ•˜๊ณ  ๋‹น์‹ ์ด ๋งํ•œ๋‹ค. "๊ผญ ๊ทธ๋Ÿด ํ•„์š”๊ฐ€ ์—†๋‹ค. operator[]์˜ ์ƒ์ˆ˜ํ™” ๋œ ๊ฐœ๋…์„ ๋ฐ›์•„๋“ค์—ฌ์„œ operator[]์˜ ์ฝ๊ธฐ์™€ ์“ฐ๊ธฐ๋ฅผ ๊ตฌ๋ถ„ํ•˜๋ฉด ๋˜์ง€ ์•Š์€๊ฐ€?" ์ด๋Ÿฌํ•œ ๋‹ค๋ฅธ ์ธก๋ณ€์œผ๋กœ ๋‹น์‹ ์€ ์šฐ๋ฆฌ์—๊ฒŒ ๋ฌธ์ œ์˜ ํ•ด๊ฒฐ ๋ฐฉ์‹์„ ์ œ์•ˆํ•œ๋‹ค.

~cpp 
class String {
public:
  const char& operator[](int index) const;       // ์ฝ๊ธฐ ์œ„ํ•ด ์กด์žฌ
  char& operator[](int index);                   // ์“ฐ๊ธฐ ์œ„ํ•ด ์กด์žฌ
  ...

};
๋ถˆํ–‰ํžˆ๋„ ์ด๋Ÿฌํ•œ ๊ฒƒ์€ ์ˆ˜ํ–‰๋˜์ง€ ์•Š๋Š”๋‹ค. ์ปดํŒŒ์ผ๋Ÿฌ๋Š” const์™€ non-const ๋ฉค๋ฒ„ ํ•จ์ˆ˜์˜ ๊ตฌ๋ถ„์„ ์˜ค์ง ๊ทธ ๊ฐ์ฒด๊ฐ€ const์ธ๊ฐ€์˜ ์—ฌ๋ถ€์— ๋”ฐ๋ผ๋งŒ ํŒ๋‹จํ•œ๋‹ค. ์ด๋Ÿฌํ•œ ๊ตฌํ˜„์€, const๊ตฌ๋ณ„์˜ ๋ชฉ์ ์„ ์œ„ํ•ด ์•„๋ฌด๋Ÿฐ ์˜ํ–ฅ์„ ๋ชป ๋ผ์นœ๋‹ค.

~cpp 
String s1, s2;

...

cout << s1[5];      // non-const operator[] ํ˜ธ์ถœ ์™œ๋ƒํ•˜๋ฉด
                    // s1์ด non-const์ด๊ธฐ ๋•Œ๋ฌธ์—

s2[5] = 'x';        // ์—ญ์‹œ non-const operator[] ํ˜ธ์ถœ: s2๋Š” non-const์ด๋‹ค.

s1[3] = s2[8];      // ๋‘˜๋‹ค non-const operator[] ํ˜ธ์ถœ ์™œ๋ƒํ•˜๋ฉด s1,s2๋ชจ๋‘
                    // non-const ๊ฐ์ฒด์ด๋‹ค.
๊ทธ๋Ÿฌ๋ฏ€๋กœ ์ด๋Ÿฐ ๋ฐฉ์‹์˜ operator[]์˜ ์˜ค๋ฒ„๋กœ๋“œ๋Š” ์ฝ๊ธฐ์™€ ์“ฐ๊ธฐ์˜ ๊ตฌ๋ถ„์— ์‹คํŒจํ•œ๋‹ค.


Item 29์—์„œ ์šฐ๋ฆฌ๋Š” operator[]๋ฅผ ์“ฐ๊ธฐ๋ฅผ ์œ„ํ•ด์„œ ์žฌ ๋””์ž์ธํ–ˆ๋‹ค. ์•„๋งˆ ์ด๊ฑธ ์‰ฝ๊ฒŒ ํฌ๊ธฐํ• ์ˆ˜๋Š” ์—†์„ ๊บผ๋‹ค.(์ž‘์„ฑ์ž์ฃผ:์–ผ๋งˆ๋‚˜ ๊ณ ์ƒํ•˜๋ฉด์„œ ๋ดค๋Š”๋ฐ, ๋ฐ”๊พธ๊ธฐ ์‹ซ์ง€.) Item 29์˜ ๋””์ž์ธ์€ lvalue์™€ rvalue์˜ ์‚ฌ์šฉ์„ ๊ตฌ๋ถ„ํ•˜๋Š” ๊ฒƒ์ด ์•„๋‹ˆ๋ผ, operator[]๋ฅผ ํ˜ธ์ถœํ•˜๋ฉด ๋ฌด์กฐ๊ฑด ์“ฐ๊ธฐ๋กœ ์ทจ๊ธ‰ํ•ด ๋ฒ„๋ฆฌ๋Š” ๊ฒƒ์ด๋‹ค.

operator[]๊ฐ€ ์ฝ๊ธฐ์™€ ์“ฐ๊ธฐ๋ฅผ ๊ตฌ๋ถ„ ๋ชปํ•˜์ง€๋งŒ ์ผ๋‹จ ์šฐ๋ฆฌ๋Š” ๊ฐ€๋Šฅํ•œํ•œ ์ด๊ฒƒ์„ ๊ตฌํ˜„ํ•ด ๋ณด๊ณ ์ž ํ•˜๋Š” ์ž…์žฅ์—์„œ ์ ‘๊ทผํ•ด ๋ณด์ž. operator[]๊ฐ€ ๋ฐ˜ํ™˜ํ•œ ์ดํ›„์— ์ฝ๊ธฐ์™€ ์“ฐ๊ธฐ์˜ ์ƒํƒœ๋ฅผ ์•Œ์•„๋‚ด๋Š” ๋ฐฉ๋ฒ•์„ ํ•„์š”๋กœ ํ•œ๋‹ค. ์ด๊ฒƒ์˜ ์˜๋ฏธ๋Š” ์•ž์— ๋‹ค๋ฃจ์—ˆ๋˜, lazy evaluation์˜ ๊ฐœ๋…๊ณผ ๋น„์Šทํ•˜์ง€ ์•Š์„๊นŒ?

ํ”„๋ก์‹œ ํด๋ž˜์Šค๋Š” ์šฐ๋ฆฌ๊ฐ€ ํ•„์š”ํ•œ ์‹œ๊ฐ„์„ ๋ฒŒ์–ด ์ค„์ˆ˜ ์žˆ๋‹ค. ์šฐ๋ฆฌ๋Š” operator[]์˜ ๋ฐ˜ํ™˜์ธ์ž๋ฅผ ๋ฌธ์ž๋Œ€์‹ ์— ๋ฌธ์ž์—ด์„ ์œ„ํ•œ ํ”„๋ก์‹œ ๊ฐ์ฒด๋ฅผ ๋ฐ˜ํ™˜ํ•˜๋„๋ก ์ˆ˜์ •ํ• ์ˆ˜ ์žˆ๊ธฐ ๋•Œ๋ฌธ์ด๋‹ค. ์šฐ๋ฆฌ๋Š” ์ด๋ ‡๊ฒŒ ํ”„๋ก์‹œ๋ฅผ ์‚ฌ์šฉํ•ด์„œ ์‹œ๊ฐ„์„ ๋ฒŒ์ˆ˜ ์žˆ๋‹ค. ์ด ํ”„๋ก์‹œ ํด๋ž˜์Šค๊ฐ€ ์ฝํž๋•Œ, operator[]๊ฐ€ ์ฝ๊ธฐ์ธ์ง€ ์“ฐ๊ธฐ์ธ์ง€๋ฅผ ์•Œ์ˆ˜ ์žˆ๋‹ค.

์ผ๋‹จ ์†Œ์Šค๋ฅผ ๋ณด๊ธฐ์ „์— ์šฐ๋ฆฌ๊ฐ€ ํ”„๋ก์‹œ๋ฅผ ์–ด๋–ป๊ฒŒ ์จ์•ผํ• ์ง€ ์„ธ๊ฐ€์ง€์˜ ์ˆœ์„œ๋กœ ๋‚˜๋ˆ„์–ด ์ƒ๊ฐํ•˜์ž.

  • ํ”„๋ก์‹œ๋ฅผ ๋งŒ๋“ ๋‹ค. ๋‹ค์‹œ ๋งํ•ด ๋ฌธ์ž์—ด์—์„œ ๋ฌธ์ž๋ฅผ ๋Œ€์‹ ํ•˜๋Š” ๊ฒƒ์— ์•Œ๋งž๋„๋ก ๋งŒ๋“ ๋‹ค.
  • ํ”„๋ก์‹œ๋ฅผ ์จ์•ผํ•  ๊ณณ, ์ฆ‰ ๋ฌธ์ž์—ด์˜ ๊ธ€์ž๋ฅผ ํ• ๋‹นํ•  ๊ณณ์— ์ ์šฉํ•œ๋‹ค. ์ ์šฉ์„ ํ• ๋•Œ ํ”„๋ก์‹œ๋Š” operaotr[]์—์„œ lvalue์˜ ์“ฐ์ž„์œผ๋กœ ์‚ฌ์šฉ๋œ๋‹ค.
  • ๋˜ ๋‹ค๋ฅธ ๋ฐฉ์‹์œผ๋กœ ํ”„๋ก์‹œ๋ฅผ ์‚ฌ์šฉํ•œ๋‹ค. ์ด๋ ‡๊ฒŒ ์‚ฌ์šฉ๋˜๋ฉด ํ”„๋ก์‹œ๋Š” operator[]์— ๋Œ€ํ•œ rvalue์˜ ์“ฐ์ž„์„ ๊ตฌํ˜„ํ•œ๋‹ค.

์—ฌ๊ธฐ์—์„œ๋Š” ์ฐธ์กฐ์„ธ๊ธฐ๊ฐ€ ์ ์šฉ๋œ Stringํด๋ž˜์Šค์— lvalue์™€ rvalue์˜ ์“ฐ์ž„์„ ๊ตฌ๋ณ„ํ•˜๋Š” operator[]์˜ ๋Šฅ๋ ฅ์„ ๋ถ€์—ฌํ–ˆ๋‹ค.

~cpp 
class String {                    // ์ฐธ์กฐ์„ธ๊ธฐ๊ฐ€ ์ ์šฉ๋œ ๋ฌธ์ž์—ด, Item 29์ฐธ๊ณ 
public:                           

    class CharProxy {               // ๋ฌธ์ž์˜ ํ”„๋ก์‹œ
    public:
        CharProxy(String& str, int index);                // ์ƒ์„ฑ

        CharProxy& operator=(const CharProxy& rhs);       // lvalue
        CharProxy& operator=(char c);                     // ์˜ ์“ฐ์ž„์— ๋ฐ˜์‘

        operator char() const;                            // rvalue์˜ ์“ฐ์ž„์— ๋ฐ˜์‘
                                                      // use
    private:
        String& theString;            // ํ”„๋ก์‹œ์—์„œ ๋ฌธ์ž์—ด์„ ์ฐธ์กฐํ•  ๊ฒฝ์šฐ๊ฐ€ ํ•„์š”ํ• ์‹œ

        int charIndex;                // ๋ฌธ์ž์˜ ์ธ๋ฑ์Šค
    };

    // Stringํด๋ž˜์Šค๊ฐ€ ํฌํ•จํ•˜๊ณ  ์žˆ๋Š” ๊ฒƒ
    const CharProxy  operator[](int index) const;   // const String์— ๋ฐ˜์‘

    CharProxy operator[](int index); // non-const String์„ ์œ„ํ•ด์„œ
    ...

    friend class CharProxy;

private:
    RCPtr<StringValue> value;
};
Item 29์—์„œ์˜ Stringํด๋ž˜์Šค์˜ ์ตœ์ข…๋ฒ„์ „๊ณผ ์ด ์†Œ์Šค๊ฐ€ ๋‹ค๋ฅธ์ ์€ ์˜ค์ง ์ถ”๊ฐ€๋œ CharProxyํด๋ž˜์Šค์— operator[] ํ•จ์ˆ˜๊ฐ€ ๊ตฌํ˜„๋˜์—ˆ๋‹ค๋Š” ์ ์ด๋‹ค. ํ•˜์ง€๋งŒ, ํด๋ผ์ด์–ธํŠธ ์ž…์žฅ์—์„œ๋Š” ๋ณดํ†ต ์“ฐ๋Š”๊ฒƒ์ฒ˜๋Ÿผ Stringํด๋ž˜์Šค๋ฅผ ์‚ฌ์šฉํ• ๋•Œ ์ด๋Ÿฌํ•œ ์‚ฌ์‹ค์„ ๋ฌด์‹œํ•˜๊ณ , operator[]ํ•จ์ˆ˜๊ฐ€ ๊ธ€์ž๋ฅผ ๋ฐ˜ํ™˜ํ•˜๋Š” ๊ฒƒ์œผ๋กœ ์ทจ๊ธ‰ํ•œ๋‹ค.


~cpp 
String s1, s2;  // ํ”„๋ก์‹œ๋ฅผ ์‚ฌ์šฉํ•˜๋Š” ์ฐธ์กฐ ์„ธ๊ธฐ๊ฐ€ ์ ์šฉ๋œ ๋ฌธ์ž์—ด
...
cout << s1[5];  // ์˜ณ๋‹ค.

s2[5] = 'x';    // ์—ญ์‹œ ์˜ณ๋‹ค.

s1[3] = s2[8];  // ์—ญ์‹œ๋‚˜ ์ž˜๋Œ์•„๊ฐ„๋‹ค.
์ด๋ ‡๊ฒŒ ์›€์ง์ด๋Š” ๊ฒƒ์ด ๊ด€์‹ฌ์‚ฌ๊ฐ€์•„๋‹ˆ๋ผ, ์–ด๋–ป๊ฒŒ ์›€์ง์ด๋А๋ƒ๊ฐ€ ๊ด€์‹ฌ์‚ฌ ์ผ๊ฒƒ์ด๋‹ค.

๋งจ์ฒ˜์Œ์— ์ด ๊ตฌ๋ฌธ์„ ์ƒ๊ฐํ•ด ๋ณด์ž.

~cpp 
cout << s1[5];

s15์˜ ํ‘œํ˜„์€ CharProxy ๊ฐ์ฒด๋ฅผ ๋ฐ˜ํ™˜ํ•œ๋‹ค. s15๊ฐ€ output(<<) ์—ฐ์‚ฐ์ž์— ๋Œ€ํ•˜์—ฌ ๊ฐ์ฒด์— ๋Œ€ํ•˜์—ฌ ์ •์˜๋œ๊ฒƒ์€ ์—†๋‹ค. ๊ทธ๋ž˜์„œ ๋‹น์‹ ์˜ ์ปดํŒŒ์ผ๋Ÿฌ๋Š” operator<<์— ์ ์šฉํ• ์ˆ˜ ์žˆ๋Š” ์•”์‹œ์ (implicit) ํ˜•๋ณ€ํ™˜์„ ์ฐพ๋Š”๋‹ค. ์ปดํŒŒ์ผ๋Ÿฌ๋Š” ๊ทธ๋ž˜์„œ ํ”„๋ก์‹œ ํด๋ž˜์Šค ๋‚ด๋ถ€์— ์„ ์–ธ๋˜์–ด ์žˆ๋Š” char()๋ฅผ ์ฐพ์„์ˆ˜ ์žˆ๋‹ค. ์ปดํŒŒ์ผ๋Ÿฌ๋Š” ์ด(char) ํ˜•๋ณ€ํ™˜์„ ์ˆ˜ํ–‰ํ•˜๊ธฐ๋ฅผ ์š”์ฒญํ•˜๊ณ , ๊ฒฐ๊ณผ์ ์œผ๋กœ CharProxy๋Š” ๋ฌธ์ž๋กœ ๋ณ€ํ™˜๋˜์–ด์„œ ์ถœ๋ จ๋˜์–ด ์ง„๋‹ค. ๋‹ค์‹œ ๋งํ•˜์ง€๋งŒ, ์ด๊ฒƒ์€ CharProxy-to-char ๋กœ์˜ ํ˜•๋ณ€ํ™˜์ด CharProxy๋‚ด๋ถ€์— ์•”์‹œ์ (implicit) ํ˜•๋ณ€ํ™˜์ด ์„ ์–ธ๋˜์–ด ์žˆ๊ธฐ ๋•Œ๋ฌธ์ด๋‹ค.

lvalue์˜ ์‚ฌ์šฉ์€ ์ข€ ๋‹ค๋ฅด๊ฒŒ ์žกํžˆ๋Š”๋ฐ, ์ด ๊ตฌ๋ฌธ์„ ๋‹ค์‹œ ๋ณด์ž.

~cpp 
s2[5] = 'x';
s25์˜ ํ‘œํ˜„์€ CharProxy๊ฐ์ฒด๋ฅผ ๋ฐ˜ํ™˜ํ•œ๋‹ค. ๊ทธ๋ฆฌ๊ณ  ํ• ๋‹น(assignment)์—ฐ์‚ฐ์ž์˜ ๋ชฉํ‘œ๊ฐ€ ๋œ๋‹ค.์–ด๋–ค ํ• ๋‹น(assignment) ์—ฐ์‚ฐ์ž๊ฐ€ ๋ถˆ๋ ค์ง€๋Š” ๊ฑธ๊นŒ? ํ• ๋‹น์˜ ๋ชฉํ‘œ๋Š” CharProxy์ด๋‹ค. ๊ทธ๋ž˜์„œ ํ• ๋‹น์—ฐ์‚ฐ์ž๋Š” CharProxy ํด๋ž˜์Šค ์•ˆ์—์„œ ๋ถˆ๋ ค์ง„๋‹ค. ์ด๊ฒƒ์€ ์ค‘์š”ํ•œ ๊ฒƒ์ด๋‹ค. ์™œ๋ƒํ•˜๋ฉด CharProxy์˜ ํ• ๋‹น(assignment) ์—ฐ์‚ฐ์ž๋ฅผ ์‚ฌ์šฉํ•˜๋Š”๊ฒƒ์œผ๋กœ ์šฐ๋ฆฌ๋Š” Stirng์—์„œ lvalue๋กœ์„œ ์ด๋ฒˆ ์—ฐ์‚ฐ์ด ์ˆ˜ํ–‰๋œ๋‹ค๋Š” ๊ฒƒ์„ ์•Œ์ˆ˜์žˆ๋‹ค. ๊ทธ๋ž˜์„œ ์šฐ๋ฆฌ๋Š” ๋ฌธ์ž์—ด ํด๋ž˜์Šค๊ฐ€ ์ด๋ฒˆ์—๋Š” lvalue์— ์•Œ๋งž๋Š” ๋™์ž‘์„ ํ•ด์•ผ ํ•œ๋‹ค๋Š” ๊ฒฐ๋ก ์„ ์–ป๋Š”๋‹ค.

๋น„์Šทํ•˜๊ฒŒ ๋‹ค์Œ๊ณผ ๊ฐ™์€ ๊ตฌ๋ฌธ์„ ๋ณด๋ฉด

~cpp 
s1[3] = s2[8];
์ด๊ฒƒ์€ ๋‘๊ฐœ์˜ CharProxy๋ฅผ ์œ„ํ•ด์„œ ํ• ๋‹น ์—ฐ์‚ฐ์ž๊ฐ€ ๋™์ž‘ํ•˜๊ณ , ํ•˜๋‚˜๋Š” char์œผ๋กœ ์•”์‹œ์  ๋ณ€ํ™˜, ๋˜ ํ•˜๋‚˜๋Š” CharProxy๊ฐ์ฒด์˜ ํ• ๋‹น ์—ฐ์‚ฐ์ž๋ฅผ ์‚ฌ์šฉํ•˜๋Š” ๊ฒƒ
์œผ๋กœ ๋‘˜์€ lvalue์™€ rvalue๋ฅผ ๊ตฌ๋ถ„ํ•˜๊ณ  ์˜ฌ๋ฐ”๋ฅด๊ฒŒ ์‚ฌ์šฉํ•˜๊ฒŒ ๋œ๋‹ค.
์ž, ์—ฌ๊ธฐ ๊ทธ๋Ÿผ String์˜ operator[]์— ๋Œ€ํ•œ ์ƒˆ๋กœ์šด ๊ตฌํ˜„ ์ฝ”๋“œ๊ฐ€ ์žˆ๋‹ค.

~cpp 
const String::CharProxy String::operator[](int index) const
{
    return CharProxy(const_cast<String&>(*this), index);
}
String::CharProxy String::operator[](int index)
{
    return CharProxy(*this, index);
}
๊ฐ ํ•จ์ˆ˜๋Š” ๋ฌธ์ž ์š”๊ตฌ์‹œ์— CharProxy ๊ฐ์ฒด๋ฅผ ๋งŒ๋“ค์–ด์„œ ๋ฐ˜ํ™˜ํ•œ๋‹ค. ๋ฌธ์ž์—ด์€ ์Šค์Šค๋กœ๋Š” ์•„๋ฌด ์ผ์„ ํ•˜์ง€ ๋ชปํ•œ๋‹ค. ์šฐ๋ฆฌ๋Š” ๊ทธ๋Ÿฌํ•œ ๋™์ž‘์„ ์ฝ๊ธฐ์™€ ์“ฐ๊ธฐ์˜ ์ ‘๊ทผ์„ ์•Œ์ˆ˜์žˆ์„๋•Œ ๊นŒ์ง€ ์ง€์—ฐ์‹œํ‚ค๋„๋ก ๋งŒ๋“ค์–ด์•ผ ํ•œ๋‹ค.

const ๋ฒ„์ „์˜ operator[] ๋Š” const proxy ๊ฐ์ฒด๋ฅผ ๋ฐ˜ํ™˜ํ•ด์•ผ ํ•˜๋Š” ๊ฒƒ์„ ๋ณด์ž. CharProxy::operator=์€ const ๋ฉค๋ฒ„ ํ•จ์ˆ˜๊ฐ€ ์ด๋‹ˆ๊ธฐ ๋•Œ๋ฌธ์— ํ• ๋‹น(assignment)์˜ ๋ชฉํ‘œ๊ฐ€ ๋˜์ง€ ์•Š๋Š”๋‹ค. ๊ทธ๋Ÿฌ๋ฏ€๋กœ, proxy๋Š” const ๋ฒ„์ „์˜ operator[]๋‚˜, lvalue๋กœ์„œ์˜ ๋ฌธ์ž์—ด์˜ ์‚ฌ์šฉ์„ ๊ณ ๋ คํ•˜์ง€ ์•Š์•„๋„ ๋œ๋‹ค. ๊ฐ„๋‹จํžˆ, const ๋ฒ„์ „์˜ operator[]์—์„œ๋„ ์ •ํ™•ํžˆ ๋Œ์•„๊ฐ„๋‹ค๋Š” ์ด์•ผ๊ธฐ์ด๋‹ค.

์ด๋ฒˆ์—๋Š” CharProxy๋ฅผ ๋งŒ๋“ค๋•Œ const๋ฒ„์ „์˜ operator[]์—์„œ const_cast(Item 2์ฐธ๊ณ )๋ฅผ ์‚ฌ์šฉํ•ด์„œ *this๋ฅผ ๋„˜๊ธฐ๋Š”๊ฑธ ์ฃผ๋ชฉํ•˜์ž.์ €๊ฒƒ์€ CharProxy์ƒ์„ฑ์ž์— ์กฐ๊ฑด์— ๋ถ€ํ•ฉํ•˜๊ธฐ ์œ„ํ•œ ์ˆ˜ํ–‰์œผ๋กœ, non-const String๋งŒ ์ธ์ž๋กœ ๋ฐ›๊ธฐ์œ„ํ•ด์„œ ํ˜•๋ณ€ํ™˜์„ ์ˆ˜ํ–‰ํ•œ๋‹ค. ํ˜•๋ณ€ํ™˜์€ ๋ณดํ†ต์€ ๊ท€์ฐฎ๋‹ค. ๊ทธ๋ ‡์ง€๋งŒ ์ด๋Ÿฌํ•œ ๊ฒฝ์šฐ์— CharProxy ๊ฐ์ฒด๋Š” ๊ทธ๊ฒƒ ์ž์ฒด๊ฐ€ const์ด๊ธฐ ๋•Œ๋ฌธ์— String๊ฐ€ ํฌํ•จํ•˜๊ณ  ์žˆ๋Š” proxy๊ฐ€ ์ฐธ์กฐํ•˜๋Š” String์€ ์ˆ˜์ •๋˜์–ด์ง€๋Š” ๊ฑฑ์ •์ด ์—†์„ ๊ฒƒ์ด๋‹ค.

operator[]์— ์˜ํ•ด ๋ฐ˜ํ™˜๋˜๋Š” ๊ฐ proxy๋Š” ํ‘œํ˜„์„ ์œ„ํ•˜์—ฌ ๋ฌธ์ž๋กœ์„œ ํ•„์š”ํ•œ ์ธ๋ฑ์Šค์™€ ๊ธ€์ž ์ •๋ณด๋ฅผ ์ˆ˜๋กํ•˜๊ณ  ์žˆ๋‹ค.

~cpp 
String::CharProxy::CharProxy(String& str, int index)
: theString(str), charIndex(index) {}
rvalue๋กœ์˜ proxy์˜ ํ˜•๋ณ€ํ™˜์€ ๊ณง๋ฐ”๋กœ ์ผ์–ด ๋‚œ๋‹ค. ์ฆ‰, ๋‹จ์ง€ proxy์—์„œ ํ˜•๋ณ€ํ™˜์œผ๋กœ ํ•ด๋‹นํ•˜๋Š” ์ˆ˜ํ–‰๋งŒ ํ•ด์ฃผ๋ฉด ๋œ๋‹ค.

~cpp 
String::CharProxy::operator char() const
{
    return theString.value->data[charIndex];
}
๋งŒ์•ฝ String๊ฐ์ฒด์™€ ๊ด€๊ณ„๋ฅผ ์ฝ์–ด ๋ฒ„๋ ธ๋‹ค๋ฉด, value ๋ฉค๋ฒ„์™€ data ๋ฉค๋ฒ„์™€์˜ ๊ด€๊ณ„์— ๋Œ€ํ•˜์—ฌ Itmem 29๋ฅผ ๋ณด๊ณ  ๊ธฐ์–ตํ•ด๋ผ. ์ด ํ•จ์ˆ˜๋Š” ๋ฌธ์ž๋ฅผ ๊ฐ’์œผ๋กœ(by-value)๋กœ ์ „๋‹ฌํ•œ๋‹ค. ๊ทธ๋ฆฌ๊ณ  C++์€ ๊ทธ๋Ÿฌํ•œ ๊ฐ’์œผ๋กœ(by-value) ์ „๋‹ฌ์„ ๋ฐ˜ํ™˜ ๊ฐ’์œผ๋กœ๋งŒ ๋ฐ˜ํ™˜ ๊ฐ’์„ ์‚ฌ์šฉํ•˜๋„๋ก ์ œํ•œํ•˜๊ธฐ ๋•Œ๋ฌธ์— ๋‹ค์Œ๊ณผ ๊ฐ™์€ ํ˜•๋ณ€ํ™˜ ํ•จ์ˆ˜๋Š” ์˜ค์ง rvalue๋•Œ๋งŒ ์œ ํšจํ•˜๋‹ค.

๊ทธ๋ž˜์„œ CharProxy์˜ ํ• ๋‹น(assignment) ์—ฐ์‚ฐ์ž ๊ตฌํ˜„์œผ๋กœ lvalue์— ํ•ด๋‹นํ•˜๋Š” ์ž‘์—…๋งŒ ๊ฐ€๋Šฅํ•˜๊ฒŒ ๊ตฌํ˜„ํ• ์ˆ˜ ์žˆ๋‹ค. ์ด์ œ CharProxy์˜ ํ• ๋‹น ์—ฐ์‚ฐ์ž๋ฅผ ๋‹ค์Œ๊ณผ ๊ฐ™์ด ๊ตฌํ˜„ํ•œ๋‹ค.

~cpp 
String::CharProxy&
String::CharProxy::operator=(const CharProxy& rhs)
{
    // ๋งŒ์•ฝ ๋ฌธ์ž์—ด์ด ๋‹ค๋ฅธ String๊ฐ์ฒด์™€ ๊ฐ’์„ ๊ณต์œ ๊ฐ€ ๊ฐ€๋Šฅํ•  ๊ฒฝ์šฐ
    if (theString.value->isShared()) {
        theString.value = new StringValue(theString.value->data);
    }

    // ๋ฌธ์ž ๊ฐ’์˜ ๋ณต์‚ฌ ๊ณผ์ •
    theString.value->data[charIndex] 
        = rhs.theString.value->data[rhs.charIndex];

    return *this;
}

Item 29์— ๋‚˜์™€์žˆ๋Š”, non-const String::operator[]๊ณผ ๋น„๊ตํ•ด๋ณด๋ฉด ์ธ์ƒ์ ์ธ ๋А๋‚Œ์ด ์˜ฌ๊ฒƒ์ด๋‹ค. ์ด๊ฒƒ์€ ์˜ˆ์ธกํ• ์ˆ˜ ์žˆ๋‹ค. Item29์—์„œ๋Š” ์ด๋Ÿฌํ•œ ์“ฐ๊ธฐ์™€ ์ฝ๊ธฐ๋ฅผ ๊ตฌ๋ถ„ํ•˜์ง€ ๋ชปํ•ด์„œ ๋ฌด์กฐ๊ฑด non-const operator[]๋ฅผ ์“ฐ๊ธฐ๋กœ ์ทจ๊ธ‰ํ–ˆ๋‹ค. ๊ทธ๋ฆฌ๊ณ , CharProxy๋Š” String์— ๋Œ€ํ•œ ์ž์œ ๋กœ์šด ์ ‘๊ทผ์„ ์œ„ํ•ด friend๋กœ ์„ ์–ธํ–ˆ๊ธฐ์— ๋ฌธ์ž๊ฐ’์˜ ๋ณต์‚ฌ ๊ณผ์ •์˜ ์ˆ˜ํ–‰์ด ๊ฐ€๋Šฅํ•˜๋‹ค.

์ด์ œ ๋‚˜๋จธ์ง€ ์ง์ ‘ ๋ฌธ์ž์—ด์ด ์ž…๋ ฅ๋ ๋•Œ๋ฅผ ๊ตฌํ˜„ํ•œ๋‹ค.

~cpp 
The second CharProxy assignment operator is almost identical:  ยค Item M30, P58 

String::CharProxy& String::CharProxy::operator=(char c)
{
    if (theString.value->isShared()) {
        theString.value = new StringValue(theString.value->data);
    }

    theString.value->data[charIndex] = c;

    return *this;
}
Software Engineer์„ ์ˆ˜ํ–‰ํ•˜๋Š” ์ž…์žฅ์ด๋ผ๋ฉด ๋ฌผ๋ก  ์ด์™€ ๊ฐ™์ด CharProxy๋ฅผ ํ†ตํ•ด์„œ ์ฝ๊ธฐ์™€ ์“ฐ๊ธฐ๋ฅผ ๊ตฌ๋ถ„ํ•ด์„œ, ๋ณต์‚ฌ์— ํ•ด๋‹นํ•˜๋Š” ์ฝ”๋“œ๋ฅผ ์‚ญ์ œํ•ด์•ผ ํ•œ๋‹ค.ํ•˜์ง€๋งŒ ์ด๊ฒƒ์— ๋Œ€ํ•œ ๊ฒฐ์ ์„ ์ƒ๊ฐํ•ด ๋ณด์ž.

2.3. Limitations : ์ œํ•œ

proxy ํด๋ž˜์Šค์˜ ์‚ฌ์šฉ์€ operator[] ์‚ฌ์šฉ์‹œ lvalue์™€ rvalue์˜ ๊ตฌ๋ถ„์„ ๋ช…๋ฃŒํ•˜๊ฒŒ ํ•œ๋‹ค. ๊ทธ๋ ‡์ง€๋งŒ ๋ฌด์‹œํ• ์ˆ˜ ์—†๋Š” ๊ฒฐ์ ์„ ๊ฐ€์ง€๊ณ  ์žˆ๋‹ค. proxy๊ฐ์ฒด๋Š” ๊ทธ๋“ค์ด ๋ชฉํ‘œํ•˜๋Š” ๊ฐ์ฒด๋ฅผ ์™„์ „ํžˆ ๊ต์ฒดํ•˜๋Š” ๊ฒƒ์ด ๋ชฉํ‘œ์ง€๋งŒ ์ •๋ง ์–ด๋ ต๋‹ค. ์—ฌ๊ธฐ์—์„œ ๋ฌธ์ž์ฒ˜๋Ÿผ, lvalue์™€ rvalue์˜ ๋ชฉ์ ๋ฟ ์•„๋‹ˆ๋ผ. ๋‹ค๋ฅธ ๋ฐฉ๋ฒ•์œผ๋กœ ๊ฐ์ฒด๋Š” ์ ‘๊ทผ๋ ์ˆ˜ ์žˆ๋‹ค.

Item 29์— ์–ธ๊ธ‰๋œ ๊ณต์œ ํ”Œ๋ž˜๊ทธ๋ฅผ ๋”ํ•œ StringValue๊ฐ์ฒด์— ๊ด€ํ•ด์„œ ๋‹ค์‹œ ์ƒ๊ฐํ•ด ๋ณด์ž. ๋งŒ์•ฝ String::operator[] ๊ฐ€ char&๋Œ€์‹ ์— CharProxy๋ฅผ ๋ฐ˜ํ™˜ํ•œ๋‹ค๋ฉด ์ด๋Ÿฌํ•œ ๊ฒฝ์šฐ๋Š” ๋”์ด์ƒ ์ปดํŒŒ์ผ ํ• ์ˆ˜๊ฐ€ ์—†๋‹ค.

~cpp 
String s1 = "Hello";
char *p = &s1[1];            // ์—๋Ÿฌ!
s11์˜ ํ‘œํ˜„์€ CharProxy๋ฅผ ๋ฐ˜ํ™˜ํ•˜๊ธฐ ๋•Œ๋ฌธ์—, ๋‘๋ฒˆ์งธ์—์„œ ์˜ค๋ฅธ์ชฝ์˜ ์˜๋ฏธ๋Š” CharProxy*๋ฅผ ๋ฐ˜ํ™˜ํ•˜๋Š” ๊ฒƒ์ด๋‹ค. ํ•˜์ง€๋งŒ CharProxy*๋ฅผ char*๋กœ ๋ฐ”๊พธ๋Š” ํ˜•๋ณ€ํ™˜์€ ํ—ˆ์šฉ๋˜์ง€ ์•Š๊ธฐ๋•Œ๋ฌธ์— p์˜ ์ดˆ๊ธฐํ™”์—์„œ ์ปดํŒŒ์ผ๋Ÿฌ๋Š” ์—๋Ÿฌ๋ฅผ ๋‚ธ๋‹ค. ์ผ๋ฐ˜์ ์œผ๋กœ proxy์˜ ์ฃผ์†Œ๋Š” ์‹ค์ œ ๊ฐ์ฒด๋ณด๋‹ค ๋‹ค๋ฅธ ํฌ์ธํ„ฐ ํƒ€์ž…์„ ๊ฐ€์ง„๋‹ค.

์ด๋Ÿฌํ•œ ๋ฌธ์ œ๋ฅผ ์ œ๊ฑฐํ•˜๊ธฐ ์œ„ํ•˜์—ฌ ์ฃผ์†Œ์— ๊ด€ํ•œ ์—ฐ์‚ฐ์ž๋ฅผ CharProxy ํด๋ž˜์Šค์— ์˜ค๋ฒ„๋กœ๋“œ(overload)ํ•œ๋‹ค.

~cpp 
class String {
public:
    class CharProxy {
    public:
        ...
        char * operator&();
        const char * operator&() const;
        ...
    };
    ...
};
์ด ํ•จ์ˆ˜๋Š” ๊ตฌํ˜„ํ•˜๊ธฐ ์‰ฝ๋‹ค. const ํ•จ์ˆ˜๋Š” ๋‹จ์ง€ const ๋ฒ„์ „์˜ ๋ฌธ์ž์˜ ํฌ์ธํ„ฐ๋ฅผ ํ”„๋ก์‹œ ํด๋ž˜์Šค๋กœ ์ „๋‹ฌํ•˜๋ฉด ๋œ๋‹ค.

~cpp 
const char * String::CharProxy::operator&() const
{
    return &(theString.value->data[charIndex]);
}

non-const ํ•จ์ˆ˜์˜ ๊ฒฝ์šฐ ์ข€๋” ์‹ ๊ฒฝ์“ธ๊ฒƒ์ด ๋งŽ์€๋ฐ, ๋ฐ˜ํ™˜๋˜๋Š” ํฌ์ธํ„ฐ์˜ ๋ฌธ์ž๊ฐ€ ์ˆ˜์ • ๊ฐ€๋Šฅ์„ฑ์ด ์žˆ๊ธฐ ๋•Œ๋ฌธ์ด๋‹ค. ์ด๋Ÿฌํ•œ ๊ฒฝ์šฐ๋Š” Item 29์—์„œ ๋‹ค๋ฃจ์—ˆ๋˜ non-const ๋ฒ„์ „์˜ String::operator[]์˜ ๋ชจ์Šต๊ณผ ๋น„์Šทํ•˜๋‹ค.๊ทธ๋ฆฌ๊ณ  ๊ตฌํ˜„ ์—ญ์‹œ ๋น„์Šทํ•˜๋‹ค.

~cpp 
char * String::CharProxy::operator&()
{
    // ๋‹ค๋ฅธ ๊ฐ์ฒด์™€ ์ •๋ณด๋ฅผ ๊ณต์œ ํ• ๋•Œ๋Š” ์ƒˆ ์ž๋ฃŒ๋ฅผ ๋งŒ๋“ ๋‹ค.
    if (theString.value->isShared()) {
        theString.value = new StringValue(theString.value->data);
    }
    // ์ด์ œ ์ด ํ•จ์ˆ˜๊ฐ€ ๋ฐ˜ํ™˜ํ•˜๋Š” ๊ฐ์ฒด๋ฅผ ํ†ตํ•˜์—ฌ ์ˆ˜์ •ํ• ์ˆ˜ ์žˆ๋‹ค. ๊ทธ๋Ÿฌ๋ฏ€๋กœ
    // ๊ณต์œ  ๋ชปํ•˜๋„๋ก ๋ง‰๋Š”๋‹ค.
    theString.value->markUnshareable();

    return &(theString.value->data[charIndex]);
}
์ด ์ฝ”๋“œ๋Š” CharProxy์˜ ๋‹ค๋ฅธ ๋ฉค๋ฒ„ ํ•จ์ˆ˜๋“ค๊ณผ ๊ฐ™์ด ํ‰๋ฒ”ํ•˜๋‹ค.

๋‘๋ฒˆ์งธ์˜ ๊ฒฐ๊ณผ, CharProxy๊ฐ€ ๋‹ค๋ฅธ์ ์€ lvalue์™€ rvalue์˜ ๊ตฌ๋ถ„์„ ์œ„ํ•ด operator[]๊ฐ€ ์ ์šฉ๋œ ํ”„๋ก์‹œ ํด๋ž˜์Šค๋ฅผ ์‚ฌ์šฉํ•˜๋Š”, ์ฐธ์กฐ์„ธ๊ธฐ ๋ฐฐ์—ด ํ…œํ”Œ๋ฆฟ์ด๋ผ๋ฉด, ํ™•์—ฐํžˆ ๋“œ๋Ÿฌ๋‚˜๋Š” ๊ฒƒ์ด๋‹ค.

~cpp 
template<class T>                        // ํ”„๋ก์‹œ๋ฅผ ์‚ฌ์šฉํ•˜๋Š”
class Array {                            // ์ฐธ์กฐ์„ธ๊ธฐ ์ ์šฉ ๋ฐฐ์—ด
public:
     class Proxy {
    public:
        Proxy(Array<T>& array, int index);
        Proxy& operator=(const T& rhs);
        operator T() const;
        ...
    };

    const Proxy operator[](int index) const;
    Proxy operator[](int index);
    ...
};
์ด๋ ‡๊ฒŒ ๊ตฌํ˜„๋œ ๋ฐฐ์—ด์„ ์–ด๋–ป๊ฒŒ ์‚ฌ์šฉํ•˜๋Š”๊ฐ€ ๋ณด์ž.

~cpp 
Array<int> intArray;
...
intArray[5] = 22;                    // ์˜ณ๋‹ค.

intArray[5] += 5;                    // ์—๋Ÿฌ!

++intArray[5];                       // ์—๋Ÿฌ!
์˜ˆ์ƒ๋˜๋Š” ๋Œ€๋กœ operator[]์˜ ๋ชฉํ‘œ์ธ ๊ฐ„๋‹จํ•œ ํ• ๋‹น(assignment)์€ ์„ฑ๊ณตํ•˜์ง€๋งŒ, left-hand์˜ operator[]์—์„œ operator+=์ด๋‹ˆ operator-=๋ฅผ ํ˜ธ์ถœํ•˜๋Š”๊ฑด ์‹คํŒจํ•œ๋‹ค. ์™œ๋ƒํ•˜๋ฉด operator[]๊ฐ€ ๋ฐ˜ํ™˜ํ•˜๋Š” ๊ฒƒ์€ ํ”„๋ก์‹œ ๊ฐ์ฒด ์ด๊ธฐ ๋–„๋ฌธ์ด๋‹ค. ๋น„์Šทํ•œ ๊ฒฝ์šฐ์— ์กด์žฌํ•˜๋Š” ๋ชจ๋“  ์—ฐ์‚ฐ์ž๊ฐ€ ์‹คํŒจํ•œ๋‹ค. operator*=, operator/=, operator<<=, operator-= ๋“ฑ ๋ง์ด๋‹ค. ๋งŒ์•ฝ ์ด๋Ÿฐ ์ˆ˜ํ–‰์„ ์›ํ•œ๋‹ค๋ฉด ์ด๋Ÿฌํ•œ ํ•จ์ˆ˜๋ฅผ ๋ชจ๋‘ ์„ ์–ธํ•ด์ฃผ์–ด์•ผ ํ•˜๋Š”๋ฐ, ์ด๋Š” ๋„ˆ๋ฌด ์ผ์ด ๋งŽ๋‹ค ๊ทธ๋ฆฌ๊ณ  ์•„๋งˆ ์›ํ•˜์ง€๋„ ์•Š์„ ๊ฒƒ์ด๋‹ค. ์ถ”๊ฐ€ํ•œ๋“ค ์ถ”๊ฐ€ํ•˜์ง€ ์•Š์€๋“ค ๋‘˜๋‹ค ๊ดด๋กœ์šด ์ผ์ด๋‹ค.

๊ด€๊ณ„์žˆ๋Š” ๋ฌธ์ œ๋กœ ํ”„๋ก์‹œ๋ฅผ ํ†ตํ•œ ์‹ค์ œ ๊ฒ์ฒด์˜ ํ˜ธ์ถœ์—์„œ ์ผ์–ด๋‚ ์ˆ˜ ์žˆ๋Š”๋ฐ, ํ• ์ˆ˜ ์—†๋Š”๊ฒƒ์— ๊ด€ํ•œ ๋ชจํ˜ธ์„ฑ์ด๋‹ค. ์˜ˆ๋ฅผ๋“ค์–ด์„œ, ์œ ๋ฆฌ์ˆ˜ ๋ฐฐ์—ด์„ ์ฐธ์กฐ์„ธ๊ธฐ๋กœ ๊ตฌํ˜„ํ–ˆ๋‹ค๊ณ  ํ•ด๋ณด์ž. ์ด๊ฒƒ์„ Rational ํด๋ž˜์Šค๋กœ ์ •์˜ํ•˜๊ณ  Array ํ…œํ”Œ๋ฆฟ์„ ์‚ฌ์šฉํ•œ๋‹ค. ์ฝ”๋“œ๋Š” ๋‹ค์Œ๊ณผ ๊ฐ™๋‹ค.

~cpp 
class Rational {
public:
    Rational(int numerator = 0, int denominator = 1);
    int numerator() const;
    int denominator() const;
    ...
};
Array<Rational> array;
์ด๋Š” ์˜ˆ์ธกํ• ์ˆ˜ ์žˆ๋Š” ๋ฐฐ์—ด์˜ ์‚ฌ์šฉ์ด๋‹ค. ํ•˜์ง€๋งŒ ํ—ˆ์šฉ๋˜์ง€ ์•Š๋Š”๋‹ค.

~cpp 
cout << array[4].numerator();                     // ์—๋Ÿฌ!

int denom = array[22].denominator();              // ์—๋Ÿฌ!
์ด๋Ÿฌํ•œ ์–ด๋ ค์›€์€ ์ถฉ๋ถ„ํžˆ ์˜ˆ์ƒ๋œ๋‹ค. operator[]๊ฐ€ ๋ฐ˜ํ™˜ํ•˜๋Š” ์œ ๋ฆฌ์ˆ˜์— ๊ด€ํ•œ ํ”„๋ก์‹œ์ด์ง€ ์ง„์งœ Rational๊ฐ์ฒด๊ฐ€ ์•„๋‹ˆ๋‹ค. numerator๊ณผ denominator ๋ฉค๋ฒ„ ํ•จ์ˆ˜๋Š” Rational์œ„ํ•ด์„œ๋งŒ ์กด์žฌํ•˜์ง€ ํ”„๋ก์‹œ๋ฅผ ์œ„ํ•ด์„œ๋Š” ์กด์žฌํ•˜์ง€ ์•Š๋Š”๋‹ค. ๊ทธ๋Ÿฌ๋ฏ€๋กœ ์ปดํŒŒ์ผ๋Ÿฌ๊ฐ€ ์ด์— ๋Œ€ํ•œ ์ˆ˜ํ–‰์„ ๋ชปํ•œ๋‹ค. ํ”„๋ก์‹œ๋ฅผ ๋งŒ๋“œ๋Š”๊ฒƒ์€ ๊ทธ๋“ค์ด ์˜๋ฏธํ•˜๋Š” ๊ฐ์ฒด์™€ ๋น„์Šทํ•œ๊ฑฐ์ง€ ์™„์ „ํžˆ ๋™์ผํ•œ ๊ฐ์ฒด์˜ ๊ธฐ๋Šฅ์„ ์ œ๊ณตํ• ์ˆ˜ ์—†๋‹ค.

์•„์ง๋„ ํ”„๋ก์‹œ๊ฐ€ ์ง„์งœ ๊ฐ์ฒด๋ฅผ ๊ต์ฒดํ•˜๊ธฐ ํž˜๋“  ๋ฌธ์ œ๋Š” ๋‚จ์•„ ์žˆ๋‹ค. ๋‹ค์Œ๊ณผ ๊ฐ™์ด reference๋กœ ๋„˜๊ธธ๋•Œ ์กฐ์ฐจ ๋ง์ด๋‹ค.

~cpp 
void swap(char& a, char& b);    // a ์™€ b์˜ ๊ฐ’์„ ๋ฐ”๊พผ๋‹ค.

String s = "+C+";               // ์—๊ตฌ, ์ด๊ฑฐ ์ด ๋ฌธ์ž์—ด์€ "C++" ์ผํ…๋ฐ.

swap(s[0], s[1]);               // ๊ทธ๊ฒƒ์„ ๊ณ ์น ๋ ค๊ณ  ํ•œ๋‹ค.
String::operator[]๋Š” CharProxy๋ฅผ ๋ฐ˜ํ™˜ํ•˜์ง€๋งŒ swap๊ฐ€ ์›ํ•˜๋Š” ๊ฒƒ์€ char&์ด๋‹ค. CharProxy๋Š” ์•„๋งˆ ์•”์‹œ์ (implicit) ํ˜•๋ณ€ํ™˜์œผ๋กœ char๋กœ ๋ณ€ํ™”ํ• ๊ฒƒ์ด๊ณ  char&๋กœ๋Š” ๋ณ€ํ™˜์ด ํ•„์š” ์—†๋‹ค. ๊ฐœ๋‹ค๊ฐ€ ํ˜•๋ณ€ํ™˜๋œ char์€ swap๋‚ด๋ถ€์—์„œ ์ˆ˜ํ–‰์— ์†Œ์šฉ์ด ์—†๋‹ค. ์™œ๋ƒํ•˜๋ฉด, char์€ ์ž„์‹œ ๊ฐ์ฒด์ด๊ธฐ ๋•Œ๋ฌธ์ด๋‹ค. ์ด์— ๋Œ€ํ•œ๊ฒƒ์€ Item 19์— ์ž์„ธํžˆ ์–ธ๊ธ‰๋˜์–ด ์žˆ๋‹ค.

๋งˆ์ง€๋ง‰ ํ”„๋ก์‹œ๊ฐ€ ์‹คํŒจํ•˜๋Š” ์ง„์งœ ๊ฐ์ฒด๋ฅผ ๊ต์ฒดํ•˜์ง€ ๋ชปํ•˜๋Š” ์ƒํ™ฉ์€ ์•”์‹œ์ (implicit) ํ˜•๋ณ€ํ™˜์—์„œ ๊ธฐ์ธํ•œ๋‹ค. ํ”„๋ก์‹œ ๊ฐ์ฒด๋Š” ์•”์‹œ์ (implicit)์œผ๋กœ ์ง„์งœ ๊ฐ์ฒด๋กœ ํ˜•๋ณ€ํ™˜ํ• ๋•Œ user-defined ํ˜•๋ณ€ํ™˜ ํ•จ์ˆ˜๊ฐ€ ๋ถˆ๋ฆฐ๋‹ค. ์˜ˆ๋ฅผ๋“ค์–ด์„œ CharProxy๋Š” char๋กœ operator char์„ ํ˜ธ์ถœํ•ด์„œ ๋ณ€ํ™”ํ•œ๋‹ค. Item 5์˜ ์„ค๋ช…์„ ๋ณด๋ฉด ์ปดํŒŒ์ผ๋Ÿฌ๋Š” user-defined ํ˜•๋ณ€ํ™˜ ํ•จ์ˆ˜๋ฅผ ๋ฐ˜์‘ํ•˜๋Š” ์ธ์ž๋กœ์˜ ํ•„์š”์„ฑ์ด ์žˆ๋Š” ๋ถ€๋ถ„์—์„œ ํ•ด๋‹น ์—ฐ์‚ฐ์„ ํ˜ธ์ถœํ•œ๋‹ค๊ณ  ํ•œ๋‹ค. ๊ฒฐ๊ตญ ํ•จ์ˆ˜ ํ˜ธ์ถœ์€ ํ”„๋ก์‹œ๊ฐ€ ์ „๋‹ฌ๋ ๋•Œ ์‹คํŒจํ•˜๋ฉด ์‹ค์ œ ๊ฐ์ฒด๋ฅผ ๋„˜๊ธฐ๋Š” ๊ฒƒ์„ ์„ฑ๊ณต์‹œ์ผœ์„œ ๊ฐ€๋Šฅํ•œ ๊ฒƒ์ด๋‹ค. ์˜ˆ๋ฅผ๋“ค์–ด์„œ TVStation๋ฆฌํ•˜๋Š” ํด๋ž˜์Šค์— watchTV ํ•จ์ˆ˜๊ฐ€ ์žˆ๋‹ค๊ณ  ํ•œ๋‹ค๋ฉด:

~cpp 
class TVStation {
public:
    TVStation(int channel);
     ...

};

void watchTV(const TVStation& station, float hoursToWatch);
์•”์‹œ์  ์ˆ˜ํ–‰์— ์˜ํ•ด์„œ ์šฐ๋ฆฌ๋Š” ๋‹ค์Œ๊ณผ ๊ฐ™์ด ์ˆ˜ํ–‰ํ• ์ˆ˜ ์žˆ๋‹ค.

~cpp 
watchTV(10, 2.5);   // 10๋ฒˆ ๋ณธ๋‹ค. 2.5์‹œ๊ฐ„ ๋ณธ๋‹ค.
ํ•˜์ง€๋งŒ ํ”„๋ก์‹œ ์‚ฌ์šฉ, ์ฐธ์กฐ์„ธ๊ธฐ ์ ์šฉ ๋ฐฐ์—ด์„ ์‚ฌ์šฉํ•œ๋‹ค๋ฉด

~cpp 
Array<int> intArray;

intArray[4] = 10;

watchTV(intArray[4], 2.5);
์ด ๋ฌธ์ œ๋Š” ์•”์‹œ์  ํ˜•๋ณ€ํ™˜์ด ์ฃผ๋Š” ๋˜ ํ•˜๋‚˜์˜ ๋ฌธ์ œ์ด๋‹ค. ์ด๊ฒƒ์„ ํ•ด๊ฒฐํ•˜๊ธฐ๋Š” ์–ด๋ ต๋‹ค. ์‚ฌ์‹ค TVStation์— ์ƒ์„ฑ์ž๋ฅผ explicit๋กœ ์„ ์–ธํ•˜๋Š” ๊ฒƒ์ด ๋” ์ข‹์€ ๋””์ž์ธ์ผ ๊ฒƒ์ด๋‹ค. ๊ทธ๋ ‡๋‹ค๋ฉด watchTV์—์„œ ์ปดํŒŒ์ผ์ด ์‹คํŒจํ•œ๋‹ค. explicit์— ๊ด€ํ•œ ์ž์„ธํ•œ ์„ค๋ช…์€ Item 5๋ฅผ ์ฐธ๊ณ ํ•˜๋ผ

2.4. Evaluation : ํ‰๊ฐ€

Proxyํด๋ž˜์Šค๋Š” ๊ตฌํ˜„ํ•˜๊ธฐ ์–ด๋ ค์šด ์–ด๋–ค ์ƒํ™ฉ์—์„œ ํ•ด๊ฒฐ์ฑ…์ด ๋ ์ˆ˜ ์žˆ๋‹ค. ๋‹ค์ฐจ์› ๋ฐฐ์—ด์ด ์ฒซ๋ฒˆ์งธ, lvaue/rvalue๊ฐ€ ๋‘๋ฒˆ์งธ , ์•”์‹œ์  ํ˜•๋ณ€ํ™˜ ๊ธˆ์ง€๊ฐ€ ์„ธ๋ฒˆ์งธ ์ด๋‹ค.

๋˜ Proxy ํด๋ž˜์Šค๋Š” ๋‹จ์ ๋„ ๋งŽ์ด๋„ ๊ฐ€์ง€๊ณ  ์žˆ๋‹ค. ํ•จ์ˆ˜๊ฐ€ ๊ฐ’์„ ๋ฐ˜ํ™˜ํ• ๋•Œ ํ”„๋ก์‹œ ๊ฐ์ฒด๋“ค์€ ์ž„์‹œ ์ธ์ž(temporaries:Item 19์ฐธ๊ณ )๋กœ ์ „๋‹ฌ๋œ๋‹ค. ๊ทธ๋ž˜์„œ ๊ทธ๋“ค์€ ์ƒ์„ฑ, ์‚ญ์ œ๋œ๋‹ค. ์ด๊ฒƒ์€ ๊ณต์งœ๊ฐ€ ์•„๋‹ˆ๋‹ค. ์ฝ๊ธฐ์™€ ์“ฐ๊ธฐ์˜ ๊ฒฝ์šฐ๋ฅผ ๊ฐ€๋ฆฌ๊ธฐ ์œ„ํ•œ ์กฐ์น˜๋„, ์ž„์‹œ์ธ์ž๋ฅผ ๋งŒ๋“ค๊ธฐ ๋•Œ๋ฌธ์— ๋น„์šฉ์ด ๋ฐœ์ƒํ•œ๋‹ค. ํ”„๋ก์‹œ ํด๋ž˜์Šค๊ฐ€ ์žˆ์–ด์„œ ์†Œํ”„ํŠธ์›จ์–ด ๊ตฌ์กฐ๋Š” ๋ณต์žกํ•ด ์ง„๋‹ค. ๋” ์–ด๋ ค์šด ๋””์ž์ธ, ๊ตฌํ˜„, ์ดํ•ด ๊ทธ๋ฆฌ๊ณ  ์œ ์ง€ ๋ณด์ˆ˜..

๋งˆ์ง€๋ง‰์œผ๋กœ ์ง„์งœ ๊ฐ์ฒด์— ๋Œ€ํ•œ ์ผ์˜ ๋Œ€ํ–‰์€ ์ข…์ข… ๋ฌธ๋ฒ•์˜ ์ œํ•œ์„ ๊ฐ€์ง€๊ณ  ์˜จ๋‹ค. ์™œ๋ƒํ•˜๋ฉด ํ”„๋ก์‹œ ๊ฐ์ฒด๊ฐ€ ์‹ค์ œ ๊ฐ์ฒด๋ฅผ ์™„์ „ํžˆ ๊ต์ฒดํ• ๋งŒํผ ๋Šฅ๋ ฅ์„ ๊ฐ€์งˆ์ˆ˜ ์—†๊ธฐ ๋•Œ๋ฌธ์ด๋‹ค. ๋Œ€๋กœ ํ”„๋ก์‹œ๋Š” ์‹œ์Šคํ…œ์˜ ๋””์ž์ธ์‹œ ๋” ๋‚˜์œ ์„ ํƒ์„ ๊ฐ€์ง€๊ณ  ์˜จ๋‹ค. ํ•˜์ง€๋งŒ ๋งŽ์€ ๊ฒฝ์šฐ ํ”„๋ก์‹œ์˜ ์กด์ œ๋Š” ํด๋ผ์ด์–ธํŠธ์—๊ฒŒ ๊ทธ ์ˆ˜ํ–‰์„ ์˜์‹ํ•˜๊ฒŒ ํ•˜๋Š” ๊ฒฝ์šฐ๋Š” ๊ฑฐ์˜ ์—†๋‹ค. ์˜ˆ๋ฅผ ๋“ค์–ด์„œ ํด๋ผ์ด์–ธํŠธ๋Š” ์ด์ฐจ์› ๋ฐฐ์—ด์˜ ์˜ˆ์ œ์—์„œ Array1D ๊ฐ์ฒด์˜ ์ฃผ์†Œ๋ฅผ ์›ํ•˜๋Š” ํด๋ผ์ด์–ธํŠธ๋Š” ๊ฑฐ์˜ ์—†๋‹ค. ๊ทธ๋ฆฌ๊ณ  ArrayIndex๊ฐ์ฒด(Item 5์ฐธ๊ณ )๋Š” ์˜ˆ์ƒ๋˜๋Š” ๋‹ค๋ฅธ ํ˜•ํƒœ์˜ ํ•จ์ˆ˜๋กœ ์ „๋‹ฌ ๋ ๊ฒƒ์ด๋‹ค. ๋งŽ์€ ๊ฒฝ์šฐ์— ํ”„๋ก์‹œ๋Š” ์ง„์งœ ๊ฐ์ฒด์˜ ์ˆ˜ํ–‰์„ ๋Œ€ํ–‰ํ•œ๋‹ค. ๊ทธ๋“ค์„ ์ ์šฉํ• ๋•Œ, ์•„๋ฌด์ผ ์—†๋Š”๊ฑด ๊ฑฐ์˜ ๋Œ€๋ถ€๋ถ„์ด๋‹ค.


Valid XHTML 1.0! Valid CSS! powered by MoniWiki
last modified 2021-02-07 05:23:49
Processing time 0.0546 sec