Troubles in attuazione nullptr su VS2013

Question

cerco un'implementazione ufficiale di nullptr

so che con nullptr e std :: nullptr_t supportato da compilatori, questa implementazione è meaningless.I sto solo cercando di studiare C++.

e tutto funziona correttamente con GCC4.9.1 sul mio PC, sia -std = C++ 03 e -std = C++ 11, anche con successo online @ ideone.com GCC4.3.2.

ma in linea di VS2013 125 va error2440, conversione non è riuscita

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

Questo è probabilmente un bug in VS2013. Il bug sembra essere stato risolto nel CTP VS14, tuttavia, dove il codice viene compilato senza errori.

Answer 2

Purtroppo non si sta nemmeno comportando male. Dato che MS è con i suoi compilatori non è il più veloce e non è nemmeno sull'interpretazione degli standard, non sono quasi mai vicini ad esso.

cioè la pianura compilatore MSVC2013 C è una miscela di clausole C89 e C99 con molte eccezioni supplementari non sostenere roba lo standard dice ac compilatore deve sostenere e ha anche molte caratteristiche che lo standard dice ac compilatore non è consentito di avere .

Quindi non fare affidamento sullo standard quando si compila un'applicazione c o C++ con il compilatore Microsoft Visual C.

(questo è probabilmente il motivo per cui lo chiamano Visual C, in quanto non sarebbe nemmeno essere autorizzati a chiamarlo pianura C;))