理解 C++ std::shared_ptr 与临时对象一起使用

Question

我试图了解 shared_ptr p 在构造未命名 shared_ptr 时的用法及其对 p 的影响。我在玩弄自己的示例并编写了以下代码：

shared_ptr<int> p(new int(42));
cout << p.use_count() << '\n';          
{ 
  cout << p.use_count() << '\n';
  shared_ptr<int>(p);
  cout << p.use_count() << '\n';
}
cout << p.use_count() << '\n';

Output:
1
1
0
1

第 5 行使用 p 创建临时文件是否正确？ shared_ptr（即未命名的 shared_ptr)?
如果是这样，为什么 use_count 没有增加。 temp.object 是否被摧毁在我们退出第 7 行的代码块之前。
如果它被销毁并且p的使用计数在块内变为零，怎么出块后又是1呢？

如果我在第 5 行使用命名的 shared_ptr q，即：

shared_ptr<int>q(p);

一切都会按预期工作，在第 5 行之后的块内使用计数将为 2，在我们退出块后它将再次为 1。

Answer 1

没有

在第 5 行中，您创建了新变量 p。空一个。看到这个：

shared_ptr<int> p(new int(42));
cout << p.use_count() << '\n';
cout << "address " << &p << "\n";
{
    cout << p.use_count() << '\n';
    shared_ptr<int>(p);
    cout << "address " << &p << "\n";
    cout << p.use_count() << '\n';
}
cout << p.use_count() << '\n';

输出：

1
address 0x7ffcf3841860
1
address 0x7ffcf3841870
0
1

请注意，p 的地址已更改。

要修复它，请更改括号：

shared_ptr<int> {p};

Answer 2

shared_ptr<int>(p); 等同于 shared_ptr<int> p;，本质上是在该块内创建另一个 p 来隐藏之前的 p。这里的括号不是构造函数调用，而是被编译器解释为分组表达式的数学括号，表达式是新构造的名称 shared_ptr.

shared_ptr<int>q(p); 而是创建一个名为 q 的新 shared_ptr，以对 p 的引用作为参数调用构造函数（从而增加引用计数）。本例中的括号被解释为包含构造函数参数。

请注意，当您使用大括号 {} 时，std::shared_ptr<int>q{p}; 将继续给出预期结果 (1 1 2 1)，而 std::shared_ptr<int>{p}; 将打印 (1 1 1 1 ), 因为编译器现在考虑它周围的小块的第二个 p 部分。用 C++ 编程的乐趣。

Answer 3

根据 C++ 标准（8.5.1.3 显式类型转换（函数符号））

1 A simple-type-specifier (10.1.7.2) or typename-specifier (17.7) followed by a parenthesized optional expressionlist or by a braced-init-list (the initializer) constructs a value of the specified type given the initializer...

所以这个表达式语句中的表达式

shared_ptr<int>(p);

看起来像一个显式类型转换（函数式）表达式。

另一方面，声明中的声明符可以用括号括起来。例如

int ( x );

是一个有效的声明。

所以这个声明

shared_ptr<int>(p);

可以解释为类似

的声明

shared_ptr<int> ( p );

所以有歧义。

C++ 标准通过以下方式解决这种歧义（9.8 歧义解决）

1 There is an ambiguity in the grammar involving expression-statements and declarations: An expression statement with a function-style explicit type conversion (8.5.1.3) as its leftmost subexpression can be indistinguishable from a declaration where the first declarator starts with a (. In those cases the statement is a declaration.

因此内部代码块中的这条语句

shared_ptr<int>(p);

是一个名为 p 的新共享指针的声明，它隐藏了外部代码块中具有相同名称 p 的对象的先前声明，并且是通过使用默认构造函数

constexpr shared_ptr() noexcept;

根据这个构造函数的描述

2 Effects: Constructs an empty shared_ptr object.

3 Postconditions: use_count() == 0 && get() == nullptr.

如果您想处理表达式而不是声明，那么您需要做的就是将语句主体括在括号中，从而在表达式语句中获得主表达式。

这是一个演示程序。

#include <iostream>
#include <memory>

int main() 
{
    std::shared_ptr<int> p( new int( 42 ) );

    std::cout << "#1: " << p.use_count() << '\n';          

    { 
        std::cout << "#2: " << p.use_count() << '\n';

        ( std::shared_ptr<int>( p ) );

        std::cout << "#3: " << p.use_count() << '\n';
    }

    std::cout << "#4: " << p.use_count() << '\n';

    return 0;
}

在这种情况下它的输出是

#1: 1
#2: 1
#3: 1
#4: 1

理解 C++ std::shared_ptr 与临时对象一起使用

Understanding C++ std::shared_ptr when used with temporary objects

c++

syntax

expression

declaration

shared-ptr