Calificación:
  • 0 voto(s) - 0 Media
  • 1
  • 2
  • 3
  • 4
  • 5
[Tutorial] C# Sobrecarga de Operadores. [Intermedio]
#1
Tutorial de sobrecarga de operadores
Visual Studio .NET 2003
Este tutorial muestra cómo se pueden sobrecargar operadores mediante clases definidas por el usuario.

Archivos de ejemplo

Vea Ejemplo de sobrecarga de operadores para descargar y generar los archivos de ejemplo que se utilizan en este tutorial.

Información adicional

7.2.2 Sobrecarga de operadores
Operadores de C#
Operadores sobrecargables
true
false
bool
Tutorial

La sobrecarga de operadores permite utilizar implementaciones de operadores definidas por el usuario en operaciones en las que al menos uno de los operandos es de un tipo estructura o clase definido por el usuario. Este tutorial contiene dos ejemplos. El primer ejemplo muestra cómo utilizar la sobrecarga de operadores para crear una clase de números complejos que define la suma compleja. El segundo ejemplo muestra cómo utilizar la sobrecarga de operadores para implementar un tipo lógico de tres valores.

Ejemplo 1

Este ejemplo muestra cómo utilizar la sobrecarga de operadores para crear una clase de números complejos Complex que define la suma compleja. El programa muestra las partes real e imaginaria de los números y el resultado de la suma mediante un método sustituto del método ToString.

// complex.cs
using System;

public struct Complex
{
public int real;
public int imaginary;

public Complex(int real, int imaginary)
{
this.real = real;
this.imaginary = imaginary;
}

// Declare which operator to overload (+), the types
// that can be added (two Complex objects), and the
// return type (Complex):
public static Complex operator +(Complex c1, Complex c2)
{
return new Complex(c1.real + c2.real, c1.imaginary + c2.imaginary);
}
// Override the ToString method to display an complex number in the suitable format:
public override string ToString()
{
return(String.Format("{0} + {1}i", real, imaginary));
}

public static void Main()
{
Complex num1 = new Complex(2,3);
Complex num2 = new Complex(3,4);

// Add two Complex objects (num1 and num2) through the
// overloaded plus operator:
Complex sum = num1 + num2;

// Print the numbers and the sum using the overriden ToString method:
Console.WriteLine("First complex number: {0}",num1);
Console.WriteLine("Second complex number: {0}",num2);
Console.WriteLine("The sum of the two numbers: {0}",sum);

}
}
Resultado

First complex number: 2 + 3i
Second complex number: 3 + 4i
The sum of the two numbers: 5 + 7i
Ejemplo 2

Este ejemplo muestra cómo utilizar la sobrecarga de operadores para implementar un tipo lógico de tres valores. Los valores posibles de este tipo son DBBool.dbTrue, DBBool.dbFalse y DBBool.dbNull, donde el miembro dbNull indica un valor desconocido.

Nota Los operadores True y False definidos aquí sólo resultan de utilidad para tipos que representan valores True, False y Null (ni True ni False), como los utilizados en bases de datos.
// dbbool.cs
using System;

