3.3.3 コンストラクタの多重定義

　コンストラクタを実装します。Matrixクラスのオブジェクトを生成するには、次の３ 
つのタイプが考えられます。 

Matrix a; // 既定値で初期化 

Matrix a(5,6); // ５行６列の行列を生成 

Matrix a = b; // 既に存在するオブジェクトｂの値と同じものを生成 

これら３つの初期化に応じたコンストラクタを多重定義します。１つ目は、引数のない 
デフォルトコンストラクタで次のようなプロトタイプで与えられるものです。 

Matrix::Matrix(); 

２つ目は引数に行数と列数の２つの引数を与えて、その次元数を持つオブジェクトを生 
成するコンストラクタで、 

Matrix::Matrix(int, int); 

というものです。実はこれら２つは１つのコンストラクタで表現することができます。 

Matrix::Matrix(int = 0, int = 0); 

の様にデフォルト引数を用意することで、２つの機能を兼ねることができます。この場 
合、次の宣言 

Matrix a; 

ではメンバ関数の（デフォルト）コンストラクタ「 a.Matrix( 0, 0); 」が自動的に 
呼び出され、また次の宣言では 

Matrix b(10,20); 

コンストラクタ「 b.Matrix( 10, 20); 」が呼び出されます。 

　３つ目は、既存のオブジェクトの値を使ってオブジェクトを生成するものです。これ 
は丁度組み込み型の変数で、次の初期化と同様のことを行えるようにするためです。 

int i = 10; 
int j = i; // iの値で初期化 

このタイプのコンストラクタをコピーコンストラクタと呼び、次のプロトタイプで表さ 
れます。 

Matrix::Matrix(const Matrix &); 

この様なコンストラクタを用意することで、次のような宣言 

Matrix b = a; // ａはMatrixクラスのオブジェクト 

では 

b.Matrix(a); 

が呼び出され、オブジェクトｂは生成時にａの属性（データメンバ）で初期設定されま 
す。この詳細はすぐ後で扱います。 

　Matrix クラスの定義の最初のバージョンは次のようになります。以前の続きから、 
ヘッダファイル名を matrix12.h とし内部実装のソースファイルを matrix12.cpp と 
します。ヘッダファイルは、クラス定義をプリプロセッサ命令で次のように囲んで２重 
にインクルードされることを防いでいます。 

#ifndef MATRIX12_H 
#define MATRIX12_H 
  ...... 

#endif 

// matrix12.h
// Matrixクラス インターフェイス部
#ifndef MATRIX12_H
#define MATRIX12_H

#include <iostream.h>
#include <stdlib.h>

class Matrix{

public:
    Matrix(int = 0, int = 0);// デフォルトコンストラクタ
    Matrix(const Matrix &);// コピーコンストラクタ
    ~Matrix();			   // デストラクタ
    void setSize(int, int);// 行列のサイズを設定する
    int getRow() const { return Row;}// 行数を取得
    int getCol() const { return Col;}// 列数を取得

private:
    double **ptr;// 要素へのポインタ
    int Row;	// 行の数
    int Col;	// 列の数

    // ユーティリティ関数
    void new_matrix();// 行列の領域を確保する
    void del_matrix();// 領域を開放する
};

#endif

3.3.4 メモリの動的作成と解放

　行列要素のメモリ領域を作成・解放する場面はいまのところ３つあります（後でもう 
１つ加わります）。 

（１）オブジェクトの生成（コンストラクタが行う） 
（２）行列のサイズ変更（メンバ関数 Matrix::setSize() が行う） 
（３）オブジェクトの消滅（デストラクタが行う） 

メモリ領域の動的作成と解放は、前回のテーマ「行列ライブラリの設計（１）」で作成 
した非オブジェクト指向の方法と基本は同じです。例えば matrix11.h で定義した関数 

void mat_new(matrix &a, int m, int n);// 行列の動的作成 
void mat_del(matrix &a);               // 行列の解放 

