标签: shared-ptr

更新

这行代码是否有效:

boost::shared_array<struct sockaddr> addr(
    reinterpret_cast<struct sockaddr *>(
        (ipv6 ? new unsigned char [sizeof(struct sockaddr_in6)]
              : new unsigned char [sizeof(struct sockaddr_in)])
    )
);

请注意分配和类型中给出的类型之间的两种不同数据类型<template>.

最初的问题是使用boost :: shared_ptr

这行代码是否有效:

boost::shared_ptr<struct sockaddr> addr(
    reinterpret_cast<struct sockaddr *>(
        (ipv6 ? new unsigned char [sizeof(struct sockaddr_in6)]
              : new unsigned char [sizeof(struct sockaddr_in)])
    )
);

请注意分配和类型中给出的类型之间的两种不同数据类型<template>.

解

boost::shared_array<unsigned char> address(new unsigned char [sizeof(sockaddr_in)]);

注意:使用相同类型的unsigned char,其大小恰好是所需的大小.

然后当我打算使用它时:

bind(, (sockaddr*)address.get(), );

我在“Serializer”类中使用共享指针时收到错误。

这是我的详细错误：

 client.h:28:52: error: expected identifier before new
 std::shared_ptr<Serializer> serializerObj2(new Serializer);
                                                ^
 client.h:28:52: error: expected , or .. before new

这是我的最小代码：

std::shared_ptr<Serializer> serializerObj2(new Serializer);

这是我的扩展代码：

#include "serializer.h" 
#include<iostream>
#include<sys/types.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<unistd.h>
#include<stdlib.h>
#include<thread>
#include<string>
#include<cstring>
#include<utility>
#include <boost/filesystem.hpp>
#include<memory>

namespace TCP
{    
class Client
{
public:
    void start();
private:

    int networkSocket=socket(AF_INET,SOCK_STREAM,0);
    std::shared_ptr<Serializer> serializerObj2(new Serializer);
    std::shared_ptr<Serializer> serializerObj=std::make_shared<Serializer>();

    bool checkConnection();
    std::pair<bool,std::string>getFile();
    void sendMessage();
    void setMessage();
}; 
}//closes namespace `

这是我的序列化器 h 文件：

#ifndef D_SERIALIZER_H
#define D_SERIALIZER_H
#include<iostream>
#include<arpa/inet.h>
#include<string>
namespace TCP …

我对所有C++编码器都有一个小问题!对于您来说,它是否与"C++哲学"兼容,以重新编码您自己的智能指针.实际上我将shared_ptr与weak_ptr一起用于项目,但它使代码过于复杂.我当然可以使用raw_ptr,但是......它是"普通c"......所以你怎么看待它？我应该重新编写自己的智能指针还是继续将shared_ptr与weak_ptr一起使用

我在我的项目中使用 boost 库。在编写 rest http 客户端代码时，出现此错误。

libc++abi.dylib：以未捕获的 std::__1::bad_weak_ptr 类型异常终止：bad_weak_ptr

