コピーコンストラクタの仕組みを教えてください

Question

以下のプログラムは参考書に書かれてあるプログラムです。

(あ)の、コピーコンストラクタの仕組みがイマイチ分かりません。
メモリの二重解放を防ぐために行われているという事は分かるのですが、ここの p はどのオブジェクトのpになるんでしょうか。
main()内でgetval()の仮引数に指定されているオブジェクトは、o になりますよね？
p が何をしているのかが分かりません。
どなたか宜しくお願いします。

// このプログラムにはエラーがある
####include <iostream>
####include <cstdlib>
using namespace std;

class myclass {
int *p;
public:
myclass(int i);
myclass(const myclass &ob);
~myclass() { delete p; }
friend int getval(myclass o);
};

myclass::myclass(int i)
{
p = new int;

if(!p) {
cout << "メモリ割り当てエラー\n";
exit(1);
}

*p = i;

}

myclass::myclass(const myclass &ob)　・・・(あ)
{
p = new(nothrow) int;

if(!p){
	cout <<"メモリ割り当てエラー\n";
	exit(1);
}

*p = *ob.p;

}

int getval(myclass o)
{
return *o.p; // 値を取得する
}

int main()
{
myclass a(1), b(2);

cout << getval(a) << " " << getval(b);
cout << "\n";
cout << getval(a) << " " << getval(b);
cout << "\n";

return 0;
}

Comments

[hoshi-takanori]

本来は *a.p と *b.p が別の値を持てるようにするためですが、メモリの二重解放を防ぐ意味もあります。
よく見たら getval の引数はコピー渡しされているので、コピーコンストラクタがないとメモリの二重解放になりますね。

[iwanami]

僕が参考書で学んだのはメモリの二重解放だけだったので、*a.pと*b.pが別の値を持てるようにするため、というのは知りませんでした。
ただ今回はメモリの二重解放に焦点を当てていて、(あ)のコピーコンストラクタの定義でなぜ二重解放が防げているのかが分かりません。

[iwanami]

回答してくれた皆さんありがとうございました。

Answer 1

二重解放とならぬよう...

myclass::myclass(const myclass &ob) { //　・・・(あ)
  p = new(nothrow) int; // 新たな領域を確保し 
  if(!p){
    cout <<"メモリ割り当てエラー\n";
    exit(1);
  } 
  *p = *ob.p; // ナカミを複製する 
} 

なので
myclass a(123);
myclass b = a;
としたとき、a.p と b.p は別領域となります(からa,bが廃棄されるとき二重解放になりません)

[追記] 領域のnew/delete の様子をプリントしてみました:

#include <iostream>
#include <cstdlib>
using namespace std;

class myclass {
    int* p;
public:
    myclass(int i);
    myclass(const myclass& ob);
    ~myclass() { std::cout << "delete " << (void*)p << "\n"; delete p; }
    friend int getval(myclass o);
};
myclass::myclass(int i)
{
    p = new int;
    std::cout << "new " << (void*)p << "\n";
    if (!p) {
        cout << "メモリ割り当てエラー\n";
        exit(1);
    }
    *p = i;
}
myclass::myclass(const myclass& ob)
{
    p = new(nothrow) int;
    if (!p) {
        cout << "メモリ割り当てエラー\n";
        exit(1);
    }
    std::cout << "new " << (void*)p << "\n";
    *p = *ob.p;
}
int getval(myclass o)
{
std::cout << "getval\n";
    return *o.p; // 値を取得する
}
int main()
{
    myclass a(1), b(2);
    cout << getval(a) << " " << getval(b);
    cout << "\n";
    cout << getval(a) << " " << getval(b);
    cout << "\n";
    return 0;
}

実行結果:

new 000002324AA76DE0
new 000002324AA76D40
new 000002324AA76E80
getval
delete 000002324AA76E80
1 new 000002324AA76E10
getval
delete 000002324AA76E10
2
new 000002324AA76DD0
getval
delete 000002324AA76DD0
1 new 000002324AA76CF0
getval
delete 000002324AA76CF0
2
delete 000002324AA76D40
delete 000002324AA76DE0

getvalの前後でnew/deleteされてて、そのポインタ値は組になってます。
つまり、getvalの直前でコピーを作り、直後でそのコピーを廃棄しています。
なので二重解放になりません。

Comments

[iwanami]

pが代わりに解放されるから o は解法されないということでしょうか？

[episteme]

ごめん何言ってんのかわかんない。
a.p と b.p は別物なので、aが廃棄されても b.p に影響ありません。(逆もまた)

[iwanami]

もうちょっと他に言い方ないですかね
a.p と b.p が別物だという事は認識してます。

