指针声明

来自cppreference.com
< cpp‎ | language

声明指针或指向成员指针类型的变量。

目录

[编辑] 语法

指针声明是任何声明器拥有下列形式的简单声明

* attr(可选) cv(可选) declarator (1)
nested-name-specifier * attr(可选) cv(可选) declarator (2)
1) 指针声明器:声明 S* D; 声明 D 为指向 decl-specifier-seq S 所确定类型的指针。
2) 指向成员指针声明器:声明 S C::* D; 声明 D 为指向 Cdecl-specifier-seq S 所确定类型非静态数据成员的指针。
declarator - 任何异于引用声明器的声明器(无指向引用的指针)。它能是另一指针声明器(允许指向指针的指针)
attr(C++11) - 属性的可选列表
cv - 应用到被声明指针的 const/volatile 限定(不是对被指向类型,其限定是 decl-specifier-seq 的一部分)
nested-name-specifier - 名称和作用域解析运算符 :: 的序列

无指向引用的指针,无指向位域的指针。

对“指针”的无详述提及通常不包含指向(非静态)成员指针。

[编辑] 指针

每个指针类型值是下列之一:

  • 指向对象或函数的指针(该情况下说该指针指向函数或对象),或
  • 对象尾后指针,或
  • 该类型的空指针值,或
  • 非法指针值

指向对象的指针表示地址,地址属于对象所占用内存中的首字节。对象尾后指针表示地址,地址为对象所占用存储后的内存的首字节。

注意,然而二个表示同一地址的指针可能拥有不同值。

struct C {
   int x, y;
} c;
 
int* px = &c.x;   // px 的值为“指向 c.x 的指针”
int* pxe= px + 1; // pxe 的值为“ c.x 的尾后指针”
int* py = &c.y;   // py 的值为“指向 c.y 的指针”
 
assert(pxe == py); // == 测试二个指针是否表示相同地址
                   // 可能或可能不崩溃
 
*pxe = 1; // 即使断言不崩溃,亦为未定义行为


通过非法指针值间接和传递非法指针值给解分配函数拥有未定义行为。非法指针值的任何其他使用拥有实现定义行为。

[编辑] 指向对象指针

指向对象指针,能以应用于任何对象类型,包含另一指针类型表达式的取址运算符的返回值初始化:

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

指针可出现为内建间接运算符(一元 operator* )的运算数,其返回指代被指向对象的左值表达式

int n;
int* p = &n;     // 指向 n 的指针
int& r = *p;     // 绑定到指代 n 的左值表达式的引用
r = 7;           // 存储 int 7 于 n
std::cout << *p; // 左值到右值隐式转换从 n 读取值

指向类对象指针亦可出现为成员访问运算符 operator->operator->* 的左侧运算数。

因为数组到指针转换,指向数组首成员的指针能以数组类型表达式初始化:

int a[2];
int* p1 = a; // 指向数组 a 首元素 a[0] (一个 int )的指针
 
int b[6][3][8];
int (*p2)[3][8] = b; // 指向数组 b 首元素 b[0] 的指针,
                     // 被指者为 3 个 8 个 int 的数组所构成的数组

因为指针的导出类到基类隐式转换,指向基类的指针能以导出类的地址初始化:

struct Base {};
struct Derived : Base {};
 
Derived d;
Base* p = &d;

Derived多态,则这种指针可用于进行虚函数调用

确定的加法、减法自增和自减为指向数组元素的指针定义:这种指针满足随机访问迭代器 (RandomAccessIterator) 要求,并允许 C++ 库算法工作于生数组上。

比较运算符在一些情况下为指针定义:二个表示相同地址的指针比较相等,二个空指针值比较相等,指向同一数组元素的指针的以同元素的数组下标的方式比较,而指向拥有同一成员访问的非静态数据成员的指针以同成员声明顺序的方式比较。

多数实现亦为随机来源的指针提供严格全序,例如若将它们实现为连续虚拟地址空间中的地址。不如此的实现(例如,其中指针所有位并非内存地址的一部分,在比较时必须忽略之,或者要求附带的计算,或者指针与整数并非 1 对 1 关系)为指针提供由此保证的 std::less 特化。这使得可在关联容器,如 std::setstd::map 中使用所有随机来源的指针。

[编辑] 指向 void 的指针

指向任何类型队形的指针能隐式转换成指向 void 的指针(可选地有 cv 限定 )。逆向转换要求 static_cast显式转型,生成原指针值:

int n = 1;
int* p1 = &n;
void* pv = p1;
int* p2 = static_cast<int*>(pv);
std::cout << *p2 << '\n'; // 打印 1

若原指针指向某多态类型对象中的基类子对象,则可用 dynamic_cast 获得指向最终导出类完整对象的 void*

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

[编辑] 指向函数指针

指向函数指针能以非成员函数或静态成员函数的地址初始化。因为函数到指针隐式转换,取址运算符是可选的:

void f(int);
void (*p1)(int) = &f;
void (*p2)(int) = f; // 同 &f

不同于函数或到函数引用,指向函数指针是对象,从而能存储于数组、复制、赋值等。

指向函数指针能用作函数调用运算符的左侧运算数,这会调用被指向的函数:

int f(int n)
{
    std::cout << n << '\n';
    return n * n;
}
 
int main()
{
    int (*p)(int) = f;
    int x = p(7);
}

解引用函数指针生成标识被指向函数的左值:

int f();
int (*p)() = f;  // 指针 p 指向 f
int (&r)() = *p; // 将标识 f 的左值绑定到引用
r();             // 通过左值引用调用函数 f
(*p)();          // 通过函数左值调用函数 f
p();             // 直接通过指针调用函数 f

指向函数指针能从可包含函数、函数模板特化及函数模板的重载集初始化,若只有一个重载匹配指针类型(细节见重载函数的地址):

template<typename T> T f(T n) { return n; }
double f(double n) { return n; }
 
int main()
{
    int (*p)(int) = f; // 实例化并选择 f<int>
}

相等比较运算符为指向函数指针定义(若指向同一函数则它们比较相等)。

[编辑] 指向成员指针

[编辑] 指向数据成员指针

指向作为类 C 成员的非静态数据成员 m 的指针能准确地以表达式 &C::m 初始化。 C 的成员函数中,如 &(C::m)&m 的表达式不构成指向成员指针。

这种指针能用作指向成员指针访问运算符 operator.*operator->* 的右侧运算数:

struct C { int m; };
 
int main()
{
    int C::* p = &C::m;          // 指向类 C 的数据成员 m
    C c = {7};
    std::cout << c.*p << '\n';   // 打印 7
    C* cp = &c;
    cp->m = 10;
    std::cout << cp->*p << '\n'; // 打印 10
}

指向可访问无歧义非虚基类数据成员的指针能隐式转换成指向导出类的同一数据成员的指针:

struct Base { int m; };
struct Derived : Base {};
 
int main()
{
    int Base::* bp = &Base::m;
    int Derived::* dp = bp;
    Derived d;
    d.m = 1;
    std::cout << d.*dp << ' ' << d.*bp << '\n'; // 打印 1 1
}

反向转换,从指向导出类数据成员的指针到指向无歧义非虚基类数据成员的指针,由 static_cast显式转型允许,即使基类无该数据成员(但在用该指针访问时的最终导出类有):

struct Base {};
struct Derived : Base { int m; };
 
int main()
{
    int Derived::* dp = &Derived::m;
    int Base::* bp = static_cast<int Base::*>(dp);
 
    Derived d;
    d.m = 7;
    std::cout << d.*bp << '\n'; // OK :打印 7
 
    Base b;
    std::cout << b.*bp << '\n'; // 未定义行为
}

指向成员指针的被指向类型可以是指向成员指针自身:指向成员指针可为多级,而且在每级可以有不同 cv 限定。亦允许指针和指向成员指针的混合多级组合:

struct A
{
    int m;
    // 指向非 const 成员的 const 指针
    int A::* const p;
};
 
int main()
{
    // 指向数据成员的非 const 指针,该成员是指向非 const 成员的 const 指针
    int A::* const A::* p1 = &A::p;
 
    const A a = {1, &A::m};
    std::cout << a.*(a.*p1) << '\n'; // 打印 1
 
    // 常规的非 const 指针到 const 指向成员指针的
    int A::* const* p2 = &a.p;
    std::cout << a.**p2 << '\n'; // 打印 1
}

[编辑] 指向成员函数指针

指向作为类 C 成员的非静态成员函数 f 能准确地以表达式 &C::f 初始化。 C 的成员函数内,如 &(C::f)&f 的表达式不构成指向成员指针。

这种指针能用做指向成员指针访问运算符 operator.*operator->* 的右运算数。结果表达式只能用作函数调用运算符的左侧运算数:

struct C
{
    void f(int n) { std::cout << n << '\n'; }
};
 
int main()
{
    void (C::* p)(int) = &C::f; // 指向类 C 成员函数 f 的指针
    C c;
    (c.*p)(1);                  // 打印 1
    C* cp = &c;
    (cp->*p)(2);                // 打印 2
}


指向基类成员函数的指针能隐式转换成指向导出类同一成员函数的指针:

struct Base
{
    void f(int n) { std::cout << n << '\n'; }
};
struct Derived : Base {};
 
int main()
{
    void (Base::* bp)(int) = &Base::f;
    void (Derived::* dp)(int) = bp;
    Derived d;
    (d.*dp)(1);
    (d.*bp)(2);
}

反向转换,从指向导出类成员函数的指针到指向无歧义非虚基类成员函数的指针,由 static_cast显式转型允许,即使基类无该成员函数(但在用指针访问时的最终导出类有):

struct Base {};
struct Derived : Base
{
    void f(int n) { std::cout << n << '\n'; }
};
 
int main()
{
    void (Derived::* dp)(int) = &Derived::f;
    void (Base::* bp)(int) = static_cast<void (Base::*)(int)>(dp);
 
    Derived d;
    (d.*bp)(1); // OK :打印 1
 
    Base b;
    (b.*bp)(2); // 未定义行为
}

指向成员函数指针可用作回调或函数对象,通常在应用 std::mem_fnstd::bind 之后:

#include <iostream>
#include <string>
#include <algorithm>
#include <functional>
 
int main()
{
    std::vector<std::string> v = {"a", "ab", "abc"};
    std::vector<std::size_t> l;
    transform(v.begin(), v.end(), std::back_inserter(l),
              std::mem_fn(&std::string::size));
    for(std::size_t n : l)
        std::cout << n << ' ';
}

输出:

1 2 3

[编辑] 空指针

每个类型的指针都拥有一个特殊值,被称为该类型的空指针值。值为空的指针不指向对象或函数(解引用空指针是未定义行为),并与所有值亦为的同类型指针比较相等。

为初始化指针为空或赋空值给既存指针,可用空指针字面量 nullptr 、空指针常量 NULL 或从整数值 0 隐式转换

值初始化亦初始化指针为其空值。

空指针可用于指示对象不存在(例如 function::target() ),或作为其他错误条件指示器(例如 dynamic_cast )。通常,接受指针参数的函数始终需要检查值是否为空,并有别地处理该情况(例如, delete 表达式在传递空指针时不做任何事)。

[编辑] 常性

  • 若指针声明中 cv 先出现于 * ,则它是 decl-specifier-seq 的一部分,并应用到被指向对象。
  • 若指针声明中 cv 后出现于 * ,则它是 declarator 的一部分,并应用到正在声明的指针。
语法 含义
const T* 指向常对象的指针
T const* 指向常对象的指针
T* const 指向对象的常指针
const T* const 指向常对象的常指针
// pc 是指向 const int 的非 const 指针
// cpc 是指向 const int 的 const 指针
// ppc 是指向指向 const int 的非 const 指针的非 const 指针
const int ci = 10, *pc = &ci, *const cpc = pc, **ppc;
// p 是指向非 const int 的非 const 指针
// cp 是指向非 const int 的 const 指针
int i, *p, *const cp = &i;
 
i = ci;    // OK :复制 const int 值到非 const int
*cp = ci;  // OK :能修改非 const int (为 const 指针所指向)
pc++;      // OK :能修改非 const 指针(指向 const int )
pc = cpc;  // OK :能修改非 const 指针(指向 const int )
pc = p;    // OK :能修改非 const 指针(指向 const int )
ppc = &pc; // OK :指向 const int 的指针的地址是指向指向 const int 指针的指针
 
ci = 1;    // 错误:不能修改 const int
ci++;      // 错误:不能修改 const int
*pc = 2;   // 错误:不能修改被指向的 const int
cp = &ci;  // 错误:不能修改 const 指针(指向非 const int )
cpc++;     // 错误:不能修改 const 指针(指向 const int )
p = pc;    // 错误:指向非 const int 的指针不能指向 const int
ppc = &p;  // 错误:指向指向 const int 的指针的指针不能指向指向非 const int 的指针

通常,从一个多级指针到另一个的隐式转换遵循描述于限定转换指针比较运算符的规则。

[编辑] 参阅

指针声明C 文档