を思い出してください。これらをメンバ関数にしたのが上のクラス定義のなかの 

void new_matrix();// 行列の領域を確保する 
void del_matrix();// 領域を開放する 

です。ここで１つの特徴に気付きます。メンバ関数の方には引数がありません。オブジ 
ェクト指向プログラミングでは渡す引数の個数が減ります。そのため関数呼び出しが簡 
略化されます。これはカプセル化の機能がもつ利点の１つです。 
　またクラス定義での関数の位置に注目しましょう。これらは、非公開メンバ関数です。 
これらの関数は上の３つ場面でそれぞれ公開メンバ関数の中から呼ばれます。クラスの 
ユーザが直接利用する必要はありません。そのためインタフェースに含めないで、非公 
開メンバとしています。この様な関数をユーティリティ関数と呼びます。次に定義を 
示します。 

// 行列の領域を確保する 
void Matrix::new_matrix() 
{ 
    // デフォルト値ではポインタをヌルに設定 
    if(Row == 0 || Col == 0){ 
        Row = 0; 
        Col = 0; 
        ptr = 0; 
        return; 
    } 
    ptr = new double *[Row];     //行の設定（行ベクトルへのポインタ配列）
    for(int i = 0; i < Row; i++) //列の設定（行ベクトル）
        ptr[i] = new double[Col]; 
} 

// 行列の領域を開放する 
void Matrix::del_matrix() 
{ 
    for(int i = 0; i < Row; i++) // 列を解放 
        delete [] ptr[i]; 

    delete [] ptr; //行を解放 
} 

コンストラクタは内部でユーティリティ関数Matrix::new_matrix()を呼び出します。 

// （デフォルト）コンストラクタ 
Matrix::Matrix(int row, int col) 
{ 
    Row = row;    // データメンバを設定 
    Col = col; 
    new_matrix(); // 行列の領域確保 

    for(int i = 0; i < Row; i++) //要素を０に初期設定 
        for(int j = 0; j < Col; j++) 
            ptr[i][j] = 0.0; 
} 

コンストラクタ内で、ユーティリティ関数Matrix::new_matrix()が呼び出される前に 
オブジェクトのデータメンバ Rowと Colが設定されていることに注意しましょう。 

　コピーコンストラクタは、同じクラスに属するオブジェクトの値で初期設定するとき 
に呼び出されるコンストラクタです。Ｘというクラスの名前があるとき、コピーコンス 
トラクタはＸ::Ｘ(const Ｘ＆)というプロトタイプになります。これにより、次の 
ようなオブジェクトを生成できます。 

X b = a; // ａは既存のクラスＸのオブジェクト 

コピーコンストラクタは動的メモリ割り当てを行うクラスでは必ず必要になります。 
わたしたちのクラスでは次のように定義されます。 

// コピーコンストラクタ 
Matrix::Matrix(const Matrix &a) 
{ 
    Row = a.Row; // 行数をコピー 
    Col = a.Col; // 列数をコピー 

    new_matrix(); // ａと同じサイズの行列領域を確保 

    for(int i = 0; i < Row; i++) // ａの要素を代入 
        for(int j = 0; j < Col; j++) 
            ptr[i][j] = a.ptr[i][j]; 
} 

これで、次のような宣言でオブジェクトｂを初期設定できます。 

Matrix b = a; // 既存のオブジェクトａの値と同じものを生成 

　組み込み型の変数はその変数のスコープの終わりで消滅します。例えば関数内で宣言 
された普通の変数は関数ブロックの終わりで消滅します。クラスのオブジェクトも同じ 
です。そのときに自動的に呼ばれるのがデストラクタです。デストラクタを使うこと 
でオブジェクトが消滅する前に後始末をすることができます。コンストラクタが動的メ 
モリを作成した場合は、それを解放するのがデストラクタの役割です。 

