int l = 10;
WideString w = WideString("");
if (w == NULL)
  l = w.Length();

Gruß

Gegenfrage : Was sollte deiner Meinung nach denn sonst rauskommen? In w ist nun mal kein Zeichen, also ist die Länge des Strings gleich 0.

/Edit : Achso, es geht dir um die Bedingung. NULL wird dazu impliziet in einen WideString konvertiert, indem der Konstruktor für char* aufgerufen wird. Und damit wird ein leerer WideString mit einem leerem WideString verglichen.

bis bald
akaei

ps: du hast dich bei deinem Namen vertippt

edit:

struct Foo
{
    Foo() { std::cout << "Foo::Foo();\n"; }
    Foo(const char* p) { std::cout << "Foo::Foo(const char*);\n"; }
    operator const char*() { std::cout << "Foo:: operator const char*();\n"; return NULL;}
};

int main(int argc, char* argv[])
{
        Foo bar;
        if(bar == NULL) {
            std::cout << "bar == NULL";
        }
}

Gibt mir das Recht? :p

Gruß

noch mehr dazu:

WideString w1 = WideString("");
WIdeString w2 = L"";

und jetzt kommt: w1 ungleich(!) w2.

aber w1.Length() == w2.Length();

Warum nicht meine Methode? - Warum konvertiert der Compiler NULL in einen WideString und nicht den WideString in einen Pointer?

weil der WideString keinen Funktionsoperator hat der nen Zeiger zurückliefert (wozu auch), ausserdem hat WideString nen Vergleichsoperator == ueber den der Vergleich erfolgt und dieser erwartet (völlig unerwartet) nen WideString als Argument!

keine ahnung was du so verzapfst, aber bei mir sind w1 und w2 gleich!

es kommt rauf an, wie du deine anweisung im quellcode hast!

hier ein kleiner test:

WideString w1;                   // Data:NULL
    w1 = L"";                        // Data:""
    int l1 = w1.Length();            // l1 = 0

    WideString w2 = L"";             // Data:NULL
    int l2 = w2.Length();            // l2 = 0

    WideString w3 = L"TEST";         // Data:TEST
    w3 = L"";                        // Data:""
    int l3 = w3.Length();            // l3 = 42

    WideString w4 = WideString("");  // Data: NULL
    int l4 = w4.Length();            // l4 = 0

    WideString w5;                   // Data:NULL
    w5 = WideString("");             // Data:NULL
    int l5 = w5.Length();            // l5 = 0

    WideString w6 = WideString("TEST");  // Data:TEST
    w6 = WideString("");                 // Data:NULL
    int l6 = w6.Length();                // l6 = 0

je nach dem, wie mann das im quellcode eingibt, kommen vollig unterschiedliche ergebnisse.

bei test 3 ist der aller schlimster

ich vermutte mal, dass wenn ich im editor die Schriftart ändere, bekomme ich wieder mal andere Ergebnisse

FireFlow schrieb:

Warum nicht meine Methode? - Warum konvertiert der Compiler NULL in einen WideString und nicht den WideString in einen Pointer?

weil der WideString keinen Funktionsoperator hat der nen Zeiger zurückliefert (wozu auch), ausserdem hat WideString nen Vergleichsoperator == ueber den der Vergleich erfolgt und dieser erwartet (völlig unerwartet) nen WideString als Argument!

Achja?

// wstring.h
namespace System
{

  class RTL_DELPHIRETURN WideString
  {
     /* [...] */
  public:
     operator BSTR() const          { return Data; }
     /* [...] */
  };

}

// in irgendwelchen anderen Headern
typedef /* [wire_marshal] */ OLECHAR *BSTR;
typedef WCHAR OLECHAR; 
typedef wchar_t WCHAR;

Deinen Vergleichsoperator finde ich jedoch gerade nirgends

Gruß