時間差で申し訳ないんですが、hoshi-takanori　さんも言っているように本来は 「*a.p と *b.p が別の値を持てるようにする 」意味がコピーコンストラクタにあるようなのですが、今回はそれではなくメモリの二重解放を防ぐために焦点を当てています。
というか参考書ではそっちしか説明されてなかったので。

epistemeさんが言っている、a=b とした時にメモリは共有されず、a,bのpの解法時に二重解放にならないというのは、なるほどとは思ったのですが、それとは多分僕が言っている事は違うと思います。
伝わればいいんですが

(あ)のコピーコンストラクタを消した状態で実行すると、

1 2
7475856 7475640

と出力されるので、コピーコンストラクタを設定してない状態でgetval()を使うと、a,bのそれぞれのpのメモリが解放されて、次のgetval()を使う時にめちゃくちゃな値が出力されてしまいます。
そのメモリの解放を防ぐやり方が(あ)なのでしょうが、(あ)でやってる事は pにo.pの値を代入しているだけなので、getval()が終わった後に、結局pが解放されると思うのですが...

このように認識していて、この p が o.p の代わりに解放されるから、o.p は解法されないのかなと思っているのですが
(あ)で p に新たな領域を確保して、o.p のナカミを複製するというのは分かるのですが、それだけでメモリの二重解放が防げている理由がわかりません。

[episteme]

＞もうちょっと他に言い方ないですかね
いやホントわかんない。
「pが代わりに解放されるから o は解法されないということでしょうか？ 」
... oってなんですか?　myclassのメンバはpだけですが。

-----------------------------
二重解放を避けたいなら、回答が示すとおり
1. 複製を作る
さもなくば
2. そもそもコピーを許さない
のいずれかです。

コピーを許し、かつ二重解放を防ぎたい となれば
3. その領域を最後に手放すインスタンスが解放する
からくりが必要となります。標準C++では std::shared_ptr がそのからくりに相当します。

[iwanami]

あ、すいません。oじゃなかったです。ob.pでした(^^;
訂正しておきます。
それを踏まえた上で僕の説明では分かりませんか

[episteme]

> (あ)でやってる事は pにo.pの値を代入しているだけなので、getval()が終わった後に、結局pが解放されると思うのですが...

myclass::myclass(const myclass &ob)　・・・(あ)
{
　p = new(nothrow) int;
　if(!p){ cout <<"メモリ割り当てエラー\n"; exit(1); }
*p = *ob.p; // ココ!!
}

p = ob.p ではありませんよ、*p = *ob.p ですから
p はこの関数で確保された領域のままです。確保のあと書き換えられていません。
# 書き換えられたのは pの指す先。

[iwanami]

それもなるほどとは思うのですが、、僕が言っているのとは多分違うんだと思います。

getval(a)は、aを値引数で指定しているので、コピーが生成されて、getval(a)が終了する時にデストラクタが呼び出されて、a.pが解放されてしまいます。
コピーコンストラクタの定義によってそれを防ぐ事が出来るようですが、この定義の内容でどうやってメモリの解放を防いでいるのかが分かりません。

[yuki23]

episteme さんは正にその説明をされてますよ。回答をちゃんと読みましょう

[episteme]

試運転してみた(追記しました)

[SHOMI]

>getval(a)が終了する時にデストラクタが呼び出されて、a.pが解放されてしまいます。
デストラクタが呼ばれるのはgetval(myclass o)を呼ぶ際に作られたoのほうで、解放されるのはo.pですよ。

[iwanami]

すいません、自分の理解が足りないため長引かせてしまっているんですね。

epistemeさんの回答をもう一度読んで解釈したのは
getval(a)で値引数に a を指定すると、コピーコンストラクタの定義のおかげで、aのコピー(メモリは共有しない)が
int getval(myclass o){}　の o に引数として指定され、それが代わりに解放されるという事でしょうか。

[episteme]

> int getval(myclass o){}　の o に引数として指定され、それが代わりに解放されるという事でしょうか。

その様子を観察しているのが[追記]です。

[iwanami]

度々すいません、回答に気づかなかったので上のコメントは15:04までの返信です。今から理解したいと思います。

[iwanami]

(一つ上の回答も15:27までの返信です。返信遅くてすいません。)

なるほどー！！
今漸く分かりました。

理解出来ない事が多くて少し逆切れ気味だった所もあり(逆切れしているつもりはないんですが、そう見えるコメントは合ったかと思います)、僕の理解が足りないために長く付き合わせてしまってすいません。
epistemeさんのプログラムのおかげで流れを目で追って理解する事ができました。
ありがとうございます。

[iwanami]

まだまだ自分が初心者だと分かりました。
episteme さんには分かりやすいプログラムまで記述してくださり感謝の気持ちで一杯です。

回答してくれた皆さんありがとうございました。