　デストラクタはクラス名の前にチルダ(〜)が付いた公開メンバ関数です。上のクラス 
定義の ~Matrix() がデストラクタです。 
　デストラクタは引数を持たず、コンストラクタと同様に戻り値型を持ちません。クラ 
スにはデストラクタを１つだけ設けることができます。デストラクタは多重定義できま 
せん。 

　デストラクタはなぜチルダ(〜)で命名規約されたのでしょう。チルド演算子(〜)は 
ビット補数演算子（ビットNOT演算子）です。つまりデストラクタはコンストラクタの 
補数（反転）という意味なのでしょう。次にデストラクタの定義を示します。 

// デストラクタ 
Matrix::~Matrix() 
{ 
    del_matrix(); 
} 

これは、ユーティリティ関数Matrix::del_matrix() を呼び出すだけです。 

　Matrixクラスの定義 (matrix12.h)のなかの行数と列数を取得するメンバ関数で、関 
数宣言の引数リストの後ろのキーワード const に注目してください。 

Matrix::getRow() const { return Row; } 
Matrix::getCol() const { return Col; } 

これは、メンバ関数がオブジェクトを変更しないことを意味します。実際これらの関数 
はデータメンバの値を返すだけで、オブジェクトの内部状態を変更していません。この 
様なメンバ関数を、constメンバ関数（定数メンバ関数）といいます。この場合、コ 
ンパイラは関数がオブジェクトを変更しようとする箇所を検出します。 
　またconstメンバ関数をクラスの外で定義するときにも、constを後ろに付加しなけ 
ればなりません。キーワードconstは関数の型の一部です。 

　メンバ関数がオブジェクトの値を変更しないなら、必ずconstメンバ関数にしてオブ 
ジェクトを変更禁止にしておくことが大切です。つまり必要以上の権限を持たせないよ 
うにします。さらにこの様にすることで、クラスの利用者（別のプログラマ）に「オブ 
ジェクトを変更しないメンバ関数」であることを知らせることができます。 

　普通のメンバ関数は呼びだされるとき、現在のオブジェクトを指すthisポインタが暗
黙に渡されます。このときthisポインタの型は、そのクラス名がＸのときは「Ｘ*」型
です。 
　一方constメンバ関数の場合、暗黙に渡されるのは「定数オブジェクトへのポインタ」 
になります。つまりthisの型は「const Ｘ＊」型です。従ってオブジェクトは変更不 
可となり、コンパイラはこれを強制します。これがconstメンバ関数の仕組みです。 

　ここで、メモリ領域の動的作成のときに、new演算子が失敗したときヌルポインタを 
返すコンパイラの場合の処理を含めています。現在の標準Ｃ++では例外を送出します。 
そのようなコンパイラではこのコードは実行されることはありません。しかしヌルポイ 
ンタを返す場合はこのエラー処理は最低限必要です。 

　コンストラクタとデストラクタはどのように呼ばれるのかを調べます。次のプログラ 
ムを実行します。この場合、このドライバプログラムlst03_06.cppとMatrix12.cppと 
を一緒にコンパイルします（分割コンパイルのページ参照）。 

// lst03_06.cpp
//Matrixクラスのドライバープログラム
//Matrix12.cppと一緒にコンパイルする
#include <iostream.h>
#include "Matrix12.h"

int main()
{
    cout << "オブジェクトａの生成：" << endl;
    Matrix a;

    cout << endl << "オブジェクトｂの生成：" << endl;
    Matrix b(3,4);

    cout << endl << "オブジェクトｃの生成：" << endl;
    Matrix c = b;

    cout << endl << "オブジェクトｃを変更：";
    c.setSize(8,9);
    cout << c.getRow() <<  "×" << c.getCol()
    << "行列になりました。" << endl << endl;

    return 0;
}

オブジェクトａの生成： 
コンストラクタが呼ばれました（0 行 0 列の行列が作成されました）。 

オブジェクトｂの生成： 
コンストラクタが呼ばれました（3 行 4 列の行列が作成されました）。 

