Curso de C#: Lição 18: Overloading Operators

Esta lição mostra como a sobrecarga C # operadores. Our objectives are as follows: Os nossos objectivos são os seguintes:Entenda o que é operador sobrecarregar. Determinar quando é apropriado para sobrecarregar um operador. Aprenda a sobrecarregar um operador. Familiarizar-se com regras de operador sobrecarregar

Por | @oficinadanet Programação
Esta lição mostra como a sobrecarga C # operadores. Our objectives are as follows: Os nossos objectivos são os seguintes:
  • Entenda o que é operador sobrecarregar
  • Determinar quando é apropriado para sobrecarregar um operador
  • Aprenda a sobrecarregar um operador
  • Familiarizar-se com regras de operador sobrecarregar


Sobre Overloading Operators


Na Lição 2, você aprendeu que os operadores estavam disponíveis em C #, que incluiu + (mais), - (menos), ^ (ou exclusivo), e outros. Os operadores são definidos para o alto-tipo, mas isso não é tudo. Você pode incluir seus próprios tipos de operadores, o que lhes permite ser usado tanto como os operadores com o alto-C # tipos.

Para entender a necessidade de Overloading Operators, imagine que você precisa para realizar operações matemáticas matriz em seu programa. Você poderia instanciar um jovem 2-dimensional arrays e fazer aquilo que você precisa. No entanto, acrescentar que o requisito de comportamento matriz para ser reutilizável. & Porque o que você precisa fazer a mesma coisa em outros programas e quiser tirar partido do facto de que você já tenha escrito o código, você quer criar um novo tipo.

Então, você cria um tipo de Matrix, o que poderia ser uma classe ou de uma struct.Agora considere como este tipo Matrix seriam utilizados. Você gostaria de inicializar dois ou mais instâncias Matrix com os dados e, em seguida, fazer uma operação matemática com eles, tais como adicionar ou obter um produto escalar.Para realizar a operação matemática, você pode implementar uma Add(), DotProduct (), e de outros métodos para fazer o trabalho. Utilizando as classes teriam parecido com este:

Matrix result = mat1.Add(mat2);  // instance

ou

Matrix result = Matrix.Add(mat1, mat2);  // static

ou ainda pior

Matrix result = mat1.DotProduct(mat2).DotProduct(mat3); // and so on...

O problema com utilizando métodos como essa é que é pesado, palavrosa, e pouco natural para o problema que você está tentando resolver. Seria muito mais fácil de ter um operador + para adicionar a operação e um operador * para o produto escalar operação. O seguinte mostra como a sintaxe aparece usando operadores:

Matrix result = mat1 + mat2;

ou

Matrix result = mat1 * mat2;

ou ainda melhor

Matrix result = mat1 * mat2 * mat3 * mat4;

Isto é muito mais elegante e mais fácil de trabalhar. Para uma única operação, pode-se argumentar que a quantidade de trabalho para implementar uma sintaxe mais do que outro que não é grande. No entanto, quando encadeamento múltiplas operações matemáticas, a sintaxe é muito mais simples. Além disso, se o principal tipo de seus usuários são matemáticos e os cientistas, os operadores são mais intuitiva e natural.

Quando não usar Operator Overloading


Uma boa parte da discussão, até agora, tem enfatizado a necessidade de escrever código e implementar os tipos da forma mais simples e mais natural possível. Um conceito muito importante a lembrar é que, embora os operadores sejam simples, eles nem sempre são naturais. No exemplo acima ele fez sentido de utilizar os operadores com o tipo Matrix. Esta é semelhante à da razão pela qual os operadores fazem sentido com o alto-tipos como int e float. No entanto, é fácil de abuso operadores e criar convolutos implementações que é difícil para qualquer pessoa, incluindo o autor original, de compreender.

Para um exemplo de uma má execução, considerar que uma classe de carro uma aplicação que permite que você precisa para estacionar o carro em uma garagem. Seria um erro pensar que a execução foi inteligente seguintes:
Car mySedan = new Car();
Garage parkingGarage = new Garage();
mySedan = mySedan + parkingGarage; // park car in the garage


Este código é mau. Caso você tenha a tentação de fazer alguma coisa como esta - não. Ninguém irá realmente compreender o que significa e eles não vão pensar que é inteligente. Além disso, dói a manutenção da candidatura, porque é tão difícil de entender o que o código faz. Apesar de o comentário existe, ela não ajuda muito e se não houver, seria ainda mais difícil de apreender o conceito de adição de um carro e uma garagem.

A ideia é esta: Use operadores onde eles prestam compreensão ea simplicidade de um tipo. Caso contrário, não utilizá-los.

Implementar um operador Overloaded Operator


A sintaxe necessária para implementar um operador está muito sobrecarregado o mesmo que um método estático com uma jovem excepções. Você deve usar o operador palavra-chave e especificar o operador símbolo sendo sobrecarregados. Aqui está um exemplo de como o esqueleto produto escalar operador poderá ser implementada:

public static Matrix operator *(Matrix mat1, Matrix mat2)
{
    // dot product implementation
}


Note que o método é estático. Usar a palavra-chave operador após especificando o tipo de retorno, Matrix, neste caso. Na sequência do operador palavra-chave, o próprio operador símbolo é especificada e, depois, há um conjunto de parâmetros a serem operados. Ver listagem completa 18-1 para um exemplo de como a implementar e utilizar um operador sobrecarregado.

Listing 18-1. Matrix.cs Implementar um Overloaded Operator: Matrix.cs
using System;

class Matrix
{
public const int DimSize = 3;
private double[,] m_matrix = new double[DimSize, DimSize];

// allow callers to initialize
public double this[int x, int y]
{
get { return m_matrix[x, y]; }
set { m_matrix[x, y] = value; }
}

// let user add matrices
public static Matrix operator +(Matrix mat1, Matrix mat2)
{
Matrix newMatrix = new Matrix();

for (int x=0; x < DimSize; x++)
for (int y=0; y < DimSize; y++)
newMatrix[x, y] = mat1[x, y] + mat2[x, y];

return newMatrix;
}
}

class MatrixTest
{
// used in the InitMatrix method.
public static Random m_rand = new Random();

// test Matrix
static void Main()
{
Matrix mat1 = new Matrix();
Matrix mat2 = new Matrix();

// init matrices with random values
InitMatrix(mat1);
InitMatrix(mat2);

// print out matrices
Console.WriteLine("Matrix 1: ");
PrintMatrix(mat1);

Console.WriteLine("Matrix 2: ");
PrintMatrix(mat2);

// perform operation and print out results
Matrix mat3 = mat1 + mat2;

Console.WriteLine();
Console.WriteLine("Matrix 1 + Matrix 2 = ");
PrintMatrix(mat3);

Console.ReadLine();
}

// initialize matrix with random values
public static void InitMatrix(Matrix mat)
{
for (int x=0; x < Matrix.DimSize; x++)
for (int y=0; y < Matrix.DimSize; y++)
mat[x, y] = m_rand.NextDouble();
}

// print matrix to console
public static void PrintMatrix(Matrix mat)
{
Console.WriteLine();
for (int x=0; x < Matrix.DimSize; x++)
{
Console.Write("[ ");
for (int y=0; y < Matrix.DimSize; y++)
{
// format the output
Console.Write("{0,8:#.000000}", mat[x, y]);

if ((y+1 % 2) < 3)
Console.Write(", ");
}
Console.WriteLine(" ]");
}
Console.WriteLine();
}
}


Similar ao esqueleto exemplo de produto escalar o operador, a matriz na classe Listing 18-1 contém uma sobrecarga para o operador + operador. Para sua comodidade, extraído da pertinente sobrecarga na execução do código abaixo:
// let user add matrices
public static Matrix operator +(Matrix mat1, Matrix mat2)
{
Matrix newMatrix = new Matrix();

for (int x=0; x < DimSize; x++)
for (int y=0; y < DimSize; y++)
newMatrix[x, y] = mat1[x, y] + mat2[x, y];

return newMatrix;
}


O operador é estática, que é a única maneira que pode e deve ser declarada porque pertence a um operador do tipo e não de uma instância específica. Existem apenas algumas regras que você tem que seguir aquando da execução operador sobrecargas. Que designa esta situação como um operador é o uso da palavra-chave operador, seguido pelo símbolo +. O parâmetro de ambos os tipos estão juntando tipo, Matrix. A implementação de sobrecarregar o operador cria uma nova instância do tipo de retorno e executa uma matriz acrescentar.

Regras de Operador


C # impõe certas regras quando você sobrecarga operadores. Uma regra é que você deve aplicar o operador de sobrecarga do tipo que irá utilizá-lo.

Outra regra é que você deve executar correspondência operadores. Por exemplo, se você sobrecarga ==, você deve também executar! =. O mesmo vale para <= e> =.

Quando você executar um operador, as suas obras também compostos operador. Por exemplo, uma vez que o operador + para o Matrix tipo foi executado, você também pode usar o operador + = em Matrix tipos.

Resumo


Operador sobrecarga permite-lhe implementar tipos que se comportam como o alto-quando utiliza tipos operadores. Certifique-se de utilizar os operadores de uma forma que é natural e compreensível para o tipo. Sintaxe operadores de execução é muito mais como um método estático, mas inclui a palavra-chave operador eo operador símbolo no lugar de um identificador. Além disso, existem regras, tais como a manutenção simetria, para a utilização de operadores, que incentivem a construção de tipos robustos.

Artigo automaticamente traduzido de: http://www.csharp-station.com/Tutorials/Lesson18.aspx

Mais sobre: curso_c_sharp c_sharp
Share Tweet
Recomendado
Comentários
Carregar comentários
Destaquesver tudo