下面我主要介绍用于类型转换的关键字:explicit、implicit 和 operator。
2.1 explicit关键字
explicit 关键字用于声明必须使用强制转换来调用的用户定义的类型转换运算符。
static explicit operator target_type { source_type identifier }
参数:
注意:
实例:下例定义了一个Digit结构,该结构表示单个十进制数字。还定义了一个运算符,用于将byte类转换为Digit结构,但因为并非所有字节都可以转换为Digit,所以该转换时显示的。
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace explicits
{
struct Digit
{
byte value;
public Digit(byte value)
{
if (value < 0 || value > 9) throw new ArgumentException();
this.value = value;
}
//定义byte到Digit的显示转换运算符
public static explicit operator Digit(byte b)
{
Console.WriteLine("conversion occured");
return new Digit(b);
}
}
class Program
{
static void Main(string[] args)
{
byte b = 3;
Digit d = (Digit)b; //显示转换
Console.Read();
}
}
}
implicit 关键字用于声明隐式的用户定义类型转换运算符。
static implicit operator target_type { source_type identifier }
注意:
operator 关键字用于在类或结构声明中声明运算符。运算符声明可以采用下列四种形式之一:
public static result-type operator unary-operator ( op-type operand )
public static result-type operator binary-operator ( op-type operand, op-type2 operand2 )
public static implicit operator conv-type-out ( conv-type-in operand )
public static explicit operator conv-type-out ( conv-type-in operand )
参数:
注意:
下面是一个类型转换关键字:explicit、implicit 和 operator 的一个例子:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace Conversions
{
public class Fraction
{
private int numerator;
private int denominator;
public Fraction(int numerator, int denominator)
{
Console.WriteLine("In Fraction Constructor(int,int)");
this.numerator = numerator;
this.denominator = denominator;
}
public static implicit operator Fraction(int theInt)
{
Console.WriteLine("In implicit conversion to Fraction");
return new Fraction(theInt);
}
public static explicit operator int(Fraction theFraction)
{
Console.WriteLine("In explicit conversion to int");
return theFraction.numerator / theFraction.denominator;
}
public static bool operator ==(Fraction lhs, Fraction rhs)
{
Console.WriteLine("In operator ==");
if (lhs.denominator == rhs.denominator && lhs.numerator == rhs.numerator)
{
return true;
}
//此处省去处理不同分母分数的代码
return false;
}
public static bool operator !=(Fraction lhs, Fraction rhs)
{
Console.WriteLine("In operator !=");
return !(lhs == rhs);
}
public override bool Equals(object o)
{
Console.WriteLine("In method Equals");
if (!(o is Fraction))
{
return false;
}
return this == (Fraction)o;
}
public static Fraction operator +(Fraction lhs, Fraction rhs)
{
Console.WriteLine("In operator+");
if (lhs.denominator == rhs.denominator)
{
return new Fraction(lhs.numerator + rhs.numerator, lhs.denominator);
}
//对不同的分母分数的简单解决方案
//1/2 + 3/4==(1*4) + (3*2) /(2*4) ==10/8
int firstProduct = lhs.numerator * rhs.denominator;
int secondProduct = rhs.numerator * lhs.denominator;
return new Fraction(
firstProduct + secondProduct,
lhs.denominator * rhs.denominator);
}
public override string ToString()
{
String s = numerator.ToString() + "/" + denominator.ToString();
return s;
}
}
class Program
{
static void Main(string[] args)
{
Fraction f1 = new Fraction(3, 4);
Console.WriteLine("f1: {0}", f1.ToString());
Fraction f2 = new Fraction(2, 4);
Console.WriteLine("f2: {0}", f2.ToString());
Fraction f3 =f1 + f2;
Console.WriteLine("f1 + f2 = f3: {0}", f3.ToString());
Fraction f4 = f3 + 5;
Console.WriteLine("f3 +5= f4: {0}", f4.ToString());
Fraction f5 = new Fraction(2, 4);
if (f5 == f2)
{
Console.WriteLine("F5: {0} ==F2: {1}", f5.ToString(), f2.ToString());
}
Console.Read();
}
}
}