Hej!

Är det någon som har gjort detta förut och kan tala om för mig vad jag gör för fel?
Jag har i klienten :

if( b && c && a)

och ska kunna ha hur många operander som helst, men jag kan bara använda två, för om jag använder fler så får jag detta felmeddelande:

error C2677: binary '&&' : no global operator found which takes type 'Boolean' (or there is no acceptable conversion)

Jag hat testat många varianter med inget fungerar. Hoppas att någon har någon ide :)

Mvh
/Jan

******** Min cpp-fil *********************************************

bool Boolean::operator&&(const Boolean& rhs)const
{

if(*truth_value == TRUE && *rhs.truth_value == TRUE)
{
return true;
}
return false;
}

******** Min h-fil *********************************************
class Boolean
{

public:

enum TruthValue {FALSE, TRUE};

Boolean(TruthValue tv); //Konstruktor

Boolean (bool value); //Konstruktor
Boolean(const Boolean& src); //Copy-konstruktor
virtual ~Boolean(); //Destruktor

bool Boolean::operator==(const Boolean& rhs)const;
bool Boolean::operator!=(const Boolean& rhs)const;
bool Boolean::operator!();
bool Boolean::operator&&(const Boolean& rhs)const;
bool Boolean::operator||(const Boolean& rhs)const;

private:

TruthValue* truth_value; //En TruthValue-pekare som heter truth_value som

};

Jag förstår inte riktigt poängen med att göra en ny boolean (det ser helt vansinnigt ut, i synnerhet att använda pekare...), men det finns två sätt.

Antingen ändrar du
bool Boolean::operator&&(const Boolean& rhs)const

till
Boolean Boolean::operator&&(const Boolean& rhs)const

Och då måste du även se till att kunna konvertera en Boolean till en bool (operator bool(), alltså).

Eller så gör du två nya &&-operationer.

bool Boolean::operator&&(bool rhs) const

och

bool operator&&(const Boolean &lhs, bool rhs) const

Hej Nicklas,

Tack för att du vill kolla på detta.

OK, om jag har:
bool operator&&(const Boolean &lhs, bool rhs) const
kan jag då jämföra låt oss säga fyra eller fem objekt med varandra?
Om jag fattat detta rätt så behandlar funktionen i detta läge tre objekt (det underförstådda, lhs samt rhs).

Hur skulle det se ut om jag skickar som retur en Boolean(i stället för en bool)som i fallet:
Boolean Boolean::operator&&(const Boolean& rhs)const?
Kan du ge ett exempel på vad du menar?

/Jan

Nej, operatorn tar inte tre argument. Koden tolkas som :

(A && B) && C
(Boolean && Boolean) && Boolean

Den tar alltså bara de två första först. Problemet är att din nuvarande &&-operator returnerar en bool.
Du får alltså efter X = A && B

X && C
bool && Boolean

men bool har ingen operator && som tar en Boolean. Problemet är att du inte kan ändra bool. Du får då skriva en separat, vanlig funktion (alltså ingen medlemsfunktion), säg (skrev lite fel innan)

bool operator&&(bool lhs, const Boolean &lhs)

En annan variant är att istället låra A && B bli en Boolean, genom att helt enkelt låta den returnera av den typen.

Då får du istället i fallet ovan
X && C = D
Boolean && Boolean

D
Boolean

Och &&-operationen kommer fungera. Sen måste det ju dock omvandlas till en bool igen, och då måste du se till att göra det automatiskt; via operator bool().

Fast varför gör du så här överhuvudtaget? Allting är märkligt med Boolean-klassen.

OK, om jag fattat detta rätt så kan man alltså göra så här:


Och att initieringen sätts till:
*****************************************************
Boolean a(Boolean::TRUE); // Här sätts värdet på a till TRUE.

Boolean b(Boolean::FALSE); // Här sätts värdet på b till FALSE.

Boolean c(Boolean::FALSE); // Här sätts värdet på c till FALSE.

*****************************************************

// I klienten skriver jag detta:

if( b && c && a)
cout"Skriv INTE detta"
else
cout"Skriv ut detta !"


*****************************************************
Boolean Boolean::operator&&(const Boolean& rhs)const
{
Boolean temp;

if(*truth_value == TRUE && *rhs.truth_value == TRUE)
{
*temp.truth_value == TRUE;
return temp;
}

*temp.truth_value == FALSE;
return temp;
}
*****************************************************
Jag får följande delmeddelande utan koden ovan.

error: conditional expression of type 'Boolean' is illegal
error: 'Boolean' : no appropriate default constructor available
warning: '==' : operator has no effect; did you intend '='?
warning: '==' : operator has no effect; did you intend '='?


operator bool() är det då en funktion som omvandlar ett truth_value som är TRUE eller FALSE till en bool som är true eller false? Hur kan implementationen på den ev. se ut?

Koden ska även passa ihop med om man t.ex. skriver bool c = true.
Det är ett problem som jag gärna skulle vilja få att funka, vitsen är också att få det hela att fungera med bool också.

/Jan

Det framgår inte riktigt vilka rader som felen syftar på.
Men conditional expression-grejen verkar ju iaf syfta på A && B && C.

Det är helt ok, precis som det ska vara, ur den operationen får du ut ett objekt av typen Boolean, vilket C++ inte kan omvandla till en bool. Vad du istället behöver är just en omvandling till bool, vilket är det operator bool gör.

Implementationen blir väl något i stil med:

Boolean::operator bool()
{
return *truth_value == TRUE;
}


Det andra felet tycks vara kopplat till

Boolean temp;

Antingen får du initera den med något, eller så får du skriva en defaultkonstruktor. Sistnämnda är nog att föredra.

<b>>Koden ska även passa ihop med om man t.ex. skriver bool c = true.
Det är ett problem som jag gärna skulle vilja få att funka, vitsen är också att få det hela att fungera med bool också.</b>
Det här förstår jag inte riktigt. Det skulle underlätta om du förklarar vad poägen med allt detta är, är det någon slags skoluppgift, gör du det för att lära dig själv?

Hejsan!

Tack Niclas för supporten, jag tror att jag är en lösning på väg :-)

Mvh
/Jan

Det är en dålig idé att överlagra operator&&. Eftersom det är en function evalueras båda argumenten, inte det vänstra först, osv, som man är van vid. En bättre idé är att omvandla till bool, eller ännu bättre, för att undvika t.ex.
varde+15 = true+15 = 16
, omvandling till en innerklass-pekare.
Men varför har du egentligen en klass Boolean? bool är bättre, eftersom det är en nativ typ (behöver inte definieras osv) och fås som resultat vid t.ex. 1==2.
Den ända rätta lösningen är:
typedef bool Boolean;

Simon