C++ 在VS2013上实现nullptr时遇到的问题

我尝试了nullptr的正式实现

我知道用Null pTR和STD:：编译器支持的Null pTrpt，这个实现是没有意义的。我只是想研究C++。 通过GCC4.9.1在我的电脑上运行良好，无论是-std=c++03还是-std=c++11，甚至在线@ideone.com GCC4.3.2都很成功

但在VS2013第125行和第2440行中，转换失败

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

错误C2440：“初始化”：无法将第125行中的“const”转换为“int（\uu thiscall Test:：*）（void）const”

>

#包括
#包括
//官方提案
// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2431.pdf
常量//这是一个常量对象。。。
阶级{
公众：
模板//可转换为任何类型
空非成员的运算符T*（）const//
{
返回0；
}//指针。。。
模板//或任何类型的null
运算符tc:：*（）常量//成员指针。。。
{
返回0；
}
私人：
void运算符（&（）const；//无法获取其地址
}my_nullptr={}；//谁的名字是nullptr
结构测试123{
int ABCD，ABC，AB；
INTA；
国际文学士、CBA、DCBA；
结构XYZ{
字符X，Y，Z，W；
};
结构{
int B，C，D；
};
}test123；
课堂测试{
int ABCD；
公众：
void方法（void）{}
测试（int-val）：ABCD（val）{}
int getABCD（void）常量{return ABCD；}
int get2ABCD（void）常量{return ABCD*2；}
int get3ABCD（void）常量{return ABCD*3；}
}试验（0123）；
int main（int argc，char*argv[]）
{
//测试我的空PTR
{
int a=321，*p=my_nullptr；
断言（p==my_nullptr）；
断言（my_nullptr==p）；
p=&a；*p=0123；
断言（p！=my_nullptr）；
断言（my_nullptr！=p）；
p=我的_nullptr；
int（*mainptr）（int argc，char**argv）=my_nullptr；
断言（mainptr==my_nullptr）；
断言（my_nullptr==mainptr）；
}
//测试我的空ptr常数
{
常数int a=321，*p=my_nullptr；
断言（p==my_nullptr）；
断言（my_nullptr==p）；
p=&a；
断言（p！=my_nullptr）；
断言（my_nullptr！=p）；
const int**ptr=my_nullptr；
断言（ptr==my_nullptr）；
断言（my_nullptr==ptr）；
ptr=&p；
断言（ptr！=my_nullptr）；
断言（my_nullptr！=ptr）；
断言（*ptr！=my_nullptr）；
断言（my_nullptr！=*ptr）；
}
//TEST_my_nullptr_成员
{
int Test123:：*pINT=my_nullptr；
断言（pINT==my_nullptr）；
断言（my_nullptr==pINT）；
品脱=&Test123:：ABCD；
断言（品脱！=my_nullptr）；
断言（my_nullptr！=pINT）；
test123.*品脱=0123；
常量int Test123:：*pCINT=my_nullptr；
断言（pCINT==my_nullptr）；
断言（my_nullptr==pCINT）；
pCINT=&Test123:：ABCD；
断言（pCINT！=my_nullptr）；
断言（my_nullptr！=pCINT）；
断言（test123.*pCINT==test123.*pINT）；
}
//TEST_my_nullptr_函数
{
无效（测试：：*pm）（无效）=测试：：方法；
pm=我的_nullptr；
>int（Test:：*pABCD）（void）const=my_nullptr；//VS2013中的此Fxxk行
pABCD=&Test:：getABCD；
inta1=（test.*pABCD）（）；
pABCD=&Test:：get2ABCD；
int a2=（测试。*pABCD）（）；
pABCD=&Test:：get3ABCD；
int a3=（测试。*pABCD）（）；
断言（a1+a2==a3）；
}
std:：cout这可能是VS2013中的一个错误。但是，该错误似乎已在VS14 CTP中修复，您的代码编译时没有错误。
遗憾的是，这甚至不是错误的行为。
由于微软的编译器不是最快的，也不是对标准的解释，所以他们几乎从来没有接近过它

i、 e.MSVC2013纯C编译器是c89和c99子句的混合体，有许多额外的例外情况，因为它们不支持标准中所说的C编译器必须支持的内容，并且还有许多标准中所说的C编译器不允许具有的功能

因此，在编译微软C++ Visual C编译器时，不要依赖于标准。
（这可能就是为什么他们称之为Visual C，因为他们甚至不允许称之为普通C；）
明确显示错误出现的行并显示完整的错误消息。您的代码中有一个匿名结构。看起来是
pABCD
变量的
const
上的MS错误。是否可以在上提交错误报告？
#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;
}