第11章　演算子のオーバーロード

1. 11．１ 演算子のオーバーロード
   1. （プログラム例 11.1 ）　ベクトルの加算（メンバー関数）
   2. （プログラム例 11.2 ）　ベクトルの加算（フレンド関数）
2. 11．２ 複素数の加算（ + ）と出力（ << ）
   1. （プログラム例 11.3 ）　複素数の加算（メンバー関数）
   2. （プログラム例 11.4 ）　複素数の加算（フレンド関数）
3. 11．３ 変換演算子
   1. （プログラム例 11.5 ）　変換演算子
4. 11．４ 関数呼び出し () の多重定義
   1. （プログラム例 11.6 ）　関数オブジェクト
   2. （プログラム例 11.7 ）　イテレータ
5. 11．５ 演算子のオーバーロードと演算子との関係
6. 演習問題11

11．１ 演算子のオーバーロード

　　クラスのオブジェクトどうしの演算はできないでしょうか．例えば，2 次元ベクトルに対応する次のようなクラスを宣言したとします．

class Vector {
	double x[2];
}		

このとき，

Vector a,b,c;
c = a + b;		

のようなことが可能であれば，ベクトルどうしの演算を普通のスカラーと同じように書くことができ，非常に便利です．

　　C++ には，上のことを可能にするため，演算子のオーバーロード（多重定義，operator overloading）という機能があります．演算子のオーバーロードは，以下の 4 つの演算子，

"."，".*"，"::"，"?*"		

を除くすべての演算子に対して可能です．例えば，上の場合のように，+ 演算子に対してオーバーロードを行いたければ，希望する + 演算を実行する関数

operator+		

を定義してやればよいわけです．コンパイラは，+ 演算子に出会うと，それが結びつけている各項の型を判断し，基本データ型であれば普通の演算を，また，オーバーロードの際宣言されたクラスのオブジェクトであれば，オーバーロードの定義に従った演算を行います．

　　演算子のオーバーロードを行うときは，以下のような規則に従う必要があります．

• 演算子は，メンバー関数，または，フレンド関数で定義します．ただし，次の演算子に対するオーバーロードは，メンバー関数で記述してやる必要があります．

  =  : 代入
  () : 関数呼び出し
  [] : 添え字
  -> : 間接参照			

• C++ に最初から備わっている演算子だけに定義でき，** （ベキ乗）のような新しい演算子を作成することはできません．

• 文法や演算子の優先順位の変更はできません．

• 基本データ型（クラスでない型）に対する演算子のオーバーロードは不可能です．

　　以下の 2 つのプログラム例は，ベクトルの加算演算をメンバー関数，及び，フレンド関数を使用して書いた場合の例です．2 つの方法の違いを理解して下さい．

（プログラム例 11.1 ） ベクトルの加算（メンバー関数）　（ A ～ B の部分を可能な限り一つの変数，定数，演算子等で，埋めてください．その際，文字を削除してから，正しい答えを半角文字で，かつ，余分なスペースを入れないで入力してください．）

　　このプログラムでは，メンバー関数を使用して，2 次元のベクトルの和（要素どうしの和）を行う + 演算を定義しています．この関数の引数が 1 つしかない理由は以下に示す通りです．例えば，

c = a + b;		

を行う場合，operator+ は Vector クラスのメンバー関数ですので，上の演算は，

c = a.(operator+)(b);		

と解釈され，下の例のように，関数内で最初のオブジェクト a のメンバーを直接参照できるからです．

（プログラム）

/**********************************/
/* ベクトルの加算（メンバー関数） */
/*      coded by Y.Suganuma       */
/**********************************/
#include <stdio.h>

/**********************/
/* クラスvectorの定義 */
/**********************/
class Vector {
		double x[2];
	public:
		Vector operator+ (Vector &b);   // 演算子＋のオーバーロード
		void input();
		void output();
};

/**********************/
/* ＋のオーバーロード */
/**********************/
Vector Vector::operator+ (Vector &b)
{
	Vector c;
	c.x[0] = x[0] + b.x[0];
	c.x[1] = x[1] + b.x[1];
	return c;
}

/**********************/
/* ベクトル要素の入力 */
/**********************/
void Vector::input()
{
	printf("   ２つの値を入力してください ");
	scanf("%lf %lf", &(x[0]), &(x[1]));
}
/**********************/
/* ベクトル要素の出力 */
/**********************/
void Vector::output()
{
	printf("%f %f\n", x[0], x[1]);
}

