Hoekom sou jy 'n opdrag in 'n toestand gebruik?

Question

In baie tale opdragte is reg in 'n toestand. Ek het nooit die rede agter dit insien. Hoekom sou jy skryf:

if (var1 = var2) {
  ...
}

in plaas van:

var1 = var2;
if (var1) {
  ...
}

Answer 1

Dit is meer nuttig vir lusse as wanneer state.

while( var = GetNext() )
{
  ...do something with var 
}

Wat sou anders afgelê moet word

var = GetNext();
while( var )
{
 ...do something
 var = GetNext();
}

Answer 2

Dit is meer nuttig as jy doen 'n beroep 'n funksie:

if (n = foo())
{
    /* foo returned a non-zero value, do something with the return value */
} else {
    /* foo returned zero, do something else */
}

Seker, kan jy net die n = cat (); op 'n aparte verklaring dan as (N), maar ek dink die bogenoemde is 'n redelik leesbare idioom.

Answer 3

Ek vind dit baie nuttig in kettings van aksies wat dikwels betrek fout opsporing, ens.

if ((rc = first_check(arg1, arg2)) != 0)
{
    report error based on rc
}
else if ((rc = second_check(arg2, arg3)) != 0)
{
    report error based on new rc
}
else if ((rc = third_check(arg3, arg4)) != 0)
{
    report error based on new rc
}
else
{
    do what you really wanted to do
}

Die alternatiewe (nie met behulp van die opdrag in die toestand) is:

rc = first_check(arg1, arg2);
if (rc != 0)
{
    report error based on rc
}
else
{
    rc = second_check(arg2, arg3);
    if (rc != 0)
    {
        report error based on new rc
    }
    else
    {
        rc = third_check(arg3, arg4);
        if (rc != 0)
        {
            report error based on new rc
        }
        else
        {
            do what you really wanted to do
        }
    }
}

Met uitgerekte foutopsporing, die alternatief kan afloop van die RK van die bladsy terwyl die opdrag-in-voorwaardelike weergawe nie doen nie.

Die fout tjeks kan ook 'aksies' - first_action(), second_action(), third_action() - natuurlik, eerder as om net tjeks. Dit wil sê, kan hulle nagegaan stappe in die proses dat die funksie is besturende. (Die meeste dikwels in die kode Ek werk met die funksies is in die trant van pre-toestand tjeks, of geheue toekennings wat nodig is vir die funksie om te werk, of langs soortgelyke lyne).

Answer 4

Dit kan nuttig wees as jy 'n funksie wat óf data om te werk of 'n vlag om 'n fout dui terug (of dat jy klaar is) is 'n beroep.

Iets soos:

while ((c = getchar()) != EOF) {
    // process the character
}

// end of file reached...

Persoonlik is dit 'n idioom Ek is nie uiters lief vir, maar soms is die alternatief is leliker.

Answer 5

GCC kan jou help om op te spoor (met Wall) as jy per ongeluk te probeer om 'n opdrag as 'n waarheid waarde gebruik, in geval dit beveel jy skryf

if ((n = foo())) {
   ...
}

I.E. gebruik ekstra hakies om aan te dui dat dit regtig wat jy wil hê.

Answer 6

Die idioom is meer nuttig as jy 'n while lus in plaas van 'n if verklaring wil skryf. Vir 'n if verklaring, kan jy dit op te breek as jy beskryf. Maar sonder hierdie konstruk, sal jy het om jouself te herhaal:

c = getchar();
while (c != EOF) {
    // ...
    c = getchar();
}

of gebruik 'n lus-en-'n-half struktuur:

while (true) {
    c = getchar();
    if (c == EOF) break;
    // ...
}

Ek sou verkies gewoonlik die lus-en-'n-half vorm.

Answer 7

Die kort antwoord is dat -Expression georiënteerde programmeertale toelaat meer bondige kode. Hulle vra nie dat jy dwing om aparte opdragte uit navrae .

Answer 8

In PHP, byvoorbeeld, is dit nuttig vir herhaling deur SQL databasis resultate:

while ($row = mysql_fetch_assoc($result)) {
    // Display row
}

Dit lyk baie beter as:

$row = mysql_fetch_assoc($result);
while ($row) {
    // Display row
    $row = mysql_fetch_assoc($result);
}

Answer 9

Die ander voordeel kom tydens die gebruik van gdb. In die volgende kode is die fout kode nie bekend as ons enkele stap.

while (checkstatus() != -1) {
    // process
}

In plaas

while (true) {
    int error = checkstatus();
    if (error != -1)
        // process
    else
        //fail
}

Nou gedurende enkele stap kan ons weet wat was die terugkeer fout kode van die checkstatus ().

Answer 10

Die rede hiervoor is:

1. Performance verbetering (Soms)

2. Klein Kode (Altyd)

Neem 'n voorbeeld: Daar is 'n metode someMethod() en in 'n if toestand wat jy wil om te kyk of die terugkeer waarde van die metode is null. As jy nie gaan om die terugkeer waarde weer gebruik.

If(null != someMethod()){
    String s = someMethod();
    ......
    //Use s
}

Dit sal die prestasie belemmer aangesien jy dieselfde metode twee keer 'n beroep. In plaas daarvan gebruik:

String s;
If(null != (s = someMethod())) {
    ......
    //Use s
}