C++ boost使_共享而不使用模板参数

我试图将指向堆栈变量的指针传递给只接受

boost:：shared\u ptr

的函数（我不控制）

据介绍，使用

boost:：make_shared

是一条可行之路。为了测试此功能，我编写了以下内容：

#include <iostream>
#include <boost/shared_ptr.hpp>
#include <boost/make_shared.hpp>

int main(int argc, char const *argv[])
{
    int i = 10;
    boost::shared_ptr<int> int_ptr = boost::make_shared(i); // doesn't work
    some_function(int_ptr); // this function takes only shared_ptr
    return 0;
}

#包括
#包括
#包括
int main（int argc，char const*argv[]
{
int i=10；
boost:：shared_ptr int_ptr=boost:：make_shared（i）；//不起作用
some_函数（int_ptr）；//此函数只接受共享的_ptr
返回0；
}

但它会抛出以下错误：

error: no matching function for call to ‘make_shared(int&)’
boost::shared_ptr<int> int_ptr = boost::make_shared(i);
                                                     ^

错误：调用“make_shared（int&）”时没有匹配的函数
boost:：shared_ptr int_ptr=boost:：make_shared（i）；
^

如果我像这样添加模板参数，它会工作，但这是什么原因呢

boost::shared_ptr<int> int_ptr = boost::make_shared<int>(i);

boost:：shared_ptr int_ptr=boost:：make_shared（i）；

---

谢谢大家!

给定

boost:：make_shared

模板：

namespace boost {
    template<typename T, typename Arg1>
      shared_ptr<T> make_shared( Arg1 const & arg1 );
}

如果要构建类型与参数相同的共享指针，可以编写包装器：

template<typename T>
boost::shared_ptr<T> my_make_shared(T const & arg) {
    return boost::make_shared<T>(arg);
}

模板
boost:：shared_ptr my_make_shared（T const&arg）{
返回boost：：使_共享（arg）；
}

但请记住，虽然这是可行的：

int i = 10.0;
std::shared_ptr<int> int_ptr = my_make_shared(i); // OK

inti=10.0；
std:：shared_ptr int_ptr=my_make_shared（i）；//好啊

隐式类型转换不会：

double d = 10.0;
std::shared_ptr<int> int_ptr = my_make_shared(d); // ERROR

double d=10.0；
std:：shared_ptr int_ptr=my_make_shared（d）；//错误

---

希望有帮助

虽然Guilherme Ferreira的回答详细阐述了模板参数推导（在这方面是正确的），但我相信这不是你想要的答案

我试图将指向堆栈变量的指针传递给只接受boost:：shared\u ptr的函数（我不控制）

shared_ptr

表示对指向对象的共享所有权。如果您试图调用的函数将指针保存在其某些数据结构（如容器）中，然后返回，则只要堆栈上的值被销毁，指针就会悬空，尽管

shared\u ptr

仍保留引用。为了做您想要做的事情，您必须绝对确保函数不会将指针保存在任何地方，并且只能在这一次调用期间使用它

如果满足此条件，则可以创建指向堆栈上某个值的

shared_ptr

，但不能为此使用

make_shared

make_shared

在堆上分配一个新对象以及该对象的引用计数器，并使用传递给函数调用的参数对其进行初始化。返回的

shared\u ptr

指向该新对象，而不是堆栈上的对象

void foo()
{
    int n = 10;
    boost::shared_ptr< int > pn = boost::make_shared< int >(n);

    assert(*pn == 10); // succeeds
    assert(pn.get() == &n); // fails

    bar(pn);
}

---

但是，请注意，此代码仍然为引用计数器

shared\u ptr

使用分配堆内存，因此您不会获得任何性能。

如果只给函数一个

int

，请自问函数应该使用哪种类型的共享指针。它如何知道您想要的是

共享的\u ptr

，而不是

共享的\u ptr

，共享的\u ptr也可以由

int

构造。请注意，模板参数推断不能包含有关结果将分配给的类型的信息。无法考虑

boost:：shared_ptr int_ptr=

部分来确定适当的模板参数。在尝试删除该内存时，创建指向堆栈分配内存的

shared_ptr

将是灾难性的。

i

是否需要通过指针进行修改，或者

i

的副本就足够了？@chris

i

不需要修改，副本就足够了，但我认为这就是使用

共享
的全部意义所在。因为我必须将
int_ptr
发送到的函数不接受除
shared_ptr
之外的任何内容，所以我没有其他选择。@simplename，这个问题指定了一个指向堆栈变量的指针。这不一定是
共享的要点。它避免了代码中的
new
，对动态分配进行了优化，并防止了在
f（new A，new A）等情况下异常泄漏对象的可能性
。将
共享的\u ptr
指向
双精度的
是什么意思？实际上，您没有将
共享的\u ptr
指向
双精度的
。但是在
make_shared
为
int
分配内存后，它会使用
double
的值初始化内存。
void foo()
{
    int n = 10;
    boost::shared_ptr< int > pn = boost::make_shared< int >(n);

    assert(*pn == 10); // succeeds
    assert(pn.get() == &n); // fails

    bar(pn);
}

void foo()
{
    int n = 10;
    boost::shared_ptr< int > pn(&n, boost::null_deleter());

    assert(*pn == 10); // succeeds
    assert(pn.get() == &n); // succeeds

    bar(pn);
}