オブジェクトｃの生成： 
コピーコンストラクタが呼ばれました（3 行 4 列の行列が作成されました）。 

オブジェクトｃを変更：8×9行列になりました。 

デストラクタが呼ばれました（8 行 9 列の行列を解放します）。 
デストラクタが呼ばれました（3 行 4 列の行列を解放します）。 
デストラクタが呼ばれました（0 行 0 列の行列を解放します）。 

このプログラムは３つのオブジェクトを生成します。まずａのデフォルトコンストラク 
タが呼ばれます。次にｂのコンストラクタが呼ばれ、最後にｃのコピーコンストラクタ 
が呼ばれます。そして、main()関数が終わるときに、これらオブジェクトのデストラク 
タが呼ばれます。 
　実行結果より、コンストラクタが呼ばれた逆の順にデストラクタが呼ばれていること
が分かります。 

　関数内で生成されたオブジェクトは、生成時にコンストラクタが呼び出され、関数 
ブロックの終わりでこのオブジェクトは消滅します。そのときにデストラクタが呼ば 
れ後始末（メモリの解放）をします。

　オブジェクトを動的に作成する場合を調べてみます。次のプログラムを見てくださ 
い。 

// lst03_08.cpp
// new演算子、delete演算子とコンストラクタ、デストラクタ
// Matrix12.cppと一緒にコンパイルする
#include <iostream.h>
#include "Matrix12.h"

int main()
{
    cout << "オブジェクトを指すポインタを宣言" << endl;
    Matrix *ptr;

    cout << "Matrixオブジェクトのメモリ領域を動的に作成します。" << endl;
    ptr = new Matrix(3,4);

    cout << endl << "サイズを変更：";
    ptr->setSize(5,6);
    cout << ptr->getRow() <<  "×" << ptr->getCol()
    << "行列になりました。" << endl << endl;


    cout << "メモリ領域を解放します。" << endl;
    delete ptr;
    cout << "メモリ領域を解放後" << endl;

    return 0;
}

オブジェクトを指すポインタを宣言 
Matrixオブジェクトのメモリ領域を動的に作成します。 
コンストラクタが呼ばれました（3 行 4 列の行列が作成されました）。 

サイズを変更：5×6行列になりました。 

メモリ領域を解放します。 
デストラクタが呼ばれました（5 行 6 列の行列を解放します）。 
メモリ領域を解放後 

このプログラムでは、まずMatirxクラスのオブジェクトを指すポインタを用意します。 

Matrix *ptr; 

この段階では、オブジェクトは何も作られていないことに注意してください。存在す 
るのはオブジェクトのアドレスを変数とするポインタ ptrです。そして 

ptr = new Matrix(3,4); // コンストラクタが呼ばれる 

でコンストラクタが呼ばれオブジェクトが生成されます。new演算子はオブジェクトの 
メモリ割り当てだけでなく初期化を行います。これは完全なオブジェクトの生成です。 
ただしnew演算子がつくりだすのは、いわば「名無しのオブジェクト」です。その代わ 
りそのアドレスを返します。つまり、new演算子はクラスのコンストラクタを呼び出す 
ことができます。同様に、delete演算子はデストラクタを呼び出します。そして（デ 
ータメンバ ptrが指すメモリの）後始末をした後に（オブジェクトの）メモリを解放し 
ます。 

delete ptr; // デストラクタが呼ばれる 

　new演算子とdelete演算子はこの様な機能を持つので、Ｃの標準ライブラリ関数 
malloc() と free() の組み合わせよりも優れています。これにより、ポインタを 
使って名前無しのオブジェクトを正しく初期化し、それを利用することができます。 

　最後に、関数呼び出しでコンストラクタが呼び出される例を示します。関数の引数に 
オブジェクトを渡すときは、値渡しで行われます。このときに関数内にローカル・オブ 
ジェクトが作られます。コピーコンストラクタはそのローカル・オブジェクトを作成す 
るために呼ばれます。コピーコンストラクタの役割は、引数で渡された呼び出し側のオ 
ブジェクトで初期化することです。そして関数の終了で、デストラクタが呼ばれてロー 
カル・オブジェクトは消滅します。 

