是野指针。
你只是生命了一个指针，却没有给它分配内存空间。
C/C++ code

int  main( )
{
    A *a = new A();
    a->prinfs();
    delete a;
return 0;
}

够野！ 

为啥能运行？因为没有读写被指向的地方。

引用 4 楼  的回复:

够野！

为啥能运行？因为没有读写被指向的地方。

“因为没有读写被指向的地方”  是什么意思阿？

你的类没有成员变量，其实就是个接口。
引用 6 楼  的回复:

引用 4 楼  的回复:

够野！

为啥能运行？因为没有读写被指向的地方。

“因为没有读写被指向的地方”  是什么意思阿？

在你的类中加个成员变量，然后在你的prinfs函数中访问该变量试试~

主要是你A * a;
a->prints();
会被理解为A::prints(this=a);
然后在你的prints里面其实没有对this进行操作，所以是可以打印的。

如A * a = 0;
a->prints();
应该也可以运行。

引用 10 楼 的回复:

在你的类中加个成员变量，然后在你的prinfs函数中访问该变量试试~

没有问题。

C/C++ code

#include<iostream>
#include<cstring>

using namespace std;

class A
{
int mVar;
public:
void prinfs()
{
        ……

因为函数的偏移地址在类被编译时就已经确定了, 所以,如果成员函数没有访问任何成员的话, 也就不会有问题了. 

哪怕是等于NULL, 也是可以访问这种成员函数的.

这也可以作为特殊用途. 比如说你写了某个类,其中有个成员函数只用到函数参数,并没有访问任何成员, 这时为在其它地方不生成对象的情况下用一下这个函数, 就可以定义一个NULL指针,使用这个函数了.

因为函数的偏移地址在类被编译时就已经确定了, 所以,如果成员函数没有访问任何成员的话, 也就不会有问题了. 

哪怕是等于NULL, 也是可以访问这种成员函数的.

这也可以作为特殊用途. 比如说你写了某个类,其中有个成员函数只用到函数参数,并没有访问任何成员, 这时为在其它地方不生成对象的情况下用一下这个函数, 就可以定义一个NULL指针,使用这个函数了.

这个大哥，可以把下面的详细解释下不？
引用 8 楼  的回复:

主要是你A * a;
a->prints();
会被理解为A::prints(this=a);
然后在你的prints里面其实没有对this进行操作，所以是可以打印的。
 



引用 8 楼  的回复:
如A * a = 0;
a->prints();
应该也可以运行。
 这样子的话直接段错误了。
……

是野指针。
你只是生命了一个指针，却没有给它分配内存空间。
C/C++ code

int  main( )
{
    A *a = new A();
    a->prinfs();
    delete a;
return 0;
}

要从本质上理解这个问题，就必须知道编译器在中间究竟做了些什么小动作。

需要知道的是，计算机本身并不认识所谓的面向对象，对它来说，一切都是过程式的。这意味着，即使我们写出了你这样的面向对象代码，编译器最终也会将它们“过程化”。而如何“过程化”就是关键了。

关键点：所有的方法最终都是全局函数。

这就是说，类A会被翻译成一个“空”结构体：
struct A{};

以及一些全局函……

引用 27 楼  的回复:
要从本质上理解这个问题，就必须知道编译器在中间究竟做了些什么小动作。

需要知道的是，计算机本身并不认识所谓的面向对象，对它来说，一切都是过程式的。这意味着，即使我们写出了你这样的面向对象代码，编译器最终也会将它们“过程化”。而如何“过程化”就是关键了。

关键点：所有的方法最终都是全局函数。

这就是说，类A会被翻译成一个“空”结构体：
struct……

首先,你要理解 什么叫 "未定义行为"

你写的代码有未定义行为 .

你所期待的"不能执行" 是一种明确的行为 . 

你写出这样的代码又去期待一个明确的行为是错的!

引用 34 楼  的回复:

首先,你要理解 什么叫 "未定义行为"

你写的代码有未定义行为 .

你所期待的"不能执行" 是一种明确的行为 .

你写出这样的代码又去期待一个明确的行为是错的!

LZ的这段代码有明确的行为。
其次变量在使用之前必须要初始化，也是胡扯。
再次，有时候野指针或空指针是必要的，如gcc的offsetof等！

朋友java学多了吧 new后面加啥小括号啊引用 2 楼  的回复:

是野指针。
你只是生命了一个指针，却没有给它分配内存空间。
C/C++ code

int  main( )
{
A *a = new A();
a->prinfs();
delete a;
return 0;
}

所谓未定义行为，是针对标准而言，不是针对你个人的理解，也不是针对楼内许多个个人的理解

C++标准2003（2011标准也一样） $5.2.5/3
If E1 has the type “pointer to class X,” then the expression E1->E2 is converted to the equivalent form (*(E1)).E2; 
意思是 a->prinfs(); 其实是要转换为 (*a).printfs();

$5.2.5/1
The postfix expression before the dot or arrow is evaluated;
意思是 (*a) 要先被求值

按标准的要求，a->prinfs(); 要排除未定义行为的话，则需要 a 是个能被合理解引用的指针

但是标准是标准，编译器厂商是编译器厂商，后者可以不严格按前者来，以致很多未定义行为在具体的编译器上没有发生问题

倘若在void prinfs()之前加个virtual，问题立即就出来了，因为大多数编译器这个时候不得不去找虚表

你可以根据多数编译器的做法，总结出一条经验：只要不需要这个指针去定位，那么((A*)0)->printfs();完全是可以的

但是，记住！这是经验，不是标准。

显然楼主的代码没有virtual，所以说是明确定义的行为！

要从本质上理解这个问题，就必须知道编译器在中间究竟做了些什么小动作。

需要知道的是，计算机本身并不认识所谓的面向对象，对它来说，一切都是过程式的。这意味着，即使我们写出了你这样的面向对象代码，编译器最终也会将它们“过程化”。而如何“过程化”就是关键了。

关键点：所有的方法最终都是全局函数。

这就是说，类A会被翻译成一个“空”结构体：
struct A{};

以及一些全局……

要从本质上理解这个问题，就必须知道编译器在中间究竟做了些什么小动作。

需要知道的是，计算机本身并不认识所谓的面向对象，对它来说，一切都是过程式的。这意味着，即使我们写出了你这样的面向对象代码，编译器最终也会将它们“过程化”。而如何“过程化”就是关键了。

关键点：所有的方法最终都是全局函数。

这就是说，类A会被翻译成一个“空”结构体：
struct A{};

以及一些全局……

要从本质上理解这个问题，就必须知道编译器在中间究竟做了些什么小动作。

需要知道的是，计算机本身并不认识所谓的面向对象，对它来说，一切都是过程式的。这意味着，即使我们写出了你这样的面向对象代码，编译器最终也会将它们“过程化”。而如何“过程化”就是关键了。

关键点：所有的方法最终都是全局函数。

这就是说，类A会被翻译成一个“空”结构体：
struct A{};

以及一些全局……