编译器空指针
⑴ 空指针错误是什么意思
所谓的空指针异常，就是一个指针是空指针，你还要去操作它，既然它指向的是空对象，它就不能使用这个对象的方法。比如上面的s假如为null,你还要用s的方法，比如s.equals( String x);那么就会产生空指针异常。
产生空指针异常的原因：
(1) 当一个对象不存在时又调用其方法会产生异常 obj.method() // obj对象不存在
(2) 当访问或修改一个对象不存在的字段时会产生异常 obj.method() // method方法不存在
(1)编译器空指针扩展阅读：
空指针正常工作意义:
在许多语言，这不是一个单独的转义序列，而是八进制转义序列，单个八进制数字为0；因此，‘ ’不能跟随任何数字0通过7;否则它被解释为更长的八进制转义序列的开始。被在使用中发现各种语言的其他转义序列 00，x00，z，或的Unicode表示u0000。
表示空字符的能力并不总是意味着生成的字符串将被正确解释，因为许多程序将认为null作为字符串的结尾。因此，键入它的能力（在未经检查的用户输入的情况下）会创建一个称为空字节注入的漏洞，并可能导致安全漏洞。
空字符以逗号表示是^@。在Windows上，可以通过按住Ctrl键，然后按@（这通常需要同时按下⇧ Shift并按下数字2键）。
参考资料：网络——空指针
⑵ 怎样在程序里获得一个空指针
根据语言定义， 在指针上下文中的常数 0 会在编译时转换为空指针。也就是
说， 在初始化、赋值或比较的时候， 如果一边是指针类型的值或表达式， 编译器可
以确定另一边的常数 0 为空指针并生成正确的空指针值。因此下边的代码段完全
合法：
char *p = 0;
if(p != 0)
然而， 传入函数的参数不一定被当作指针环境， 因而编译器可能不能识别未加修饰的 0 “表示” 指针。在函数调用的上下文中生成空指针需要明确的类型转换，强制把 0 看作指针。例如， Unix 系统调用 execl 接受变长的以空指针结束的字符指针参数。它应该如下正确调用：
execl("/bin/sh"， "sh"， "-c"， "date"， (char *)0);
如果省略最后一个参数的 (char *) 转换， 则编译器无从知道这是一个空指针，从而当作一个 0 传入。
如果范围内有函数原型， 则参数传递变为 “赋值上下文”， 从而可以安全省略多数类型转换， 因为原型告知编译器需要指针， 使之把未加修饰的 0 正确转换为适当的指针。函数原型不能为变长参数列表中的可变参数提供类型。在函数调用时对所有的空指针进行类型转换可能是预防可变参数和无原型函数出问题的最安全的办法。
⑶ c语言为什么在本地空指针用的了，到了网教编译器却提示空指针没有定义，把NULL改成‘\0’就可以了
NULL需要包含stdio.h
如果你没有包含stdio.h 那么使用NULL会报错.
另外,根据你的描述, 改成\0即可. 而\0 是char型.NULL是void *型.
所以很可能是你赋值类型错误,将NULL赋值给了char变量, 本地编译忽略了类型转换.
网教的更加严格,不允许指针赋值给字符型.
⑷ C语言为什么在本地空指针用的了，到了网教编译器却提示空指针没有定义,把NULL改成‘\0’就可以了
怎么说呢，这个是我个人见解，如有不对请各位指点
对于指针在本地使用，操作系统要干很多事情，对于程序来说虚拟内存是关系最密切的，因此，每一个变量都是有意义，有根可寻的。当不进行指针初始化的话，很可能是一个野指针，操纵系统不会答应的。而网络编程发送的是数据流，他是写到buff里面的。你没有必要写一个0X0000 0000，毕竟写一个'\0'对面可以解析出来这个数据内容为0X0000 0000，这样不但省空间，而且表达的意思没有二义性，你觉得选择那个更好呢？
⑸ java中的空指针异常怎么解决
原文：https://www.hu.com/question
你这个问题的解决
问题定位：
在堆栈异常信息的第一行就可以定位到是哪里出了空指针，倘若这里不是你写的类，可以往下翻一下，找到你写的类，就是这里出现的空指针。
问题解决：
对一个空对象调用里面的方法或者属性的时候会报空指针，检查这个对象为什么是空即可。
Java 空指针异常的若干解决方案
Java 中任何对象都有可能为空，当我们调用空对象的方法时就会抛出 NullPointerException 空指针异常，这是一种非常常见的错误类型。我们可以使用若干种方法来避免产生这类异常，使得我们的代码更为健壮。本文将列举这些解决方案，包括传统的空值检测、编程规范、以及使用现代 Java 语言引入的各类工具来作为辅助。
运行时检测
最显而易见的方法就是使用 if (obj == null) 来对所有需要用到的对象来进行检测，包括函数参数、返回值、以及类实例的成员变量。当你检测到 null 值时，可以选择抛出更具针对性的异常类型，如 IllegalArgumentException，并添加消息内容。我们可以使用一些库函数来简化代码，如 Java 7 开始提供的 Objects#requireNonNull 方法：
public void testObjects(Object arg) {
Object checked = Objects.requireNonNull(arg, "arg must not be null");
checked.toString();}
Guava 的 Preconditions 类中也提供了一系列用于检测参数合法性的工具函数，其中就包含空值检测：
public void testGuava(Object arg) {
Object checked = Preconditions.checkNotNull(arg, "%s must not be null", "arg");
checked.toString();
}
我们还可以使用 Lombok 来生成空值检测代码，并抛出带有提示信息的空指针异常：
public void testLombok(@NonNull Object arg) {
arg.toString();
生成的代码如下：
public void testLombokGenerated(Object arg) {
if (arg == null) {
throw new NullPointerException("arg is marked @NonNull but is null");
}
arg.toString();
}
这个注解还可以用在类实例的成员变量上，所有的赋值操作会自动进行空值检测。
编程规范
·通过遵守某些编程规范，也可以从一定程度上减少空指针异常的发生。
使用那些已经对 null 值做过判断的方法，如 String#equals、String#valueOf、以及三方库中用来判断字符串和集合是否为空的函数：
if (str != null && str.equals("text")) {}
if ("text".equals(str)) {}
if (obj != null) { obj.toString(); }
String.valueOf(obj); // "null"
// from spring-core
StringUtils.isEmpty(str);
CollectionUtils.isEmpty(col);
// from guava
Strings.isNullOrEmpty(str);
// from commons-collections4
CollectionUtils.isEmpty(col);
·如果函数的某个参数可以接收 null 值，考虑改写成两个函数，使用不同的函数签名，这样就可以强制要求每个参数都不为空了：
public void methodA(Object arg1) {
methodB(arg1, new Object[0]);
}
public void methodB(Object arg1, Object[] arg2) {
for (Object obj : arg2) {} // no null check
}
·如果函数的返回值是集合类型，当结果为空时，不要返回 null 值，而是返回一个空的集合；如果返回值类型是对象，则可以选择抛出异常。Spring JdbcTemplate 正是使用了这种处理方式：
// 当查询结果为空时，返回 new ArrayList<>()
jdbcTemplate.queryForList("SELECT * FROM person");
// 若找不到该条记录，则抛出
jdbcTemplate.queryForObject("SELECT age FROM person WHERE id = 1", Integer.class);
// 支持泛型集合
public <T> List<T> testReturnCollection() {
return Collections.emptyList();
}
静态代码分析
Java 语言有许多静态代码分析工具，如 Eclipse IDE、SpotBugs、Checker Framework 等，它们可以帮助程序员检测出编译期的错误。结合 @Nullable 和 @Nonnull 等注解，我们就可以在程序运行之前发现可能抛出空指针异常的代码。
但是，空值检测注解还没有得到标准化。虽然 2006 年 9 月社区提出了 JSR 305 规范，但它长期处于搁置状态。很多第三方库提供了类似的注解，且得到了不同工具的支持，其中使用较多的有：
javax.annotation.Nonnull：由 JSR 305 提出，其参考实现为 com.google.code.findbugs.jsr305；
org.eclipse.jdt.annotation.NonNull：Eclipse IDE 原生支持的空值检测注解；
e.umd.cs.findbugs.annotations.NonNull：SpotBugs 使用的注解，基于 findbugs.jsr305；
org.springframework.lang.NonNull：Spring Framework 5.0 开始提供；
org.checkerframework.checker.nullness.qual.NonNull：Checker Framework 使用；
android.support.annotation.NonNull：集成在安卓开发工具中；
- <dependency>
- <groupId>com.github.spotbugs</groupId>
- <artifactId>spotbugs-annotations</artifactId>
- <version>3.1.7</version>
- </dependency>
- @NonNull
- private Object returnNonNull() {
- // 错误：returnNonNull() 可能返回空值，但其已声明为 @Nonnull
- return null;
- }
- @CheckForNull
- private Object returnNullable() {
- return null;
- }
- public void testReturnNullable() {
- Object obj = returnNullable();
- // 错误：方法的返回值可能为空
- System.out.println(obj.toString());
- }
- private void argumentNonNull(@NonNull Object arg) {
- System.out.println(arg.toString());
- }
- public void testArgumentNonNull() {
- // 错误：不能将 null 传递给非空参数
- argumentNonNull(null);
- }
- public void testNullableArgument(@CheckForNull Object arg) {
- // 错误：参数可能为空
- System.out.println(arg.toString());
- }
- import org.checkerframework.checker.nullness.qual.Nullable;
- @Nullable
- private Object returnNullable() {
- return null;
- }
- public void testReturnNullable() {
- Object obj = returnNullable();
- // 错误：obj 可能为空
- System.out.println(obj.toString());
- }
- private Object returnNonNull() {
- // 错误：方法声明为 @NonNull，但返回的是 null。
- return null;
- }
- private void argumentNonNull(Object arg) {
- System.out.println(arg.toString());
- }
- public void testArgumentNonNull() {
- // 错误：参数声明为 @NonNull，但传入的是 null。
- argumentNonNull(null);
- }
- // 这是 spring-core 中定义的类和方法
- public abstract class StringUtils {
- // str 参数继承了全局的 @NonNull 注解
- public static String capitalize(String str) {}
- @Nullable
- public static String getFilename(@Nullable String path) {}
- }
- // 错误：参数声明为 @NonNull，但传入的是 null。
- StringUtils.capitalize(null);
- String filename = StringUtils.getFilename("/path/to/file");
- // 错误：filename 可能为空。
- System.out.println(filename.length());
- Optional<String> opt;
- // 创建
- opt = Optional.empty();
- opt = Optional.of("text");
- opt = Optional.ofNullable(null);
- // 判断并读取
- if (opt.isPresent()) {
- opt.get();
- }
- // 默认值
- opt.orElse("default");
- opt.orElseGet(() -> "default");
- opt.orElseThrow(() -> new NullPointerException());
- // 相关操作
- opt.ifPresent(value -> {
- System.out.println(value);
- });
- opt.filter(value -> value.length() > 5);
- opt.map(value -> value.trim());
- opt.flatMap(value -> {
- String trimmed = value.trim();
- return trimmed.isEmpty() ? Optional.empty() : Optional.of(trimmed);
- });
- String zipCode = getUser()
- .flatMap(User::getAddress)
- .flatMap(Address::getZipCode)
- .orElse("");
- stringList.stream().findFirst().orElse("default");
- stringList.stream()
- .max(Comparator.naturalOrder())
- .ifPresent(System.out::println);
- val opt: Option[String] = Some("text")
- opt.getOrElse("default")
- opt match {
- case Some(text) => println(text)
- case None => println("default")
- opt.map(_.trim).filter(_.length > 0).map(_.toUpperCase).getOrElse("DEFAULT")
- val upper = for {
- text <- opt
- trimmed <- Some(text.trim())
- upper <- Some(trimmed) if trimmed.length > 0
- } yield upper
- upper.getOrElse("DEFAULT")
- var a: String = "text"
- a = null // 错误：无法将 null 赋值给非空 String 类型。
- val b: String? = "text"
- // 错误：操作可空类型时必须使用安全操作符（?.）或强制忽略（!!.）。
- println(b.length)
- val l: Int? = b?.length // 安全操作
- b!!.length // 强制忽略，可能引发空值异常
我建议使用一种跨 IDE 的解决方案，如 SpotBugs 或 Checker Framework，它们都能和 Maven 结合得很好。
SpotBugs 与 @NonNull、@CheckForNull
SpotBugs 是 FindBugs 的后继者。通过在方法的参数和返回值上添加 @NonNull 和 @CheckForNull 注解，SpotBugs 可以帮助我们进行编译期的空值检测。需要注意的是，SpotBugs 不支持 @Nullable 注解，必须用 @CheckForNull 代替。如官方文档中所说，仅当需要覆盖 @ParametersAreNonnullByDefault 时才会用到 @Nullable。
官方文档 中说明了如何将 SpotBugs 应用到 Maven 和 Eclipse 中去。我们还需要将 spotbugs-annotations 加入到项目依赖中，以便使用对应的注解。
以下是对不同使用场景的说明：
对于 Eclipse 用户，还可以使用 IDE 内置的空值检测工具，只需将默认的注解 org.eclipse.jdt.annotation.Nullable 替换为 SpotBugs 的注解即可：
Checker Framework 与 @NonNull、@Nullable
Checker Framework 能够作为 javac 编译器的插件运行，对代码中的数据类型进行检测，预防各类问题。我们可以参照 官方文档，将 Checker Framework 与 maven-compiler-plugin 结合，之后每次执行 mvn compile 时就会进行检查。Checker Framework 的空值检测程序支持几乎所有的注解，包括 JSR 305、Eclipse、甚至 lombok.NonNull。
Checker Framework 默认会将 @NonNull 应用到所有的函数参数和返回值上，因此，即使不添加这个注解，以下程序也是无法编译通过的：
Checker Framework 对使用 Spring Framework 5.0 以上的用户非常有用，因为 Spring 提供了内置的空值检测注解，且能够被 Checker Framework 支持。一方面我们无需再引入额外的 Jar 包，更重要的是 Spring Framework 代码本身就使用了这些注解，这样我们在调用它的 API 时就能有效地处理空值了。举例来说，StringUtils 类里可以传入空值的函数、以及会返回空值的函数都添加了 @Nullable 注解，而未添加的方法则继承了整个框架的 @NonNull 注解，因此，下列代码中的空指针异常就可以被 Checker Framework 检测到了：
Optional 类型
Java 8 引入了 Optional<T> 类型，我们可以用它来对函数的返回值进行包装。这种方式的优点是可以明确定义该方法是有可能返回空值的，因此调用方必须做好相应处理，这样也就不会引发空指针异常。但是，也不可避免地需要编写更多代码，而且会产生很多垃圾对象，增加 GC 的压力，因此在使用时需要酌情考虑。
方法的链式调用很容易引发空指针异常，但如果返回值都用 Optional 包装起来，就可以用 flatMap 方法来实现安全的链式调用了：
Java 8 Stream API 同样使用了 Optional 作为返回类型：
此外，Java 8 还针对基础类型提供了单独的 Optional 类，如 OptionalInt、OptionalDouble 等，在性能要求比较高的场景下很适用。
其它 JVM 语言中的空指针异常
Scala 语言中的 Option 类可以对标 Java 8 的 Optional。它有两个子类型，Some 表示有值，None 表示空。
除了使用 Option#isEmpty 判断，还可以使用 Scala 的模式匹配：
Scala 的集合处理函数库非常强大，Option 则可直接作为集合进行操作，如 filer、map、以及列表解析（for-comprehension）：
Kotlin 使用了另一种方式，用户在定义变量时就需要明确区分 可空和不可空类型。当可空类型被使用时，就必须进行空值检测。
Kotlin 的特性之一是与 Java 的可互操作性，但 Kotlin 编译器无法知晓 Java 类型是否为空，这就需要在 Java 代码中使用注解了，而 Kotlin 支持的 注解 也非常广泛。Spring Framework 5.0 起原生支持 Kotlin，其空值检测也是通过注解进行的，使得 Kotlin 可以安全地调用 Spring Framework 的所有 API。
结论
在以上这些方案中，我比较推荐使用注解来预防空指针异常，因为这种方式十分有效，对代码的侵入性也较小。所有的公共 API 都应该使用 @Nullable 和 @NonNull 进行注解，这样就能强制调用方对空指针异常进行预防，让我们的程序更为健壮。
⑹ 恳求各位Java同学，看看我这段代码到底是哪里出现了空指针异常 编译器一直抛出空指针异常啊！谢谢各位
ImageIcon image=new ImageIcon(getClass().getResource("image.png"));
image.png图片没有
应该把图片放在和这个类的同一个目录下。。
不可以是别的地方，必须是同一个目录下。。
由getClass().getResource("image.png")决定的
⑺ c语言 出现空指针赋值怎么回事请高手帮忙看下。
是编译器报的空指针赋值吧？主要原因：作者没有搞清楚C中的全局变量和局部变量的问题。
1。zts[35];point1[35];point2[35];x1[35]这四个数组在main()中有，在四个子函数中有，各是各的，互不干涉，所以main()中的这四个数组始终没有被赋值过，空指针指的就是这个吧。
2。应该把这四个数组的首地址作为四个read()的参数传过去，就可以实现：“在子函数中赋值，在main函数中使用” 的设计目的了。看程序，感觉作者就是这个目的吧。
3。 魔尊8 说的有一定道理，这四个read确实没有起到应有的作用。加上数组首地址做参数就可以了。或者把这四个数组做成全局变量也行啊。
4。作者有时间的话还是应该好好看看C语言的书啊。
⑻ 关于java中空指针异常
空指针异常产生的主要原因如下:
（1）当一个对象不存在时又调用其方法会产生异常obj.method() // obj对象不存在
（2）当访问或修改一个对象不存在的字段时会产生异常obj.method() // method方法不存在
（3）字符串变量未初始化；
（4)接口类型的对象没有用具体的类初始化，比如：
List lt；会报错
List lt = new ArrayList()；则不会报错了
当一个对象的值为空时，你没有判断为空的情况。你可以试着把下面的代码前加一行代码：
if(rb!=null && rb!="")
改成：
if(rb==null);
if(rb!==null&&rb!="") 或者if((“”).equals(rb))
空指针的解决办法：
重点关注报错发生的所在行，通过空指针异常产生的两条主要原因诊断具体的错误。同时为了避免空指针的发生，最好在做判断处理时将“null”或者空值放于设定的值之前。
⑼ C++中如何定义空指针
在C++11（C++0x）里，空指针有了一个官方版的表示：nullptr。
一种方法是定义一个NULL宏（#defineNULL0）来表示空指针，虽然本质上和直接写成0一样，但NULL能相对直观地表示这是个指针。
一些知名头文件里就带有NULL的定义，比如windows.h和stdio.h。直接用NULL似乎是个不错的主意。
有时候源文件中并不需要引用到这些知名头文件，那么NULL就要由自己来定义。
另外，NULL可以由自己定义，这意味着NULL完全有可能被定义成其他东西（少见）。因为NULL并非标准，所以有人可能自己定义了Null或null或其他东西（少见），这会带来混乱。
那么直接用0来表示空指针好了。用0表示写起来简单，而且0就是0，不会有其他定义，只是不那么直观。
(9)编译器空指针扩展阅读：
当通过指针来访问指针所指向的内存区时，指针所指向的类型决定了编译器将把那片内存区里的内容当做什么来看待。从语法上看，只须把指针声明语句中的指针名字和名字左边的指针声明符*去掉，剩下的就是指针所指向的类型。例如：
int*ptr；//指针所指向的类型是int
char*ptr；//指针所指向的的类型是char
int**ptr；//指针所指向的的类型是int*
int（*ptr）［3］；//指针所指向的的类型是int（）［3］
int*（*ptr）［4］；//指针所指向的的类型是int*（）［4］
⑽ C++函数指针和空指针的问题
函数int plus(int b)的指针类型原型为：int (*)(int)
其中左侧int指定函数返回类型，右侧(int)表示函数的参数类型。指针类型定义中，凡是右侧有括号的都表示是个函数指针，而括号内可以定义0个或多个参数，以逗号分隔。中间的(*)把星号独立起来表示是个指针定义。
当要直接定义一个函数指针时将变量名放星号后面，比如这样：
int (*p)(int) =NULL;
双参数定义：int (*p)(int,int) =NULL;
图例中由于pV是个虚指针（万能指针），可以赋值任意类型的地址，因此pV=Plus不会报错，但访问时必须强转，否则编译器不知道如何访问指针（强转就是将指定类型放在变量左侧，比如(int)a就是将a的值强转为int类型），强转格式：(类型) 变量 ,那么外面要套一层括号：(int (*)(int))pV，我们需要用强转后的函数指针传递参数进行函数调用，为避免歧义，因此需要连同变量名再打包一次：((int (*)(int))pV)，随后再传递参数10：
((int (*)(int))pV)(10)
括号打包的内容可以看作一个整体/对象，你迷惑的主要因素应该有两点：
1、不知道如何定义函数指针类型。
实际上就是将函数定义中的函数名用（*）替换，再将参数名去掉就可以了，比如下面这个函数
int * Fun(int a,char c){。。。。。。}
其函数指针类型为： int * (*)(int,char)
指针定义：int* (*p)(int, char);
2、括号嵌套多了看起来比较乱。这个很简单，一层一层拆解一层层理解。