Início / coding / Perguntas / 78943145
Accepted
FluidMechanics Potential Flows
Asked: 2024-09-03 15:32:26 +0800 CST

Sobrecarga de verdadeiro e falso, sobrecarga de falso nunca parece ser usada

  • 772

No livro C#12 In a Nutshell (p. 259 Capítulo Sobrecarga de verdadeiro e falso), eles nos fornecem este exemplo para ilustrar como sobrecarregar os operadores verdadeiro e falso.

SqlBoolean a = SqlBoolean.Null;
if (a)
    Console.WriteLine ("True");
else if (!a)
    Console.WriteLine ("False");
else
    Console.WriteLine ("Null");

public struct SqlBoolean
{
    public static bool operator true (SqlBoolean x)
    {
        return  x.m_value == True.m_value;
    }

    public static bool operator false(SqlBoolean x)
    {
        return x.m_value == False.m_value;
    }

    public static SqlBoolean operator ! (SqlBoolean x)
    {
        if (x.m_value == Null.m_value) return Null;
        if (x.m_value == False.m_value) return True;
        return False;
    }

    public static readonly SqlBoolean Null = new SqlBoolean (0);
    public static readonly SqlBoolean False = new SqlBoolean (1);
    public static readonly SqlBoolean True = new SqlBoolean (2);

    SqlBoolean (byte value) { m_value = value; }
    byte m_value;
}

Estou tentando entender quando a falsesobrecarga é chamada, e pelo meu entendimento (e confirmando brincando com o depurador), parece que ela nunca é chamada. Por que a falsesobrecarga seria útil então? Já que só usamos while (a)or , etc ... Sobrecarregar and while (!a)não seria o suficiente?true!

c#

2 respostas

  1. Best Answer

    O padrão C# tem esta nota :

    Nota: Embora truee falsenão sejam usados ​​explicitamente em expressões (e, portanto, não estão incluídos na tabela de precedência em §12.4.2), eles são considerados operadores porque são invocados em vários contextos de expressão: expressões booleanas (§12.24) e expressões envolvendo os operadores lógicos condicionais (§12.18) e condicionais (§12.14). nota final

    Seguindo esses links, você verá que o falseoperador é usado em operadores lógicos condicionais :

    A operação x && yé avaliada como T.false(x) ? x : T.&(x, y), onde T.false(x)é uma invocação do operator falsedeclarado em T, e T.&(x, y)é uma invocação do selecionado operator &. Em outras palavras, xé primeiro avaliado e operator falseé invocado no resultado para determinar se xé definitivamente falso. Então, se xfor definitivamente falso, o resultado da operação é o valor previamente computado para x. Caso contrário, yé avaliado, e o selecionado operator &é invocado no valor previamente computado para xe o valor computado para ypara produzir o resultado da operação.

    Aqui está um código de teste para mostrar os vários momentos em que os operadores são usados:

    LoggingBoolean t = new LoggingBoolean(true);
LoggingBoolean f = new LoggingBoolean(false);

Console.WriteLine("Boolean expression");
if (t)
{
    Console.WriteLine("In true body");
}

if (f)
{
    Console.WriteLine("In false body");
}

Console.WriteLine("Conditional operator");

Console.WriteLine(t ? "true branch" : "false branch");
Console.WriteLine(f ? "true branch" : "false branch");

Console.WriteLine("Conditional && logic");
Console.WriteLine(t && t);
Console.WriteLine(t && f);
Console.WriteLine(f && t);
Console.WriteLine(f && f);

Console.WriteLine("Conditional || logic");
Console.WriteLine(t || t);
Console.WriteLine(t || f);
Console.WriteLine(f || t);
Console.WriteLine(f || f);

internal struct LoggingBoolean
{
    public bool Value { get; }

    public LoggingBoolean(bool value) => Value = value;

    public static bool operator false(LoggingBoolean x)
    {
        Console.WriteLine("false operator called");
        return !x.Value;
    }

    public static bool operator true(LoggingBoolean x)
    {
        Console.WriteLine("true operator called");
        return x.Value;
    }

    public static LoggingBoolean operator &(LoggingBoolean x, LoggingBoolean y) =>
        new LoggingBoolean(x.Value && y.Value);

    public static LoggingBoolean operator |(LoggingBoolean x, LoggingBoolean y) =>
        new LoggingBoolean(x.Value || y.Value);

    public override string ToString() => $"LoggingBoolean({Value})";
}

    Saída:

    Boolean expression
true operator called
In true body
true operator called
Conditional operator
true operator called
true branch
true operator called
false branch
Conditional && logic
false operator called
LoggingBoolean(True)
false operator called
LoggingBoolean(False)
false operator called
LoggingBoolean(False)
false operator called
LoggingBoolean(False)
Conditional || logic
true operator called
LoggingBoolean(True)
true operator called
LoggingBoolean(True)
true operator called
LoggingBoolean(True)
true operator called
LoggingBoolean(False)
    • 5

  2. O operador falso entrará em ação quando houver curto-circuito envolvido - com &&o operador, quando se a primeira expressão falhar, podemos ignorar a segunda.

    Nessa situação, o operador falso será invocado, veja o exemplo:

    // Need to define this operator in order to leverage short circuiting with &&,
// it will be analogical with ||
public static SqlBoolean operator &(SqlBoolean left, SqlBoolean right)
{
    // Implement appropriately, this is just example
    return True;
}

    e então o teste:

    var shortCircuitAnd = a && a;
    • 3

relate perguntas