public struct DBBool
{
// The three possible DBBool values:
public static readonly DBBool dbNull = new DBBool(0);
public static readonly DBBool dbFalse = new DBBool(-1);
public static readonly DBBool dbTrue = new DBBool(1);
// Private field that stores -1, 0, 1 for dbFalse, dbNull, dbTrue:
int value;

// Private constructor. The value parameter must be -1, 0, or 1:
DBBool(int value)
{
this.value = value;
}

// Implicit conversion from bool to DBBool. Maps true to
// DBBool.dbTrue and false to DBBool.dbFalse:
public static implicit operator DBBool(bool x)
{
return x? dbTrue: dbFalse;
}

// Explicit conversion from DBBool to bool. Throws an
// exception if the given DBBool is dbNull, otherwise returns
// true or false:
public static explicit operator bool(DBBool x)
{
if (x.value == 0) throw new InvalidOperationException();
return x.value > 0;
}

// Equality operator. Returns dbNull if either operand is dbNull,
// otherwise returns dbTrue or dbFalse:
public static DBBool operator ==(DBBool x, DBBool y)
{
if (x.value == 0 || y.value == 0) return dbNull;
return x.value == y.value? dbTrue: dbFalse;
}

// Inequality operator. Returns dbNull if either operand is
// dbNull, otherwise returns dbTrue or dbFalse:
public static DBBool operator !=(DBBool x, DBBool y)
{
if (x.value == 0 || y.value == 0) return dbNull;
return x.value != y.value? dbTrue: dbFalse;
}

// Logical negation operator. Returns dbTrue if the operand is
// dbFalse, dbNull if the operand is dbNull, or dbFalse if the
// operand is dbTrue:
public static DBBool operator !(DBBool x)
{
return new DBBool(-x.value);
}

// Logical AND operator. Returns dbFalse if either operand is
// dbFalse, dbNull if either operand is dbNull, otherwise dbTrue:
public static DBBool operator &(DBBool x, DBBool y)
{
return new DBBool(x.value < y.value? x.value: y.value);
}

// Logical OR operator. Returns dbTrue if either operand is
// dbTrue, dbNull if either operand is dbNull, otherwise dbFalse:
public static DBBool operator |(DBBool x, DBBool y)
{
return new DBBool(x.value > y.value? x.value: y.value);
}

// Definitely true operator. Returns true if the operand is
// dbTrue, false otherwise:
public static bool operator true(DBBool x)
{
return x.value > 0;
}

// Definitely false operator. Returns true if the operand is
// dbFalse, false otherwise:
public static bool operator false(DBBool x)
{
return x.value < 0;
}

// Overload the conversion from DBBool to string:
public static implicit operator string(DBBool x)
{
return x.value > 0 ? "dbTrue"
: x.value < 0 ? "dbFalse"
: "dbNull";
}

// Override the Object.Equals(object o) method:
public override bool Equals(object o)
{
try
{
return (bool) (this == (DBBool) o);
}
catch
{
return false;
}
}

// Override the Object.GetHashCode() method:
public override int GetHashCode()
{
return value;
}

// Override the ToString method to convert DBBool to a string:
public override string ToString()
{
switch (value)
{
case -1:
return "DBBool.False";
case 0:
return "DBBool.Null";
case 1:
return "DBBool.True";
default:
throw new InvalidOperationException();
}
}
}

class Test
{
static void Main()
{
DBBool a, b;
a = DBBool.dbTrue;
b = DBBool.dbNull;

Console.WriteLine( "!{0} = {1}", a, !a);
Console.WriteLine( "!{0} = {1}", b, !b);
Console.WriteLine( "{0} & {1} = {2}", a, b, a & b);
Console.WriteLine( "{0} | {1} = {2}", a, b, a | b);
// Invoke the true operator to determine the Boolean
// value of the DBBool variable:
if (b)
Console.WriteLine("b is definitely true");
else
Console.WriteLine("b is not definitely true");
}
}
Resultado

!DBBool.True = DBBool.False
!DBBool.Null = DBBool.Null
DBBool.True & DBBool.Null = DBBool.Null
DBBool.True | DBBool.Null = DBBool.True
b is not definitely true

Tutorial de conversiones definidas por el usuario
Visual Studio .NET 2003
Este tutorial muestra cómo definir y utilizar conversiones hacia o desde clases o estructuras.

Archivos de ejemplo

Vea Ejemplo de conversiones definidas por el usuario para descargar y generar los archivos de ejemplo que se utilizan en este tutorial.

Información adicional

explicit
implicit
Operador ()
Tabla de conversiones numéricas implícitas
operator
6.4 Conversiones definidas por el usuario
6.4.4 Conversiones explícitas definidas por el usuario
Tutorial

C# permite a los programadores declarar conversiones de clases o estructuras para convertirlas en otras clases o estructuras o en tipos básicos. Las conversiones se definen como operadores con el nombre del tipo al cual convierten.

En C#, las conversiones se pueden declarar bien como declaraciones implícitas (implicit), las cuales se producen automáticamente cuando son necesarias, o bien como declaraciones explícitas (explicit), que requieren que se invoque una conversión explícita. Todas las conversiones deben ser static, y pueden recibir el tipo sobre el que está definida la conversión o bien devolver ese tipo.

Este tutorial presenta dos ejemplos. El primer ejemplo muestra cómo declarar y utilizar conversiones, mientras que el segundo ejemplo ilustra las conversiones entre estructuras.

Ejemplo 1

En este ejemplo, se declara un tipo RomanNumeral y se definen varias conversiones hacia y desde él.

// conversion.cs
using System;

struct RomanNumeral
{
public RomanNumeral(int value)
{
this.value = value;
}
// Declare a conversion from an int to a RomanNumeral. Note the
// the use of the operator keyword. This is a conversion
// operator named RomanNumeral:
static public implicit operator RomanNumeral(int value)
{
// Note that because RomanNumeral is declared as a struct,
// calling new on the struct merely calls the constructor
// rather than allocating an object on the heap:
return new RomanNumeral(value);
}
// Declare an explicit conversion from a RomanNumeral to an int:
static public explicit operator int(RomanNumeral roman)
{
return roman.value;
}
// Declare an implicit conversion from a RomanNumeral to
// a string:
static public implicit operator string(RomanNumeral roman)
{
return("Conversion not yet implemented");
}
private int value;
}

