C++

参考

<memory>

function template
<memory>

std::static_pointer_cast

template <class T, class U>  shared_ptr<T> static_pointer_cast (const shared_ptr<U>& sp) noexcept;
shared_ptr 的静态转换
返回一个指向其 存储指针 被静态转换后的正确类型的 sp 的副本U*为T*.

如果 sp 非空，则返回的对象共享 sp 的资源，其 使用计数 会加一。

如果 sp 为空，则返回的对象是一个空的 shared_ptr。

该函数只能转换满足以下表达式有效的类型
1
 
static_cast<T*>(sp.get())

参数

sp
一个 shared_pointer。
U*应可转换为T*usingstatic_cast.

返回值

一个 shared_ptr 对象，它拥有与 sp 相同的指针（如果有），并且其 共享指针 指向与 sp 相同的对象，但类型可能不同。

示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
 
// static_pointer_cast example
#include <iostream>
#include <memory>

struct A {
  static const char* static_type;
  const char* dynamic_type;
  A() { dynamic_type = static_type; }
};
struct B: A {
  static const char* static_type;
  B() { dynamic_type = static_type; }
};

const char* A::static_type = "class A";
const char* B::static_type = "class B";

int main () {
  std::shared_ptr<A> foo;
  std::shared_ptr<B> bar;

  foo = std::make_shared<A>();

  // cast of potentially incomplete object, but ok as a static cast:
  bar = std::static_pointer_cast<B>(foo);

  std::cout << "foo's static  type: " << foo->static_type << '\n';
  std::cout << "foo's dynamic type: " << foo->dynamic_type << '\n';
  std::cout << "bar's static  type: " << bar->static_type << '\n';
  std::cout << "bar's dynamic type: " << bar->dynamic_type << '\n';

  return 0;
}

输出
foo's static  type: class A
foo's dynamic type: class A
bar's static  type: class B
bar's dynamic type: class A


另见

dynamic_pointer_cast
shared_ptr 的动态转换 (函数模板)
const_pointer_cast
shared_ptr 的 const 转换 (函数模板)
shared_ptr
共享指针 (类模板)