指针声明

指针是一种对象类型，它引用函数或另一种类型的对象，可以添加限定符。指针亦可以不引用任何内容，这通过一个特定的空指针值指示。

语法

在指针声明的声明文法中， 类型说明符 序列指代所指向的类型（可以是函数或对象，可以是不完整类型），而声明器拥有形式：

其中 声明符 可以是命名所声明指针的标识符，包括另一个指针声明器（这指示一个指向指针的指针）：

float *p, **pp; // p 是指向 float 的指针
                // pp 是指向指向 float 指针的指针
int (*fp)(int); // fp 是指向类型 int(int) 为函数的指针

出现在 * 与标识符（或另一个嵌套声明符）间的 限定符 将被声明的限定赋予指针类型：

int n;
const int * pc = &n; // pc 是指向 const int 的非 const 指针
// *pc = 2; // 错误：不能通过不带转型的 p 修改 n
pc = NULL; // OK ： pc 自身可修改
 
int * const cp = &n; // cp 是一个指向非 const 的 int 的 const 指针
*cp = 2; // OK ：通过 cp 修改 n
// cp = NULL; // 错误： cp 自身不能修改
 
int * const * pcp = &cp; // 指向指向非 const 的 int 的 const 指针的非 const 指针

解释

指针用于间接使用，这是种普遍存在的编程技巧；它们可以用于实现按引用传递语义、访问有动态存储期的对象、实现“可选”类型（使用空指针值）、结构体间的聚合关系、回调（使用指向函数指针）、泛型接口（使用指向 void 的指针）以及其他更多。

指向对象的指针

指向对象的指针可以通过应用于对象类型（可以不完整）表达式的取值运算符初始化：

int n;
int *np = &n; // 指向 int 的指针
int *const *npp = &np; // 指向指向非 const 的 int 的 const 指针的非 const 指针
 
int a[2];
int (*ap)[2] = &a; // 指向 int 数组的指针
 
struct S { int n; } s = {1}
int* sp = &s.n; // 指向作为 s 成员的 int 的指针

指针可以出现作间接运算符 （一元 * ）的运算数，它返回标识所指向对象的左值：

int n;
int* p = &n;     // 指针 p 指向 n
*p = 7;         // 存储 7 于 n
printf("%d\n", *p); // 左值到右值转换从 n 读取值

指向 struct 和 union 类型对象的指针亦可作为经由指针成员访问运算符 -> 的左运算数出现。

因为数组到指针隐式转换，指向数组首元素的指针可通过数组类型表达式初始化：

int a[2];
int *p = a; // 指向a[0]
 
int b[3][3];
int (*row)[3] = b; // 指向b[0]

确定的加减、复合赋值、自增减运算符定义于指向数组元素的指针。

比较运算符在一些情况下定义于指向对象的指针：二个表示相同地址的指针比较相等，二个空指针值比较相等，比较指向同一数组的元素的指针以二个元素的数组下标比较，及指向结构体成员的指针以这些成员声明顺序比较。

许多实现亦提供随意来源指针的严格全序，例如若它们实现在连续（“平直”）的虚拟地址空间上。

指向函数的指针

指向函数的指针可由函数地址初始化。因为函数到指针转换，取址运算符是可选的：

void f(int);
void (*pf1)(int) = &f;
void (*pf2)(int) = f; // 等于&f

不同于函数，指向函数的指针是对象，从而能存储在数组中、复制、赋值、作为参数传递给其他函数等等。

指向函数的指针可以用作函数调用运算符的左运算数；这会调用所指向的函数：

#include <stdio.h>
int f(int n)
{
    printf("%d\n", n);
    return n*n;
}
int main(void)
{
    int (*p)(int) = f;
    int x = p(7);
}

解引用函数指针产生所指向函数的函数指代器：

int f();
int (*p)() = f;    // 指针 p 指向 f
(*p)(); // 通过函数指代器调用函数 f
p();    // 直接通过指针调用 f

等于比较运算符定义于指向函数的指针（若指向相同函数则它们比较相等）。

因为函数类型的兼容性忽略函数参数的顶层限定符，指向仅在参数的顶层限定符有区别的函数指针是可互换的：

int f(int), fc(const int);
int (*pc)(const int) = f; // OK
int (*p)(int) = fc;       // OK
pc = p;                   // OK

指向 void 指针

指向任意类型对象的指针能隐式转换成指向 void 的指针（可选地有 const 或 volatile 限定），反之亦然：

int n=1, *p=&n;
void* pv = p; // int* 到 void*
int* p2 = pv; // void* 到 int*
printf("%d\n", *p2); // 打印 1

指向 void 的指针用于传递未知类型的对象，这在泛型接口中常用： malloc 返回 void* ，qsort 期待用户提供接受二个 const void* 参数的回调。 pthread_create 期待用户提供接受并返回 void* 的回调。所有情况下，调用方负责在使用前将指针转换到正确的类型。

空指针

每种类型的指针都有含有一个该类型的特殊的值，称为空指针值。值为空的指针不指向对象或函数（解引用空指针是未定义行为），而且与所有相同类型的且值以为空的指针比较相等。

为初始化指针为空，或将空值赋给已存在的指针，可以使用空指针常量（ NULL ，或其他任何拥有值零的整数常量）。静态初始化亦将指针初始化到它们的空值。

空指针可以指示对象不存在，或可用于指示错误条件的其他对象。通常，接收指针参数的函数几乎总是需要检查该值是否为空，并对该情况特殊处理（例如， free 在传递空指针时不做任何事）。

注解

尽管任何指向对象的指针能被转型成指向其他类型对象的指针，解引用指向类型异于对象声明类型的指针几乎总是未定义行为。细节见严格别名使用。

数组类型的左值表达式，在大多数语境中使用时，会经历隐式转换到指向数组首元素的指针。细节见数组到指针转换。

char *str = "abc"; // "abc" 是 char[4] 类型的数组， str 是指向 'a' 的指针

指向 char 的指针通常用于表示字符串。为表示合法的字节字符串，指针必须指向作为 char 数组元素的 char ，而且在大于或等于指针所引用元素的下标的某个下标处，必须有零值的 char 。

引用