多重定義

概要

言語による多重定義のサポート

#include<stdio.h>
#include<math.h>
floatvector2f_length(floatx,floaty){returnsqrtf(x*x+y*y);}
doublevector2d_length(doublex,doubley){returnsqrt(x*x+y*y);}
floatvector3f_length(floatx,floaty,floatz){returnsqrtf(x*x+y*y+z*z);}
doublevector3d_length(doublex,doubley,floatz){returnsqrt(x*x+y*y+z*z);}
intmain(void)
{
printf("%f\n",vector2f_length(1.0f,-1.0f));
printf("%f\n",vector2d_length(1.0,2.0));
printf("%f\n",vector3f_length(1.0f,-1.0f,1.0f));
printf("%f\n",vector3d_length(1.0,2.0,-1.0));
}

#include<cstdio>
#include<cmath>
floatvector_length(floatx,floaty){returnstd::sqrt(x*x+y*y);}
doublevector_length(doublex,doubley){returnstd::sqrt(x*x+y*y);}
floatvector_length(floatx,floaty,floatz){returnstd::sqrt(x*x+y*y+z*z);}
doublevector_length(doublex,doubley,floatz){returnstd::sqrt(x*x+y*y+z*z);}
intmain(void)
{
printf("%f\n",vector_length(1.0f,-1.0f));// (float, float) バージョンが呼ばれる。
printf("%f\n",vector_length(1.0,2.0));// (double, double) バージョンが呼ばれる。
printf("%f\n",vector_length(1.0f,-1.0f,1.0f));// (float, float, float) バージョンが呼ばれる。
printf("%f\n",vector_length(1.0,2.0,-1.0));// (double, double, double) バージョンが呼ばれる。
}

ルックアップ

publicclass Main{
staticvoidtestMethod(Stringstr){System.out.println("String version is called.");}
staticvoidtestMethod(Objectobj){System.out.println("Object version is called.");}
publicstaticvoidmain(String[]args){
Stringstr="test";
Objectobj=str;
testMethod(str);// String バージョンが呼ばれる。
testMethod(obj);// Object バージョンが呼ばれる。
}
}

printf("%f\n",vector_length(1,-1));// コンパイルエラー。
printf("%f\n",vector_length(1.0f,-1.0));// コンパイルエラー。
printf("%f\n",vector_length(1.0,-1.0f));// コンパイルエラー。

printf("%f\n",vector_length(double(1),double(-1)));// コンパイル可能。(double, double) バージョンが呼ばれる。

printf("%f\n",vector2d_length(1,-1));/* コンパイル可能。 */
printf("%f\n",vector2d_length(1.0f,-1.0));/* コンパイル可能。 */
printf("%f\n",vector2d_length(1.0,-1.0f));/* コンパイル可能。 */

欠点

多重定義の例

// (1-1): 引数の数の違いによる多重定義
intFunction(void);
intFunction(intvalue);
intFunction(intvalue0,intvalue1);
// (2): 引数の修飾子の違いによる多重定義
intFunction(int*value);
intFunction(intconst*value);
intFunction(int*const*value);
intFunction(int*const*const*value);
// (3): 引数の型の違いによる多重定義
intFunction(charvalue);
intFunction(std::complex<double>const&value);
intFunction(...);// ※(注記)1
template<classType>intFunction(Typeconst&value);// ※(注記)2
structExample
{
// (1-2): 引数の型の違いによる多重定義(コンストラクター版)
Example(void);
Example(intvalue);

// (4): メンバー関数の修飾子の違いによる多重定義
intFunction(void);
intFunction(void)const;

// (1-3): 引数の型の違いによる多重定義(メンバー関数版)
intFunction(intvalue);
// (5): 戻り値の型の違いによる多重定義
operatorbool(void)const;
operatorint(void)const;
};

module Example
implicit none

! Function0, Function1をFunctionとして定義。FORTRANに予約語はなくFunctionは予約語ではない。
interface Function
 module procedure Function0,Function1
end interface Function
contains
 function Function0(value1)result(value0)
!省略
end function Function0

function Function1(value1,value2)result(value0)
!省略
end function Function1
end module Example

演算子の多重定義

テンプレートと多重定義

#include<cmath>
#include<cstdlib>
// 引数valueの符号に応じて、-1, 1または0を返す関数。
// ※(注記)absを使用しているため、引数に指定できる値の値の範囲はこの関数の引数と同じ型(反変な型)をとるabsの仕様に依存する。
template<classType>TypeSign(Typeconst&value)
{
returnType()==value?Type():abs(value)/value;// 除算演算子及び、abs関数の実体はSignの引数によって変わる
}
intmain(void)
{
doublevalue=-2;
std::valarray<double>array(2);
doublevalue_sign=Sign(value);// double型の-1, 1または0が返る
std::valarray<double>array_sign=Sign(array);// -1, 1または0を含むvalarrayの値が返る
returnEXIT_SUCCESS;
}

#include<cstdlib>
namespaceGraphics
{
classLine{/* 省略 */};
classEllipse{/* 省略 */};
classSquare
{
/* 省略 */
LineAt(size_tindex)const;// 四角形の辺を返す関数
/* 省略 */
};
voidDraw(...)
{
}
// 四角形を描画する
template<classType>voidDraw(Type&device,Squareconst&shape)
{
Draw(device,shape.At(0));
Draw(device,shape.At(1));
Draw(device,shape.At(2));
Draw(device,shape.At(3));
}
}
namespaceRasterDevice
{
structDevice{/* 省略 */};
// Raster形式用に線分を描画する
voidDraw(Device&device,Graphics::Lineconst&shape);
}
namespaceVectorDevice
{
structDevice{/* 省略 */};
// Vector形式用に線分を描画する
voidDraw(Device&device,Graphics::Lineconst&shape);
}
namespaceDisplayDevice
{
structDevice{/* 省略 */};
// 表示装置用に線分を描画する
voidDraw(Device&device,Graphics::Lineconst&shape);
}
intmain()
{
RasterDevice::Devicedevice0;
VectorDevice::Devicedevice1;
DisplayDevice::Devicedevice2;
Draw(device0,Graphics::Square(0,0,1,1));// 内部でRasterDevice::Draw( Device &, Graphics::Line const & )を呼び出す
Draw(device1,Graphics::Square(0,0,1,1));// 内部でVectorDevice::Draw( Device &, Graphics::Line const & )を呼び出す
Draw(device1,Graphics::Square(0,0,1,1));// 内部でDisplayDevice::Draw( Device &, Graphics::Line const & )を呼び出す
Draw(device0,Graphics::Ellipse(0,0,1,1));// Graphics::Draw( ... )を呼び出す
Draw(device1,Graphics::Ellipse(0,0,1,1));// Graphics::Draw( ... )を呼び出す
Draw(device2,Graphics::Ellipse(0,0,1,1));// Graphics::Draw( ... )を呼び出す
returnEXIT_SUCCESS;
}

多重定義濫用の弊害

曖昧な型を持つ言語

脚注

注釈

1. ^ 英: function overloading
2. ^ 英: operator overloading
3. ^ 英: method overloding
4. ^ 英: method overriding
5. ^ 英: implicit type conversion
6. ^ 英: type coercion
7. ^ 英: inheritance
8. ^ 英: inclusion
9. ^ 英: generic type
10. ^ 英: parametric type
11. ^ 英: polymorphism

出典

関連項目