/************/
/* main関数 */
/************/
int main()
{
	Vector a, b, c;

	printf("a\n");
	a.input();
	printf("b\n");
	b.input();

	c = a + b;

	c.output();

	return 0;
}
			

　　このプログラムを実行すると，以下に示すような結果が得られます．

a
   ２つの値を入力してください 1 2
b
   ２つの値を入力してください 3 5
4.000000 7.000000		

（プログラム例 11.2 ） ベクトルの加算（フレンド関数）

　　上の例と同じ内容を，フレンド関数を使用して実現しています．引数の違いに注意して下さい．

/**********************************/
/* ベクトルの加算（フレンド関数） */
/*      coded by Y.Suganuma       */
/**********************************/
#include <stdio.h>

/**********************/
/* クラスvectorの定義 */
/**********************/
class Vector {
		double x[2];
	public:
		void input();
		void output();
	friend Vector operator+ (Vector &a, Vector &b);
};

/**********************/
/* ＋のオーバーロード */
/**********************/
Vector operator+ (Vector &a, Vector &b)
{
	Vector c;
	c.x[0] = a.x[0] + b.x[0];
	c.x[1] = a.x[1] + b.x[1];
	return c;
}

/**********************/
/* ベクトル要素の入力 */
/**********************/
void Vector::input()
{
	printf("   ２つの値を入力してください ");
	scanf("%lf %lf", &(x[0]), &(x[1]));
}
/**********************/
/* ベクトル要素の出力 */
/**********************/
void Vector::output()
{
	printf("%f %f\n", x[0], x[1]);
}

/************/
/* main関数 */
/************/
int main()
{
	Vector a, b, c;

	printf("a\n");
	a.input();
	printf("b\n");
	b.input();

	c = a + b;

	c.output();

	return 0;
}
		

11．２ 複素数の加算（ + ）と出力（ << ）

　　次の 2 つの例も，メンバー関数とフレンド関数との違いを示したものです．これらの例は，複素数型データを扱うためのクラスを定義しており，複素数に対する加算のオーバーロードを定義しています．また，通常の変数と同じように出力ができるようにするため，<< のオーバーロードも参照型関数として定義しています．

　　まず，プログラム例 11.3 では，メンバー関数を使用して処理しています．少なくとも，プログラム例のような複素数どうしの演算は正しく行われます．また，

z = x + 5;		

のように，複素数に整数を加える演算も，コンストラクタが整数を複素数に変換してくれることにより正しく実行されます．

　　しかし，

z = 5 + x;		

の場合は，演算子 + に対する最初の引数が基本データ型（ int ）であるため，通常の加算とみなされ，コンパイラからエラーメッセージが出力されます．このことは，先に述べたように，メンバー関数による + 演算子のオーバーロードが，a.(operator+)(b) と解釈される，つまり，a が複素数型のオブジェクトでなければならないことから明らかです．

　　上で述べた 2 種類の演算を正しく実行するためには，次のプログラム例 11.4 のように，演算子 + に対して，各引数を対称に扱うフレンド関数を使用する必要があります．

（プログラム例 11.3 ） 複素数の加算（メンバー関数）　（ A ～ B の部分を可能な限り一つの変数，定数，演算子等で，埋めてください．その際，文字を削除してから，正しい答えを半角文字で，かつ，余分なスペースを入れないで入力してください．）

（プログラム）

/****************************/
/* 複素数（メンバー関数）   */
/*      coded by Y.Suganuma */
/****************************/
#include <iostream>

using namespace std;

class Complex {
		double r;
		double i;
	public:
		Complex (double a = 0.0, double b = 0.0);         // constructor
		Complex operator +(Complex a);                 // overload of +
	friend ostream& operator << (ostream&, Complex);   // overload of <<
};

Complex::Complex(double a, double b)
{
	r = a;
	i = b;
}

Complex Complex::operator +(Complex a)
{
	Complex c;
	c.r = a.r + r;
	c.i = a.i + i;
	return c;
}

ostream& operator << (ostream& stream, Complex a)
{
	stream << "(" << a.r << ", " << a.i << ")\n";
	return stream;
}

int main()
{
	Complex w, x(1.0, 2.0), y(3.0), z;
	z = x + y;
	w = x + 5.0;   // 5.0 + x はエラー
	cout << "z " << z ;
	cout << "w " << w ;
	return 0;
}
			

　　このプログラムを実行すると，以下に示すような結果が得られます．

z (4, 2)
w (6, 2)		