class Test
{
static public void Main()
{
RomanNumeral numeral;

numeral = 10;

// Call the explicit conversion from numeral to int. Because it is
// an explicit conversion, a cast must be used:
Console.WriteLine((int)numeral);

// Call the implicit conversion to string. Because there is no
// cast, the implicit conversion to string is the only
// conversion that is considered:
Console.WriteLine(numeral);

// Call the explicit conversion from numeral to int and
// then the explicit conversion from int to short:
short s = (short)numeral;

Console.WriteLine(s);
}
}
Resultado

10
Conversion not yet implemented
10
Ejemplo 2

Este ejemplo define dos estructuras, RomanNumeral y BinaryNumeral, y muestra dos conversiones entre ellas.

// structconversion.cs
using System;

struct RomanNumeral
{
public RomanNumeral(int value)
{
this.value = value;
}
static public implicit operator RomanNumeral(int value)
{
return new RomanNumeral(value);
}
static public implicit operator RomanNumeral(BinaryNumeral binary)
{
return new RomanNumeral((int)binary);
}
static public explicit operator int(RomanNumeral roman)
{
return roman.value;
}
static public implicit operator string(RomanNumeral roman)
{
return("Conversion not yet implemented");
}
private int value;
}

struct BinaryNumeral
{
public BinaryNumeral(int value)
{
this.value = value;
}
static public implicit operator BinaryNumeral(int value)
{
return new BinaryNumeral(value);
}
static public implicit operator string(BinaryNumeral binary)
{
return("Conversion not yet implemented");
}
static public explicit operator int(BinaryNumeral binary)
{
return(binary.value);
}

private int value;
}

class Test
{
static public void Main()
{
RomanNumeral roman;
roman = 10;
BinaryNumeral binary;
// Perform a conversion from a RomanNumeral to a
// BinaryNumeral:
binary = (BinaryNumeral)(int)roman;
// Performs a conversion from a BinaryNumeral to a RomanNumeral.
// No cast is required:
roman = binary;
Console.WriteLine((int)binary);
Console.WriteLine(binary);
}
}
Resultado

10
Conversion not yet implemented
Descripción del código

En el ejemplo anterior, la instrucción:
binary = (BinaryNumeral)(int)roman;
realiza una conversión de un RomanNumeral a un BinaryNumeral. Como no existe una conversión directa de RomanNumeral a BinaryNumeral, se utiliza una conversión explícita de un RomanNumeral a un int, y otra conversión explícita para convertir de un int a un BinaryNumeral.

Además, la instrucción:
roman = binary;
realiza una conversión de un BinaryNumeral a un RomanNumeral. Como RomanNumeral define una conversión implícita desde BinaryNumeral, no se requiere ninguna conversión explícita.


Posibles temas similares...
Tema Autor Respuestas Vistas Último mensaje
Información [Tutorial] Certificado SSL Gratis StartSSL 2016 Tutorial DarkMaster 26 5,103 28-04-2016, 03:39 AM
Último mensaje: Lob3zNo
Bombilla [Tutorial] SSL Gratis, Conseguir e Instalar Certificado DarkMaster 16 871 06-01-2016, 01:32 AM
Último mensaje: DarkMaster
  [PUBLICO] Tutorial Botones con perspectiva 3D AngelKrak 0 233 17-01-2015, 05:44 AM
Último mensaje: AngelKrak
  Curso C++: 4.- Operadores Samo30 0 345 19-05-2014, 03:35 AM
Último mensaje: Samo30
  [Tutorial] Aumentar el Tamaño Máximo al Cargar Archivos con PHP y Apache papanoel 0 667 22-01-2014, 04:38 AM
Último mensaje: papanoel
  [PHP] Operadores básicos torgar22 0 257 07-05-2013, 01:35 PM
Último mensaje: torgar22
  Tutorial Css Primera Parte para phpost JNeutron 4 1,051 24-02-2013, 04:01 AM
Último mensaje: Echizen
  [TUTORIAL] Conexión a una Base de Datos desde [PHP] lapipichapa 0 490 15-02-2013, 05:52 PM
Último mensaje: lapipichapa
  Tutorial de .htaccess | Control de acceso a carpetas diringax 11 1,452 13-01-2013, 12:28 PM
Último mensaje: papi
  [TUTORIAL] Como evitar el Hotlinkeo (robo de imágenes) Taquion 8 1,686 12-01-2013, 05:50 PM
Último mensaje: natestale



Usuarios navegando en este tema: 1 invitado(s)