[C++ VS6] Merkwaardige ambiguous operator

[Verwijderd]

OK na lang zoeken dan toch mn eerste thread op GoT

Het probleem is als volgt : Ik wil van een eigen string class het eerste karakter opvragen. Als ik dat door de compiler heen trek (Visual C++ 6 SP5) dan blijf ik de volgende melding krijgen :

h:\xlib\sources\xbase\xhugeint.cpp(30) : error C2666: '[]' : 3 overloads have similar conversions

Het stukje code waar dit in gebeurt is

C++:

XHugeInt::XHugeInt ( const XString &xstr )
{
  // Check if the number in the string is negative or positive
  if ( xstr[0] == '-' )

Dit lijkt te komen door de volgende declaraties in de XString class

C++:

  ///////////////////////////////////////////////////////////////////////////
  // Casts the XString object to a character pointer.
  ///////////////////////////////////////////////////////////////////////////
  virtual operator const char * const ( ) const;
  virtual operator const wchar_t * const ( ) const;

  ///////////////////////////////////////////////////////////////////////////
  // Returns the character at position 'pos' in the string, which is a zero
  // based index. If 'pos' is greater then the length of the string, it 
  // returns 0.
  ///////////////////////////////////////////////////////////////////////////
  virtual char operator[] ( unsigned long pos ) const;

Het lijkt wel of de compiler serieus overweegt xstr eerst naar een const char * const of een const wchar_t * const te kasten en 'm daarna pas te dereferencen i.p.v. gewoon de member functie van XString te gebruiken. Als ik de casting operators eruit gooi vind de compiler het namelijk ineens wel goed.
Alleen... ik WIL die casting operators helemaal niet kwijt.

Aangezien de MSDN niet echt behulpzaam was bij het oplossen van dit probleem heb ik eens gekeken in de source van CString. Daar zitten namelijk ook casting operators en een [] operator

C++:

// return single character at zero-based index
TCHAR operator[](int nIndex) const;
// return pointer to const string
operator LPCTSTR() const;

fyi een TCHAR is zonder #define UNICODE gewoon een char en een LPCTSTR is gewoon een const TCHAR *

Ik dacht : als ik de tweede const weghaal uit de casting operators (dus naar const char * ( ) const en const wchar_t * ( ) const ) dan werkt het mischien wel, maar nee dus...

Iemand enig idee hoe ik dit oplos? Ik dacht altijd dat resolution naar class members voorrang had boven implicit casts maar dat gaat hier dus niet op?

[.oisyn]

hmm weird, het zou imho gewoon goed moeten gaan...
post je hele class definition van XString eens

[Verwijderd]

oisyin : you asked for it

C++:

#ifndef XSTRING_INC
#define XSTRING_INC

#include "xserializable.h"

class LD_XBASE XString : virtual public XSerializable
{
public:
  /*************************************************************************/
  /* Construction/destruction                                              */
  /*************************************************************************/

  ///////////////////////////////////////////////////////////////////////////
  // Default constructor, constructs an empty XString object.
  ///////////////////////////////////////////////////////////////////////////
  XString();
  
  ///////////////////////////////////////////////////////////////////////////
  // Constructs a XString object from a character pointer. If the pointer
  // is 0, an empty XString object will be constructed.
  ///////////////////////////////////////////////////////////////////////////
  XString(const char * const sz);
  XString(const wchar_t * const wsz);

  ///////////////////////////////////////////////////////////////////////////
  // Constructs a XString object from another XString object
  ///////////////////////////////////////////////////////////////////////////
  XString(const XString &string);

  ///////////////////////////////////////////////////////////////////////////
  // Constructs a XString object from a signed 32 bit integer
  ///////////////////////////////////////////////////////////////////////////
  XString(long l);

  ///////////////////////////////////////////////////////////////////////////
  // Constructs a XString object from an unsigned 32 bit integer
  ///////////////////////////////////////////////////////////////////////////
  XString(unsigned long ul);

  ///////////////////////////////////////////////////////////////////////////
  // Constructs a XString object from a single character
  ///////////////////////////////////////////////////////////////////////////
  XString(char ch);
  XString(wchar_t wch);

  virtual ~XString();

  /*************************************************************************/
  /* Modification routines                                                 */
  /*************************************************************************/

  ///////////////////////////////////////////////////////////////////////////
  // Clears the contents of the member string, effectively making it empty.
  // Returns a reference to the current XString object.
  ///////////////////////////////////////////////////////////////////////////
  virtual XString &clear();

  ///////////////////////////////////////////////////////////////////////////
  // Replaces the contents of the member string with the string.
  // Returns a reference to the current XString object.
  ///////////////////////////////////////////////////////////////////////////
  virtual XString &operator =(const char * const sz);
  virtual XString &operator =(const wchar_t * const wsz);
  virtual XString &operator =(const XString &xsz);

  ///////////////////////////////////////////////////////////////////////////
  // Replaces the contents of the string with the character.
  // Returns a reference to the current XString object.
  ///////////////////////////////////////////////////////////////////////////
  virtual XString &operator =(char ch);
  virtual XString &operator =(wchar_t wch);

  ///////////////////////////////////////////////////////////////////////////
  // Replaces the contents of the member string with the string 
  // representation of the signed or unsigned 32 bit integer.
  // Returns a reference to the current XString object.
  ///////////////////////////////////////////////////////////////////////////
  virtual XString &operator =(long l);
  virtual XString &operator =(unsigned long ul);

  ///////////////////////////////////////////////////////////////////////////
  // Inserts a string (either from character pointer or XString object) into 
  // the member string at position 'pos', which is a zero-based index (so 0 
  // will place the string entirely string before the first character of the 
  // member string).
  // If the indicated position is greater than the length of the member 
  // string, the string is inserted behind the last character of the member 
  // string.
  // Returns a reference to the current XString object.
  ///////////////////////////////////////////////////////////////////////////
  virtual XString &insert(const char * const sz,unsigned long pos);
  virtual XString &insert(const wchar_t * const wsz,unsigned long pos);
  virtual XString &insert(const XString &xsz,unsigned long pos);

  ///////////////////////////////////////////////////////////////////////////
  // Inserts a character into the string at position 'pos'. If the position
  // is greater then the length of the string, the character is appended
  // to the string.
  // Returns a reference to the current XString object.
  ///////////////////////////////////////////////////////////////////////////
  virtual XString &insert(char ch,unsigned long pos);
  virtual XString &insert(wchar_t wch,unsigned long pos);

  ///////////////////////////////////////////////////////////////////////////
  // Inserts the string representation of a signed or unsigned 32 bit integer
  // into the string at position 'pos'. If the position is greater then the 
  // length of the string, the number is appended to the string.
  // Returns a reference to the current XString object.
  ///////////////////////////////////////////////////////////////////////////
  virtual XString &insert(long l,unsigned long pos);
  virtual XString &insert(unsigned long ul,unsigned long pos);

  ///////////////////////////////////////////////////////////////////////////
  // Concatenates the string to the member string.
  // Returns a reference to the current XString object.
  ///////////////////////////////////////////////////////////////////////////
  virtual XString &concat(const char * const sz);
  virtual XString &concat(const wchar_t * const wsz);
  virtual XString &concat(const XString &xsz);
  virtual XString &operator +=(const char * const sz);
  virtual XString &operator +=(const wchar_t * const wsz);
  virtual XString &operator +=(const XString &xsz);

  ///////////////////////////////////////////////////////////////////////////
  // Concatenates a character to the string.
  // Returns a reference to the current XString object.
  ///////////////////////////////////////////////////////////////////////////
  virtual XString &concat(char ch);
  virtual XString &concat(wchar_t wch);
  virtual XString &operator +=(char ch);
  virtual XString &operator +=(wchar_t wch);

  ///////////////////////////////////////////////////////////////////////////
  // Concatenates the string representation of the signed or unsigned 32 bit
  // integer to the string.
  // Returns a reference to the current XString object.
  ///////////////////////////////////////////////////////////////////////////
  virtual XString &concat(long l);
  virtual XString &concat(unsigned long ul);
  virtual XString &operator +=(long l);
  virtual XString &operator +=(unsigned long ul);

  ///////////////////////////////////////////////////////////////////////////
  // Removes 'len' characters from the string, starting at 
  // position 'pos' (which is a zero-based index). If 'pos' is greater then
  // the length of the string, no characters are removed. If 'len' is greater
  // then the number of remaining characters behind 'pos', then the remainder
  // of the string is removed.
  // Returns a reference to the current XString object.
  ///////////////////////////////////////////////////////////////////////////
  virtual XString &remove(unsigned long pos,unsigned long len);

  ///////////////////////////////////////////////////////////////////////////
  // If the string (either character pointer or XString object)
  // is found within the member string, it is removed from the member string. 
  // Note that all occurrences of the string are removed, not just the
  // first one.
  // Returns a reference to the current XString object.
  ///////////////////////////////////////////////////////////////////////////
  virtual XString &remove(const char * const sz);
  virtual XString &remove(const wchar_t * const sz);
  virtual XString &remove(const XString &xsz);

  ///////////////////////////////////////////////////////////////////////////
  // If the character is found within the string, it is removed from the 
  // string. Note that all occurrences of the character are removed, not just 
  // the first one.
  // Returns a reference to the current XString object.
  ///////////////////////////////////////////////////////////////////////////
  virtual XString &remove(char ch);
  virtual XString &remove(wchar_t wch);

  ///////////////////////////////////////////////////////////////////////////
  // If the string representation of the signed or unsigned 32 bit integer
  // is found within the member string, it is removed from the member string. 
  // Note that all occurrences of the number are removed, not just 
  // the first one.
  // Returns a reference to the current XString object.
  ///////////////////////////////////////////////////////////////////////////
  virtual XString &remove(long l);
  virtual XString &remove(unsigned long ul);

  ///////////////////////////////////////////////////////////////////////////
  // Replaces all occurrances of the first string within the member string
  // with the second string.
  // Returns a reference to the current XString object.
  ///////////////////////////////////////////////////////////////////////////
  virtual XString &replace(const char * const szSrc,const char * const szTgt);
  virtual XString &replace(const wchar_t * const wszSrc,const wchar_t * const wszTgt);
  virtual XString &replace(const XString &xszSrc,const XString &xszTgt);
  virtual XString &replace(const char * const sz,const XString &xsz);
  virtual XString &replace(const wchar_t * const wsz,const XString &xsz);
  virtual XString &replace(const XString &xsz,const char * const sz);
  virtual XString &replace(const XString &xsz,const wchar_t * const wsz);

  ///////////////////////////////////////////////////////////////////////////
  // For each character in the first character array, the string is parsed.
  // If that character is found in the string, it is replaced with the
  // corresponding character from the second character array.
  // Returns a reference to the current XString object.
  ///////////////////////////////////////////////////////////////////////////
  virtual XString &translate(char *szSrc,char *szTgt);
  virtual XString &translate(wchar_t *wszSrc,wchar_t *wszTgt);

  ///////////////////////////////////////////////////////////////////////////
  // Converts all characters in the string to uppercase.
  // Returns a reference to the current XString object.
  ///////////////////////////////////////////////////////////////////////////
  virtual XString &toUpper();

  ///////////////////////////////////////////////////////////////////////////
  // Converts all characters in the string to lowercase.
  // Returns a reference to the current XString object.
  ///////////////////////////////////////////////////////////////////////////
  virtual XString &toLower();

  /*************************************************************************/
  /* Substring querying routines                                           */
  /*************************************************************************/

  ///////////////////////////////////////////////////////////////////////////
  // Returns the position of the first character in the member string of 
  // the substring in that member string that matches the string entirely.
  // If the string isn't contained in the member string, the function 
  // returns -1
  ///////////////////////////////////////////////////////////////////////////
  virtual long pos(const char * const sz) const;
  virtual long pos(const wchar_t * const wsz) const;
  virtual long pos(const XString &xsz) const;

  ///////////////////////////////////////////////////////////////////////////
  // Returns the position of the first character in the string that matches 
  // the given character.
  // If the character isn't contained in the member string, the function 
  // returns -1
  ///////////////////////////////////////////////////////////////////////////
  virtual long pos(char ch) const;
  virtual long pos(wchar_t wch) const;

  ///////////////////////////////////////////////////////////////////////////
  // Returns the position of the first character in the member string of 
  // the substring in that member string that matches the string 
  // representation of the signed or unsigned 32 bit integer entirely.
  // If the number isn't contained in the member string, the function 
  // returns -1
  ///////////////////////////////////////////////////////////////////////////
  virtual long pos(long l) const;
  virtual long pos(unsigned long ul) const;

  ///////////////////////////////////////////////////////////////////////////
  // Returns the substring from the meber string starting at position 'pos'
  // and with length 'len'.
  ///////////////////////////////////////////////////////////////////////////
  virtual XString substr(unsigned long pos,unsigned long len) const;
  
  ///////////////////////////////////////////////////////////////////////////
  // Tests whether the string is found entirely in the member string.
  // i.e. "BCD" is contained in "ABCDEF", but "BDE" is not
  ///////////////////////////////////////////////////////////////////////////
  virtual bool contains(const char * const sz) const;
  virtual bool contains(const wchar_t * const wsz) const;
  virtual bool contains(const XString &xsz) const;

  ///////////////////////////////////////////////////////////////////////////
  // Tests whether the character is found in the string.
  ///////////////////////////////////////////////////////////////////////////
  virtual bool contains(char ch) const;
  virtual bool contains(wchar_t wch) const;

  ///////////////////////////////////////////////////////////////////////////
  // Tests whether the string representation of the signed or unsigned
  // 32 bit integer is found in the member string.
  ///////////////////////////////////////////////////////////////////////////
  virtual bool contains(long l) const;
  virtual bool contains(unsigned long ul) const;

  /*************************************************************************/
  /* Conversion routines                                                   */
  /*************************************************************************/
  
  ///////////////////////////////////////////////////////////////////////////
  // Returns the signed or unsigned 32 bit integer value which is represented
  // by the string. If conversion is not possible (the string does not
  // represent a number), 0 is returned.
  ///////////////////////////////////////////////////////////////////////////
  virtual long toLong() const;
  virtual unsigned long toUlong() const;

  ///////////////////////////////////////////////////////////////////////////
  // Casts the XString object to a character pointer.
  ///////////////////////////////////////////////////////////////////////////
  virtual operator const char * const() const;
  virtual operator const wchar_t * const() const;

  /*************************************************************************/
  /* Comparison routines                                                   */
  /*************************************************************************/
  
  ///////////////////////////////////////////////////////////////////////////
  // Returns true if the string is empty.
  ///////////////////////////////////////////////////////////////////////////
  virtual bool isEmpty() const;

  ///////////////////////////////////////////////////////////////////////////
  // Returns true if the string exactly matches the member string. This
  // operator is case sensitive.
  ///////////////////////////////////////////////////////////////////////////
  virtual bool operator ==(const char * const sz) const;
  virtual bool operator ==(const wchar_t * const wsz) const;
  virtual bool operator ==(const XString &xsz) const;
  friend bool operator ==(const char * const sz,const XString &xsz);
  friend bool operator ==(const wchar_t * const wsz,const XString &xsz);

  ///////////////////////////////////////////////////////////////////////////
  // Returns true if the string does not exactly match the member string. 
  // This operator is case sensitive.
  ///////////////////////////////////////////////////////////////////////////
  virtual bool operator !=(const char * const sz) const;
  virtual bool operator !=(const wchar_t * const wsz) const;
  virtual bool operator !=(const XString &xsz) const;
  friend bool operator !=(const char * const sz,const XString &xsz);
  friend bool operator !=(const wchar_t * const wsz,const XString &xsz);

  ///////////////////////////////////////////////////////////////////////////
  // Returns true if the string is alfabatically indexed before the member
  // string.
  // This operator is case sensitive.
  ///////////////////////////////////////////////////////////////////////////
  virtual bool operator >(const char * const sz) const;
  virtual bool operator >(const wchar_t * const wsz) const;
  virtual bool operator >(const XString &xsz) const;
  friend bool operator >(const char * const sz,const XString &xsz);
  friend bool operator >(const wchar_t * const wsz,const XString &xsz);
  
  ///////////////////////////////////////////////////////////////////////////
  // Returns true if the string is alfabatically indexed after the member
  // string.
  // This operator is case sensitive.
  ///////////////////////////////////////////////////////////////////////////
  virtual bool operator <(const char * const sz) const;
  virtual bool operator <(const wchar_t * const wsz) const;
  virtual bool operator <(const XString &xsz) const;
  friend bool operator <(const char * const sz,const XString &xsz);
  friend bool operator <(const wchar_t * const wsz,const XString &xsz);

  ///////////////////////////////////////////////////////////////////////////
  // Returns true if the string is alfabatically indexed before or equally
  // to the member string.
  // This operator is case sensitive.
  ///////////////////////////////////////////////////////////////////////////
  virtual bool operator >=(const char * const sz) const;
  virtual bool operator >=(const wchar_t * const wsz) const;
  virtual bool operator >=(const XString &xsz) const;
  friend bool operator >=(const char * const sz,const XString &xsz);
  friend bool operator >=(const wchar_t * const wsz,const XString &xsz);

  ///////////////////////////////////////////////////////////////////////////
  // Returns true if the string is alfabatically indexed after or equally
  // to the member string.
  // This operator is case sensitive.
  ///////////////////////////////////////////////////////////////////////////
  virtual bool operator <=(const char * const sz) const;
  virtual bool operator <=(const wchar_t * const wsz) const;
  virtual bool operator <=(const XString &xsz) const;
  friend bool operator <=(const char * const sz,const XString &xsz);
  friend bool operator <=(const wchar_t * const wsz,const XString &xsz);

  /*************************************************************************/
  /* Direct member querying                                                */
  /*************************************************************************/

  ///////////////////////////////////////////////////////////////////////////
  // Returns the number of characters in the string.
  ///////////////////////////////////////////////////////////////////////////
  virtual DWORD length() const;

  ///////////////////////////////////////////////////////////////////////////
  // Returns the character at position 'pos' in the string, which is a zero
  // based index. If 'pos' is greater then the length of the string, it 
  // returns 0.
  ///////////////////////////////////////////////////////////////////////////
  virtual char operator[](unsigned long pos) const;

  /*************************************************************************/
  /* Cloning routines                                                      */
  /*************************************************************************/

  ///////////////////////////////////////////////////////////////////////////
  // Returns a copy of the string.
  ///////////////////////////////////////////////////////////////////////////
  virtual XString clone() const;

  ///////////////////////////////////////////////////////////////////////////
  // Clones the current XString object and adds a string to the clone.
  ///////////////////////////////////////////////////////////////////////////
  virtual XString operator +(const char * const sz) const;
  virtual XString operator +(const wchar_t * const wsz) const;
  virtual XString operator +(const XString &xsz) const;
  friend XString operator +(const char * const sz,const XString &xsz);
  friend XString operator +(const wchar_t * const wsz,const XString &xsz);
  friend XString operator +(char ch,const XString &xsz);
  friend XString operator +(wchar_t wch,const XString &xsz);
  friend XString operator +(long l,const XString &xsz);
  friend XString operator +(unsigned long ul,const XString &xsz);

  /*************************************************************************/
  /* Interface requirements                                                */
  /*************************************************************************/

  ///////////////////////////////////////////////////////////////////////////
  // Functions of the serializable interface.
  // Override these if you add additional data members to your
  // derived class of XString.
  ///////////////////////////////////////////////////////////////////////////
  virtual unsigned long byteSize() const;
  virtual BYTE *serialize(BYTE *pBuf) const;
  virtual BYTE *deserialize(BYTE *pBuf);

protected:
  char * m_sz;
  mutable wchar_t * m_wsz;
  unsigned long m_ulLen;

};

#endif

[.oisyn]

hmm, hier compiled het prima met alleen die 3 methoden die je in je eerste post gaf (MSVC 7)
misschien een compiler bug?

vraagje: waarom zijn al je methoden trouwens virtual? Ga je m nog subclassen?

[Verwijderd]

Het probleem is hoogst waarschijnlijk dat je de index in de [] operator niet als een int maar als een unsigned int definieert. Daardoor moet de compiler de int index eerst naar unsigned casten en heeft de [] operator geen precedence meer over de cast operators. (Overigens vraag ik me af waarom je operators als virtual definieert).

C++:

char operator[] ( int pos ) const;

Dit zou moeten werken volgens mij.

[Verwijderd]

OK ten eerste wil ik jullie bedanken voor de gedane moeite.

Oisyn : kan compilerafhankelijk zijn, mischien zelfs wel een bug maar ik ben verder zeer tevreden over MSVS6 en heb momenteel geen mogelijkheid om aan MSVS7 te komen.

Mietje : je hebt gelijk. De volgende code

C++:

if ( xstr[ ( unsigned long ) 0] == '-' ) { }

doet het namelijk wel. Dan kies ik daarvoor en niet voor jouw oplossing om er dan maar een int van te maken, en wel omdat het hier om een zero-based-index gaat. Door het unsigned te laten hoef ik niet te checken of de gevraagde index >= 0. Overigens is dat natuurlijk gewoon een keuze maar ik vind het functioneel correcter, een negatieve index is nou eenmaal onzin in deze context

edit:
even ietsjes meer uitleg

De reden dat ik de meeste zaken virtual gedeclareerd heb is inderdaad omdat ik van plan ben hem nog te subclassen. Er is bovendien ook geen noodzaak ze niet virtual te declareren, dus waarom zou ik dat dan doen? Dat maakt het voor eventuele anderen die hiervan willen subclassen alleen maar onnodig moeilijk. Of zie ik dat verkeerd?

edit:
toch niet handig

Ik denk dat ik op den duur erg moe ga worden van al dat casten naar unsigned long dus dan de int versie er maar gewoon bijgeplakt

[cameodski]

Verwijderd schreef op 03 oktober 2002 @ 17:42:
De reden dat ik de meeste zaken virtual gedeclareerd heb is inderdaad omdat ik van plan ben hem nog te subclassen. Er is bovendien ook geen noodzaak ze niet virtual te declareren, dus waarom zou ik dat dan doen? Dat maakt het voor eventuele anderen die hiervan willen subclassen alleen maar onnodig moeilijk. Of zie ik dat verkeerd?

Ik ga niet zeggen dat je het verkeerd ziet, maar helemaal goed zie je het in ieder geval niet.
Methodes/operator die virtual zijn, zijn minder efficient, omdat er regelmatig gecontroleerd moet worden of er nog overrides zijn van betreffende methode/operator. Dus het is toch beter/netter om niet onnodig virtual te gebruiken.

[.oisyn]

Verwijderd schreef op 03 oktober 2002 @ 17:42:
OK ten eerste wil ik jullie bedanken voor de gedane moeite.

Oisyn : kan compilerafhankelijk zijn, mischien zelfs wel een bug maar ik ben verder zeer tevreden over MSVS6 en heb momenteel geen mogelijkheid om aan MSVS7 te komen.

Mietje : je hebt gelijk. De volgende code

C++:

if ( xstr[ ( unsigned long ) 0] == '-' ) { }

doet het namelijk wel.

hmm in mijn test deed ik idd gewoon int, ik dacht er nog aan maar het leek me onwaarschijnlijk. Nog steeds overigens. Je roept namelijk de [] operator op XString aan, dus op dat moment zou de compiler al voor de geoverloadde [] operator moeten kiezen. Dan geef jij een 0 mee, wat eigenlijk een const int is, maar zonder problemen kan worden gecast naar unsigned long. Dat levert een char op, wat ie vervolgens vergelijkt.

Volgens mietje zou ie eerst naar de vergelijking kijken om daar te zien dat het een char is, en dus operator char * aanroept, en dan de pointer dereferenced dmv array indexing. Maar dat is helemaal niet de juiste volgorde

Ik heb het nog een keer getest in MSVC7, deze keer met een unsigned long als index, en daar krijg ik idd precies dezelfde error
g++ (2.7.2.1) compiled het echter prima

cameodski schreef op 03 oktober 2002 @ 19:25:
Methodes/operator die virtual zijn, zijn minder efficient, omdat er regelmatig gecontroleerd moet worden of er nog overrides zijn van betreffende methode/operator. Dus het is toch beter/netter om niet onnodig virtual te gebruiken.

er wordt niet 'gecontroleerd', de reden dat het inefficient is, is omdat ie de functie aanroept dmv een pointer (de instantie) naar een pointer (de vtable van die instantie) naar een pointer (de functie in de vtable). Ook kan de cpu geen branch prediction uitvoeren omdat ie niet van tevoren weet waar ie naartoe moet

[Verwijderd]

.oisyn schreef op 03 oktober 2002 @ 19:51:
hmm in mijn test deed ik idd gewoon int, ik dacht er nog aan maar het leek me onwaarschijnlijk. Nog steeds overigens. Je roept namelijk de [] operator op XString aan, dus op dat moment zou de compiler al voor de geoverloadde [] operator moeten kiezen.

Dit klopt niet. De compiler moet nu kiezen uit óf een [] operator, óf een cast operator naar een pointer. De compiler zal de "best fit" kiezen, dus in wezen de operator die de minste casts kost. Normalerwijze is dat de [] operator, omdat er dan 0 casts nodig zijn. Nu moet de compiler echter eerst van int naar unsigned casten, en dan worden alledrie de operatoren "even goed" en dus ambigue.

Ik heb het nog een keer getest in MSVC7, deze keer met een unsigned long als index, en daar krijg ik idd precies dezelfde error
g++ (2.7.2.1) compiled het echter prima

g++ 2.95.2 en 3.0.1 geven beiden ook de error. Ik weet echt bijna zeker dat ik hierin goed zit, dit is me zelf ook wel eens overkomen.

[.oisyn]

hmmm, vervelend dan

[Verwijderd]

toch altijd weer interessant die discussies
Eigenlijk is het jammer dat je casting operators niet 'explicit' kan maken, zoals je wel met constructors kan...
En als performance de enige reden is om voor niet-virtual methods te kiezen in dit geval : mwah, kan ik mee leven. Voor echte high-performance string operaties gebruik ik wel gewoon een char pointer als het ECHT nodig is... Hier maakt het weinig uit, ik ga er geen parsers mee bouwen o.i.d.

[Verwijderd]

Verwijderd schreef op 03 oktober 2002 @ 17:42:

C++:

if ( xstr[ ( unsigned long ) 0] == '-' ) { }

edit:
toch niet handig

Ik denk dat ik op den duur erg moe ga worden van al dat casten naar unsigned long

Als je denkt dat je erg moe gaat worden van al het typen, kan je toch ook deze veel kortere vorm gebruiken:

C++:

if ( xstr[0UL] == '-' ) { }

Komt op het zelfde neer, maar is toch een boel minder typewerk!