（プログラム例 11.4 ） 複素数の加算（フレンド関数）　（ A ～ B の部分を可能な限り一つの変数，定数，演算子等で，埋めてください．その際，文字を削除してから，正しい答えを半角文字で，かつ，余分なスペースを入れないで入力してください．）

（プログラム）

/****************************/
/* 複素数（フレンド関数）   */
/*      coded by Y.Suganuma */
/****************************/
#include <iostream>

using namespace std;

class Complex {
		double r;
		double i;
	public:
		Complex (double a = 0.0, double b = 0.0);   // constructor
	friend Complex operator +(Complex a, Complex b);   // overload of +
	friend ostream& operator << (ostream&, Complex);   // overload of <<
};

Complex::Complex(double a, double b)
{
	r = a;
	i = b;
}

Complex operator +(Complex a, Complex b)
{
	Complex c;
	c.r = a.r + b.r;
	c.i = a.i + b.i;
	return c;
}

ostream& operator << (ostream& stream, Complex a)
{
	stream << "(" << a.r << ", " << a.i << ")\n";
	return stream;
}

int main()
{
	Complex w, x(1.0, 2.0), y(3.0), z;
	z = x + y;
	w = 5.0 + x;
	cout << "z " << z;
	cout << "w " << w;
	return 0;
}
			

　　このプログラムを実行すると，以下に示すような結果が得られます．

z (4, 2)
w (6, 2)		

　　ここでは，演算子のオーバーロードの説明のため，あえて上に示すような方法を採りましたが，複素数を取り扱うためには，下のプログラム例に示すように，C++ の標準ライブラリ内にある complex クラスを使用した方が簡単だと思います．

#include <iostream>
#include <complex>

using namespace std;

int main()
{
	complex<double> x(1.0, 2.0), y(3.0);
	complex<double> z = x + y;
	complex<double> w = 5.0 + x;

	cout << "z " << z << endl;
	cout << "w " << w << endl;

	return 0;
}
		

/****************************/
/* 変換演算子               */
/*      coded by Y.Suganuma */
/****************************/
#include <stdio.h>

/**********************/
/* クラスVectorの定義 */
/**********************/
class Vector {
		double x[2];
	public:
		operator int()     // 変換演算子の定義
		{
			return (x[0] != 0.0 || x[1] != 0.0);
		}
	friend void input(Vector &);
	friend void output(Vector &);
};
/**********************/
/* ベクトル要素の入力 */
/**********************/
void input(Vector &v)
{
	scanf("%lf %lf", &(v.x[0]), &(v.x[1]));
}
/**********************/
/* ベクトル要素の出力 */
/**********************/
void output(Vector &v)
{
	printf("%f %f\n", v.x[0], v.x[1]);
}
/************/
/* main関数 */
/************/
int main()
{
	Vector a;
	int sw = 0;

	while (sw == 0) {
		printf("要素を入力してください ");
		input(a);
		sw = int(a);    // オブジェクトaの型をintに変換
	}

	output(a);

	return 0;
}
		

要素を入力してください 0 0
要素を入力してください 1 0
1.000000 0.000000		

#include <stdio.h>
					// () のオーバーロード
class Plus
{
	public :
		int operator() (int a, int b)
		{
			return a + b;
		}
};
					// main
int main()
{
	Plus p;
	int c = p(10, 20);
	printf("c = %d\n", c);
	return 0;
}
		

c = 30		

#include <stdio.h>
					// 構造体 list
struct list
{
	char *name;
	int nen;
};
					// クラス Vector
class Vector
{
		list *val;
		int max;
	public:
							// コンストラクタ
		Vector(int n)
		{
			val = new list [n];
			max = n;
		}
							// デストラクタ
		~Vector()
		{
			delete [] val;
		}
	friend class IteratorNext;
};
					// クラス IteratorNext
class IteratorNext
{
		const Vector *vp;
		int i;
	public:
							// コンストラクタ
		IteratorNext (const Vector &v)
		{
			vp = &v;
			i  = 0;
		}
							// 次の要素
		list *operator() ()
		{
			return (i < vp->max) ? &(vp->val[i++]) : 0;
		}
};
					// main
int main()
{
	Vector v(2);
	list *p;
	IteratorNext next1(v);
	p       = next1();
	p->name = "山田太郎";
	p->nen  = 30;
	p       = next1();
	p->name = "鈴木花子";
	p->nen  = 25;
	IteratorNext next2(v);
	while ((p = next2()) != 0)
		printf("%s %d\n", p->name, p->nen);
	return 0;
}
		

山田太郎 30
鈴木花子 25