　次のプログラムは、２つの関数にオブジェクトを渡します。 

void func1(Matrix ); 
void func2(Matrix &); 

１つ目の関数は値渡しで、２つ目は参照渡しです。これらの関数は共にオブジェクトの 
サイズを変更して終了します。 

// lst03_09.cpp
// 関数への値渡しと参照渡し
// Matrix12.cppと一緒にコンパイルする
#include <iostream.h>
#include "Matrix12.h"

void func1(Matrix a)
{
    cout << endl << "[関数 func1()内]" << endl;
    cout << a.getRow() <<  "×" << a.getCol() << "行列です。" << endl;
    cout << "サイズを変更します。" << endl;
    a.setSize(5,6);
    cout << a.getRow() <<  "×" << a.getCol() << "行列です。" << endl;
}

void func2(Matrix &a)
{
    cout << endl << "[関数 func2()内]" << endl;
    cout << a.getRow() <<  "×" << a.getCol() << "行列です。" << endl;
    cout << "サイズを変更します。" << endl;
    a.setSize(7,8);
    cout << a.getRow() <<  "×" << a.getCol() << "行列です。" << endl;
}

int main()
{
    Matrix a(3,4); // オブジェクトを生成

    // 値渡し
    cout << "関数 func1()呼び出し前：" << endl << endl;
    func1(a);
    cout << "関数 func1()呼び出し後：" << endl << endl;

    // 参照渡し
    cout << "関数 func2()呼び出し前：" << endl;
    func2(a);
    cout << "関数 func2()呼び出し後：" << endl << endl;

    return 0;
}

コンストラクタが呼ばれました（3 行 4 列の行列が作成されました）。 
関数 func1()呼び出し前： 

コピーコンストラクタが呼ばれました（3 行 4 列の行列が作成されました）。 

[関数 func1()内] 
3×4行列です。 
サイズを変更します。 
5×6行列です。 
デストラクタが呼ばれました（5 行 6 列の行列を解放します）。 
関数 func1()呼び出し後： 

関数 func2()呼び出し前： 

[関数 func2()内] 
3×4行列です。 
サイズを変更します。 
7×8行列です。 
関数 func2()呼び出し後： 

デストラクタが呼ばれました（7 行 8 列の行列を解放します）。 

値渡しの関数ではコピーコンストラクタが呼ばれて、呼び出し側のオブジェクトと同じ 
値（３行４列の行列）のオブジェクトが生成されます。関数内でオブジェクトは変更さ 
れ、終了時にデストラクタが呼ばれてこのローカル・オブジェクトは消滅します。この 
とき呼び出し側のオブジェクトは変更を受けません（値呼び出しだから）。 
　一方参照渡しでは、呼び出し側のオブジェクト自体が渡されますから、コンストラク 
タは起動されません。そして関数内でのオブジェクトの変更は、元のオブジェクトその 
ものを変更することを示します。 

　これと同じ事情は、関数がオブジェクトを返すときにも生じます。戻り値型がクラス 
型（つまり値渡し）の関数が戻るときコピーコンストラクタが呼ばれます。関数の戻り 
型で特に注意すべきとことはオブジェクトへの参照を返す関数の場合です。関数内で生 
成したオブジェクトへの参照を関数が返すと重大な実行エラーを引き起こします。 

　これらについては、後のページで再び詳しく検討します。 
  

[演習問題 3.1] ベクトルを表現するクラス Vectorを設計しなさい。 
　　　　　　　　回答：インターフェース部（ vector01.h ） 
　　　　　　　　　　　実装部（ vector01.cpp ） 

[演習問題 3.2] 演習問題3.1で作成したクラスをテストするプログラム 
　　　　　　　を書きなさい。 
　　　　　　　回答：（ ex03_01.cpp ）