Funzione sovraccarica chiamata con un parametro, ma pensavo di averne passati due

Question

Recentemente ho refactoring il codice come questo (MyClass A MyClassR).

#include <iostream>

class SomeMember
{
public:
  double m_value;

  SomeMember() : m_value(0) {}
  SomeMember(int a) : m_value(a) {}
  SomeMember(int a, int b)
  : m_value(static_cast<double>(a) / 3.14159 +
            static_cast<double>(b) / 2.71828)
  {}
};


class MyClass
{
public:
SomeMember m_first, m_second, m_third;

MyClass(const bool isUp, const int x, const int y)
{
  if (isUp)
  {
    m_first = SomeMember(x);
    m_second = SomeMember(y);
    m_third = SomeMember(x, y);
  }
  else
  {
    m_first = SomeMember(y);
    m_second = SomeMember(x);
    m_third = SomeMember(y, x);
  }
}
};


class MyClassR
{
public:
SomeMember m_first, m_second, m_third;

MyClassR(const bool isUp, const int x, const int y)
: m_first(isUp ? x : y)
, m_second(isUp ? y : x)
, m_third(isUp ? x, y : y, x)
{
}
};


int main()
{
    MyClass a(true, 1, 2);
    MyClassR b(true, 1, 2);

    using namespace std;
    cout.precision(10);
    cout
        << "a:" << endl
        << "\tfirst: " << a.m_first.m_value 
        << "\tsecond: " << a.m_second.m_value 
        << "\tthird: " << a.m_third.m_value << endl;

    cout
        << "b:" << endl
        << "\tfirst: " << b.m_first.m_value
        << "\tsecond: " << b.m_second.m_value
        << "\tthird: " << b.m_third.m_value << endl;

    return 0;
}

• Qual è l'errore?
• perché si compila (testato con VC6 nonché il livello di avviso VC9 4:nessuna lamentela) e
• qual è il modo giusto per farlo?

(Presumo) di avere già tutte queste risposte, ma penso che sia un problema interessante da condividere.

Aggiornamento
Codice esteso in modo che sia possibile "copiare, incollare ed eseguire".Nemmeno VC9 mi ha dato lamentele VC6 non è il problema qui.
Per completezza, l'output è:

a:
        first: 1        second: 2       third: 1.054069532
b:
        first: 1        second: 2       third: 1.004499999

Answer 1

Non sono sicuro di cosa ti aspetti esattamente, ma iniziamo...

• Prima di tutto, abbandona VC6. Sul serio. Usarlo è un grosso problema poiché semplicemente non è conforme agli standard e preclude molte opzioni.Usarlo correttamente è come giocare alla roulette russa.

• Il tuo costruttore di m_third non fa quello che pensi che faccia.Non puoi scrivere un'espressione condizionale come questa:"diversi parametri" non è valido espressione in C++ e l'operatore condizionale funziona sulle espressioni.

• Il codice viene compilato perché è fermo corretto, semplicemente non fa quello che vuoi.Invece di utilizzare “diversi parametri”, valuta l’operatore del punto di sequenza (,) che prende solo il file scorso valore dell'espressione, quindi il tuo condizionale è effettivamente equivalente a: isUp ? y : x

• Il modo giusto è usare due condizionali: m_third(isUp ? x : y, isUp ? y : x)

• Il terzo costruttore di SomeMember è sbagliato, il valore potrebbe eccedere, producendo un valore negativo: dubito fortemente che sia quello che desideri.

Answer 2

m_third(isUp ? x, y : y, x)

Questo sembra sbagliato essere. Il primo x è un'espressione inutile in quanto non ha effetti collaterali e il risultato non è utilizzato, poi le due parti del : hanno lo stesso valore e gli effetti collaterali così ?: può essere elimintated come espressione prima della ? ha anche effetti collaterali .

m_third(y, x)

Ma ora non fa quello che il codice originale fa ... è questo l'errore?

Answer 3

  

Qual è l'errore   qual è il modo giusto di farlo?

Credo che la vostra intenzione è quella di mostrare un qualche tipo di utilizzo ingenuo di operatore virgola in combinazione con ternario?, Forse c'è qualche intelligente e inaspettata Gotcha priorità degli operatori nascosto, ma che penso che il codice è assolutamente artificiale. Se questo è il punto, che io direi il "modo giusto di farlo" è non utilizzare C ++ o prima imparare prima di utilizzarla. Sì, ha molti costrutti che possono apparire come "stranezze" e si può creare un sacco di codice stranamente Looking accettato da un compilatore. Usando C ++ Direi che si sono assunti di conoscere gli strumenti.

  

Perché non compilare

Perché contiene alcun errore e si tratta di un codice corretto C ++ senza ambiguità.