Troubles bei der Umsetzung nullptr auf VS2013

Question

Ich versuche, eine offizielle Implementierung von nullptr

Ich weiß, mit nullptr und std :: nullptr_t von Compiler unterstützte diese Implementierung ist meaningless.I ist nur C zu studieren versuchen ++.

und alles funktioniert gut von GCC4.9.1 auf meinem PC, beide -std = C++ 03 und -std = C++ 11, sogar erfolgreich Online @ Ideone.com GCC4.3.2.

aber in VS2013 Linie 125 geht error2440, Konvertierung fehlgeschlagen

error C2440: "initialize": cannot convert "const <unnamed-type-my_nullptr>" to "int (__thiscall Test::*)(void) const" in line125 

>

#include <iostream> 
#include <cassert> 

// The Official proposal 
// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2431.pdf 
const // this is a const object... 
class { 
public: 
    template<class T> // convertible to any type 
    operator T*() const // of null non-member 
    { 
     return 0; 
    } // pointer... 

    template<class C, class T> // or any type of null 
    operator T C::*() const // member pointer... 
    { 
     return 0; 
    } 

private: 
    void operator&() const; // whose address can't be taken 
} my_nullptr = {}; // and whose name is nullptr 


struct Test123 { 
    int ABCD, ABC, AB; 
    int A; 
    int BA, CBA, DCBA; 
    struct XYZ { 
     char X, Y, Z, W; 
    }; 
    struct { 
     int B, C, D; 
    }; 
} test123; 


class Test { 
    int ABCD; 
public: 
    void method(void){} 

    Test(int val) :ABCD(val){} 
    int getABCD(void) const { return ABCD; } 
    int get2ABCD(void) const { return ABCD * 2; } 
    int get3ABCD(void) const { return ABCD * 3; } 
} test(0123); 


int main(int argc, char* argv[]) 
{ 

    // TEST_my_nullptr 
    { 
     int a = 321, *p = my_nullptr; 
     assert(p == my_nullptr); 
     assert(my_nullptr == p); 

     p = &a; *p = 0123; 
     assert(p != my_nullptr); 
     assert(my_nullptr != p); 

     p = my_nullptr; 

     int(*mainptr)(int argc, char** argv) = my_nullptr; 
     assert(mainptr == my_nullptr); 
     assert(my_nullptr == mainptr); 
    } 


    // TEST_my_nullptr_const 
    { 
     const int a = 321, *p = my_nullptr; 
     assert(p == my_nullptr); 
     assert(my_nullptr == p); 

     p = &a; 
     assert(p != my_nullptr); 
     assert(my_nullptr != p); 

     const int** ptr = my_nullptr; 

     assert(ptr == my_nullptr); 
     assert(my_nullptr == ptr); 

     ptr = &p; 
     assert(ptr != my_nullptr); 
     assert(my_nullptr != ptr); 
     assert(*ptr != my_nullptr); 
     assert(my_nullptr != *ptr); 

    } 


    // TEST_my_nullptr_member 
    { 
     int Test123::*pINT = my_nullptr; 
     assert(pINT == my_nullptr); 
     assert(my_nullptr == pINT); 

     pINT = &Test123::ABCD; 
     assert(pINT != my_nullptr); 
     assert(my_nullptr != pINT); 

     test123.*pINT = 0123; 

     const int Test123::*pCINT = my_nullptr; 
     assert(pCINT == my_nullptr); 
     assert(my_nullptr == pCINT); 

     pCINT = &Test123::ABCD; 
     assert(pCINT != my_nullptr); 
     assert(my_nullptr != pCINT); 

     assert(test123.*pCINT == test123.*pINT); 
    } 

    // TEST_my_nullptr_Function 
    { 
     void (Test::*pm)(void) = &Test::method; 

     pm = my_nullptr; 

     > int (Test::*pABCD)(void) const = my_nullptr; // This Fxxk Line In VS2013 

     pABCD = &Test::getABCD; 

     int a1 = (test.*pABCD)(); 

     pABCD = &Test::get2ABCD; 
     int a2 = (test.*pABCD)(); 

     pABCD = &Test::get3ABCD; 
     int a3 = (test.*pABCD)(); 

     assert(a1 + a2 == a3); 
    } 

    std::cout << "All Tests for my_nullptr Passed!" << std::endl; 
    return 0; 
} 

my Testsuit in GCC4.3.2

Answer 1

Dies ist wahrscheinlich ein Fehler in VS2013. Der Fehler scheint jedoch im C14 von VS14 behoben zu sein, wo der Code fehlerfrei kompiliert wird.

Answer 2

Dies ist leider nicht einmal falsches Verhalten. Da MS mit seinen Compilern nicht am schnellsten ist und es auch nicht auf die Interpretation der Standards ankommt, sind sie fast nie nah dran. Der MSVC2013 plain C Compiler ist eine Mischung aus c89 und c99 Klauseln mit vielen zusätzlichen Ausnahmen als nicht unterstützende Sachen, die der Standard sagt AC-Compiler HAS zu unterstützen und hat auch viele Funktionen, die der Standard besagt, dass AC-Compiler nicht erlaubt ist zu haben .

Also verlassen Sie sich nicht auf den Standard beim Kompilieren einer C oder C++ - Anwendung mit Microsoft Visual C Compiler.

(das ist wahrscheinlich, warum sie es Visual C nennen, da sie nicht einmal erlaubt werden, wäre es schlicht C zu nennen;))