template <typename M>
 21 class Http: public std::enable_shared_from_this<Http<M>>
 22 {
 23     M* message_;
 24     bool isSubscribe_;
 25     boost::asio::io_context io_;
 26     boost::asio::ip::tcp::resolver resolver_;
 27     boost::beast::tcp_stream stream_;
 28     boost::beast::flat_buffer buffer_;
 29     boost::beast::http::request<boost::beast::http::empty_body> req_;
 30     boost::beast::http::response<boost::beast::http::string_body> res_;
 31     std::function<void(M*)> callback_;
 32 
 33     void SetUpRestHeader() {
 34         req_.method(boost::beast::http::verb::get);
 35         req_.target(message_ -> header_ -> target_);
 36         req_.set(boost::beast::http::field::host, message_ -> header_ -> host_);
 37         req_.set(boost::beast::http::field::user_agent, BOOST_BEAST_VERSION_STRING);
 38 
 39         resolver_.async_resolve(message_ -> header_ -> host_
 40                 , message_ -> …

我是新手，shared_ptr无法解决这个问题，

我想存储shared_ptr在 custom 中struct。

struct ThreadSafeQMsg
{
    ThreadSafeQMsg(shared_ptr<ptree> control, shared_ptr<uint32_t> data=0, int data_size=0) {
        data_size = data_size; 
        data = data;
        control = control;
    }
    size_t data_size;
    shared_ptr<ptree> control;
    shared_ptr<uint32_t> data;
};

    ThreadSafeQMsg* tmsg = new ThreadSafeQMsg(control,spData, data_size);
    PRINT_LOG("message with data[" << std::dec << tmsg->data_size << ",ref: " << std::dec << tmsg->data.use_count() 
                                 << "] & control[ref: " << std::dec << tmsg->control.use_count() << "]");

在分配之前，我看到在分配后检查时引用计数为 1，我得到：

message with data[140737018606128,ref: 0] & control[ref: 0]

我在这里错过了什么？

我刚开始学习智能指针，遇到了一个似乎与理论相矛盾的情况。例如，当我们使用 shared_ptr 并且如果调用复制语义时，对象共享所有权并且引用计数为 2。这是可以理解的。例如代码。

 class Test {
    public:
    Test(){ cout << "Const" << "\n"; }

    void Disp(){
        cout << "Class Test()\n";
    }

    ~Test(){ cout << "Dest" << "\n"; }
 };

int main()
{
 Test *p = new Test();
 shared_ptr<Test> p1(p);
 shared_ptr<Test> p2(p1); // = make_shared<Test>(*p1);

 p1->Disp();
 p2->Disp();

}

输出很好，因为：

Const
Class Test()
Class Test()
Dest

现在，如果我尝试将语义移动为

int main()
{
 Test *p = new Test();
 shared_ptr<Test> p1(p);
 shared_ptr<Test> p2 = make_shared<Test>(*p1);

 p1->Disp();
 p2->Disp();

}

那么 p1 应该已经失去了所有权。因此 p1->Disp() 应该是有效的。因为 make_shared 将转移所有权并重置 …

AFAIKunique_ptr与 PIMPL 一起使用非常棘手，因为删除器是unique_ptr类型的一部分，因此它不适用于不完整的类型。另一方面，shared_ptr使用动态删除器，因此它可以处理不完整的类型。

shared_ptr无论我是否需要，都存在给我原子操作的性能问题。

我可以使用其他更快的替代方案吗std::？我显然对类型擦除很满意，我说的是原子引用计数的成本。

#include <any>
#include <memory>
#include <iosfwd>

std::shared_ptr<std::fstream> sp;
// unique_ptr requires complete type
// std::unique_ptr<std::fstream> up;
std::any a;

#include <fstream>
int main() {
    // any requires copy_constructible
    // a = std::fstream{};  
    sp = std::make_shared<std::fstream>();
} 

笔记：

• 我考虑过any，但它不适用于某些类型。
• 我考虑使用动态删除器的 unique_ptr ，但据我所知构造unique_ptr函数永远不会“告诉”删除器构造的对象是什么（为删除器提供一种学习如何销毁对象的方法）。

PS 我知道很久以前boost::shared_ptr就有宏来禁用原子引用计数，但即使仍然支持我也不想切换到boost::shared_ptr.

我想定义两个类A，并I以它们的对象尊重这种关系的方式：

i1 -----------a1
  |------a2
  |----a3

• 该类的一个实例I指向该类的零个、一个或多个实例A。

• 类的一个实例A仅指向该类的一个实例I。

• 类的实例I可以没有任何类的实例A，但类的实例必须“附加”A类的实例。I

为了满足这些条件，我将这两个类声明如下：

class I;
class A
{
    private:
        std::string as;
        std::shared_ptr<I> iA;        
    public:
        A(std::string aTxt);
        A();
        ~A();
};

class I
{
   private:
       std::string ip;
       std::vector<std::unique_ptr<A>> as;
       friend class A;
   public:
       I(std::string i);
       ~I();
};

在源文件中，我以这种方式定义了这两个类：

A::A(std::string aText)
{
    as = aText;
}

A::A()
{
    as = "";
}

A::~A()
{
}

I::I(std::string i)
{ …

我有一个类中的类对象的std::vector成员.函数添加指向向量的新对象的指针.构造函数使得指向的数据的内部副本.现在,当我调用我的函数时,是否所有内存都会被释放？boost::shared_ptrFooSetData()FooFoopDataReset()

class myClass()
{
 void SetData(char* pData, size_t nSize)
 {
   boost::shared_ptr<Foo> pFoo(new Foo(pData, nSize));
   mVector.push_back(pFoo);
 }

 void Reset()
 {
   mVector.clear();
 }

private:
    std::vector<boost::shared_ptr<Foo>> mVector;


};

use_count()使用iteratorde-reference 打印共享指针时,下面的程序输出意外值std::vector:

#include<iostream>
#include<memory>
#include<vector>

class A;

typedef std::shared_ptr<A>            sharedPtr;
typedef std::vector<sharedPtr>        sharedPtrVect;
typedef sharedPtrVect::const_iterator vectItr;

class A
{
  public:
    A(int inp): m_Val(inp) { /*std::cout << "*** A ctor called: " << m_Val << " ***" <<std::endl;*/ }
    ~A() { /*std::cout << "### A dtor called: " << m_Val << " ###" <<std::endl; */}

    int getVal() const { return m_Val; }

  private:
    int m_Val;
};

int main()
{
  sharedPtrVect myVect1, myVect2;
  vectItr myVectItr;
  std::shared_ptr<A> tmpPtr; …