const和shared_ptr及基于智能指针的PCL的深拷贝与浅拷贝

已于 2022-08-01 21:08:43 修改
阅读量1.7k 收藏 5
点赞数 6
分类专栏： PCL Learn 文章标签： c++ 开发语言
于 2021-07-15 12:32:16 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_47989004/article/details/118756843
版权

常量指针与指针常量

如果关键字const出现在星号左边，表示被指物是常量；如果出现在星号右边，表示指针自身是常量；如果出现在星号两边，表示被指物和指针两者都是常量

//const int *ptr, int const *ptr, int * const ptr, const int * const ptr
const int* ptr1=new int(1);
int const* ptr2=new int(2);
int *const ptr3=new int(3);
const int *const ptr4=new int(4);
// error
// *ptr1=5;
// *ptr2=5;
// ptr3=ptr1;
// ok
// ptr1=ptr2;
// ptr2=ptr1;
// *ptr3=5;

const and shared_ptr

shared_ptr<T> p;             ---> T * p;                                    : nothing is const
const shared_ptr<T> p;       ---> T * const p;                              : p is const
shared_ptr<const T> p;       ---> const T * p;       <=> T const * p;       : *p is const
const shared_ptr<const T> p; ---> const T * const p; <=> T const * const p; : p and *p are const.

ConstPtr and Ptr

using Ptr = shared_ptr<PointCloud<PointT> >;
using ConstPtr = shared_ptr<const PointCloud<PointT> >;

Convert Ptr to ConstPtr

template <class T, class U>
  shared_ptr<T> const_pointer_cast (const shared_ptr<U>& sp) noexcept;

std::shared_ptr<int> foo;
std::shared_ptr<const int> bar;

foo = std::make_shared<int>(10);
bar = std::const_pointer_cast<const int>(foo);

Construct ConstPtr from Ptr

pcl::PointCloud<pcl::PointXYZRGBA>::Ptr ptr(new pcl::PointCloud<pcl::PointXYZRGBA>);
std::cout<<ptr.use_count()<<'\n';
pcl::PointCloud<pcl::PointXYZRGBA>::ConstPtr cptr(ptr);
std::cout<<ptr.use_count()<<'\n';

// [out] 1 2

智能指针

智能指针的实现

class SharedPtr
{
public:
        SharedPtr(T*ptr=NULL)
               :_ptr(ptr)
               , _pcount(new int(1))
        {}
        SharedPtr(const SharedPtr&s)
               :_ptr(s._ptr)
               , _pcount(s._pcount)
        {
               *(_pcount)++;
        }
        SharedPtr<T>&operator=(const SharedPtr&s)
        {
               if (this!= &s)
               {
                       if (--(*(this->_pcount)) == 0)
                       {
                              delete this->_ptr;
                              delete this->_pcount;
                       }
                       _ptr = s._ptr;
                       _pcount = s._pcount;
                       *(_pcount)++;
               }
               return *this;
        }
        T&operator*()
        {
               return *(this->_ptr);
        }
        T*operator->()
        {
               return this->_ptr;
        }
        ~SharedPtr()
        {
               --(*(this->_pcount));
               if (this->_pcount == 0)
               {
                       delete _ptr;
                       _ptr = NULL;
                       delete _pcount;
                       _pcount = NULL;
               }
        }
private:
        T*_ptr;
        int *_pcount;//指向引用计数的指针
};
int main()
{
        SharedPtr<int>p1(new int(1));
        SharedPtr<int>p2(p1);//调用拷贝构造函数
        SharedPtr<int> p3 = p2;//调用的是拷贝构造函数、因为p3原本是不存在的。
        p3 = p2;
        system("pause");
        return 0;
}

注意拷贝构造函数和operator=调用时机的区别，当对象不存在时，调用的是拷贝构造函数，当对象存在时，调用的是operator=

智能指针调用示例

pcl::PointCloud<pcl::PointXYZRGBA>::Ptr glbptr(new pcl::PointCloud<pcl::PointXYZRGBA>);

// It cannot be acheived if you want to encapsulate the Ptr object 
// 返回的是全局变量的引用，不会出现拷贝
const pcl::PointCloud<pcl::PointXYZRGBA>::Ptr& get(){
    return glbptr;
}
// 由Ptr构造生成ConstPtr，ConstPtr对象构造会出现复制
pcl::PointCloud<pcl::PointXYZRGBA>::ConstPtr getConst(){
    return std::const_pointer_cast<const pcl::PointCloud<pcl::PointXYZRGBA> >(glbptr);
}

bool bvisualizer=true;

int main ()
{
    get()->points.resize(1); // ok to operate the object
    std::cout<<glbptr.use_count()<<'\n';
    // 等价于pcl::PointCloud<pcl::PointXYZRGBA>::Ptr glbptr1 = glbptr， 由于拷贝构造，出现复制
    pcl::PointCloud<pcl::PointXYZRGBA>::Ptr glbptr1=get();  
    glbptr1->points.resize(2); // ok to operate the object
    std::cout<<glbptr.use_count()<<'\n';
    pcl::PointCloud<pcl::PointXYZRGBA>::ConstPtr cglbptr2=getConst();
    std::cout<<glbptr.use_count()<<'\n';
    std::cout<<glbptr->points.size()<<'\n';
}

# [output]
1
2
3
2

基于智能指针的PCL深拷贝与浅拷贝

测试用例来源：测试用例

typedef pcl::PointXYZ MyPoint;
typedef pcl::PointCloud<MyPoint> MyPointCloud;

void func_ptr(MyPointCloud::Ptr pc){
    pc->resize(0);
}

void func_pointcloud(MyPointCloud pc){
    pc.resize(0);
}

void func_ref(MyPointCloud& pc){
    pc.resize(10);
}

MyPointCloud::Ptr pc (new MyPointCloud()), pc2(new MyPointCloud());
MyPointCloud pc3, pc4;
string filename = "/home/zhao/Downloads/csdn_codes-main/pointcloud_copy/mesh.pcd";

用例1：测试上述函数智能指针拷贝传参、值传参和引用传参

pcl::io::loadPCDFile<MyPoint>(filename, *pc);

cout << "------- Test 1. Using Ptr" << endl;
cout<<"before: "<< (*pc).size() << endl;
func_ptr(pc);
cout << "after: " << (*pc).size() << endl;

pcl::io::loadPCDFile<MyPoint>(filename, *pc);
cout << "------- Test 2.1 Using pointcloud but input *ptr" << endl;
cout<<"before: "<< (*pc).size() << endl;
func_pointcloud(*pc);
cout << "after: " << (*pc).size() << endl;

pcl::io::loadPCDFile<MyPoint>(filename, pc3);
cout << "------- Test 2.2 Using pointcloud but input pointcloud" << endl;
cout<<"before: "<< pc3.size() << endl;
func_pointcloud(pc3);
cout << "after: " << pc3.size() << endl;

pcl::io::loadPCDFile<MyPoint>(filename, pc3);
pcl::io::loadPCDFile<MyPoint>(filename, *pc);
cout << "------- Test 3. Using ref pointcloud" << endl;
cout<<"before: "<< (*pc).size() << endl;
func_ref(*pc);
cout << "after: " << (*pc).size() << endl;
cout<<"before: "<< pc3.size() << endl;
func_ref(pc3);
cout << "after: " << pc3.size() << endl;

输出

------- Test 1. Using Ptr
before: 12500
after: 0
------- Test 2.1 Using pointcloud but input *ptr
before: 12500
after: 12500
------- Test 2.2 Using pointcloud but input pointcloud
before: 12500
after: 12500
------- Test 3. Using ref pointcloud
before: 12500
after: 10
before: 12500
after: 10

根据智能指针的operator*操作，*ptr对应的就是值的引用，上述的操作结果很好理解

用例2：智能指针的operator=

pcl::io::loadPCDFile<MyPoint>(filename, *pc);
pc2 = pc;
cout << "Pc2: " << pc2->size() << endl;
pc->resize(0);
cout << "Pc2: " << pc2->size() << endl;
// ---
// Pc2: 12500
// Pc2: 0

pc2 = pc;调用的是shared_ptr的operator=函数，由实现可知pc2和pc指向同一块内存地址，所以操作相互影响，若在这之后调用pcl深拷贝，由于两者指向的是同一地址，所以copyPointCloud后，两者仍相互影响

pcl::copyPointCloud(*pc, *pc2);
cout << "pc2: " << pc2->size() << endl;
pc->resize(0);
cout << "pc2: " << pc2->size() << endl;
// ---
// pc2: 12500
// pc2: 0

用例3：调用copyPointCloud
根据copyPointCloud的实现，其输入src和dst都必须先被分配内存

cout << "================  Copy Function test ================" << endl;
cout << "------- Test 1. Copy *pointer to *pointer" << endl;
pcl::io::loadPCDFile<MyPoint>(filename, *pc);
pcl::copyPointCloud(*pc, *pc2);
cout << "pc2: " << pc2->size() << endl;
pc->resize(0);
cout << "pc2: " << pc2->size() << endl;

cout << "------- Test 2. Copy *pointer to value" << endl;
pcl::io::loadPCDFile<MyPoint>(filename, *pc);
pcl::copyPointCloud(*pc, pc3);
cout << "pc3: " << pc3.size() << endl;
pc->resize(0);
cout << "pc3: " << pc3.size() << endl;

cout << "------- Test 3. Copy value to *pointer" << endl;
pcl::io::loadPCDFile<MyPoint>(filename, pc3);
pcl::copyPointCloud(pc3, *pc);
cout << "pc: " << pc->size() << endl;
pc3.resize(0);
cout << "pc: " << pc->size() << endl;

cout << "------- Test 4. Copy value to value" << endl;
pcl::io::loadPCDFile<MyPoint>(filename, pc3);
pcl::copyPointCloud(pc3, pc4);
cout << "pc4: " << pc4.size() << endl;
pc3.resize(0);
cout << "pc4: " << pc4.size() << endl;

================  Copy Function test ================
------- Test 1. Copy *pointer to *pointer
pc2: 12500
pc2: 12500
------- Test 2. Copy *pointer to value
pc3: 12500
pc3: 12500
------- Test 3. Copy value to *pointer
pc: 12500
pc: 12500
------- Test 4. Copy value to value
pc4: 12500
pc4: 12500

可见copyPointCloud实现的是深拷贝
用例4：PointCloud的operator=
在PointCloud源码中并未单独实现operator=操作，采用默认操作，使用值引用，故为两块内存，互补干扰

cout << "------- Test 2. Copy *pointer to *pointer" << endl;
pcl::io::loadPCDFile<MyPoint>(filename, *pc);
*pc2 = *pc;
cout << "Pc2: " << pc2->size() << endl;
pc->resize(0);
cout << "Pc2: " << pc2->size() << endl;

cout << "------- Test 3. Copy *pointer to value" << endl;
pcl::io::loadPCDFile<MyPoint>(filename, *pc);
pc3 = *pc;
cout << "Pc3: " << pc3.size() << endl;
pc->resize(0);
cout << "Pc3: " << pc3.size() << endl;


cout << "------- Test 4. Copy value to value" << endl;
pcl::io::loadPCDFile<MyPoint>(filename, pc3);
pc4 = pc3;
cout << "Pc4: " << pc3.size() << endl;
pc4.resize(0);
cout << "Pc4: " << pc3.size() << endl;

cout << "------- Test 5. Copy value to *pointer" << endl;
pcl::io::loadPCDFile<MyPoint>(filename, pc3);
*pc = pc3;
cout << "Pc: " << pc->size() << endl;
pc3.resize(0);
cout << "Pc: " << pc->size() << endl;

------- Test 2. Copy *pointer to *pointer
Pc2: 12500
Pc2: 12500
------- Test 3. Copy *pointer to value
Pc3: 12500
Pc3: 12500
------- Test 4. Copy value to value
Pc4: 12500
Pc4: 12500
------- Test 5. Copy value to *pointer
Pc: 12500
Pc: 12500

结果支撑上述结论

m_zhaoguangbao
关注
  • 6
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
PCL点云库必备知识点4——pointcloud2消息格式的转换
qq_41545537的博客
11-03 4396
1 sensor_msgs::PointCloud2ConstPtr与sensor_msgs::PointCloud2的转换 参考链接 sensor_msgs::PointCloud2ConstPtr是一个指针，*sensor_msgs::PointCloud2ConstPtr=sensor_msgs::PointCloud2； 2 convertPointCloud2ToPointCloud 参考链接2 #include <sensor_msgs/PointCloud.h> #include
ros中的::ConstPtr&等用法
RTFSC的博客
03-15 3635
｀｀ void chatterCallback(const std_msgs::String::ConstPtr& msg) { ROS_INFO(“I heard: [%s]”, msg->data.c_str()); } 当消息被转换成 参考：https://answers.ros.org/question/212857/what-is-constptr/
C++总结：C++中的const和constexpr(转)
weixin_30725315的博客
03-25 2684
C++总结：C++中的const和constexpr C++中的const可用于修饰变量、函数，且在不同的地方有着不同的含义，现总结如下。 const的语义 C++中的const的目的是通过编译器来保证对象的常量性，强制编译器将所有可能违背const对象的常量性的操作都视为error。 对象的常量性可以分为两种：物理常量性（即每个bit都不可改变）和逻辑常量性（即对象的表现保持不变）。C+...
【C++】share_ptr详解
最新发布
songbijian的博客
03-26 2041
分析：根据对象生成顺序，先初始化基类 enable_shared_from_this ，再初始化派生类 Frame 对象本身，这时 Frame 对象已经生成，但 _M_weak_this 成员还未被初始化，最后应通过 shared_ptr<T> sp(new T()) 等方式调用 shared_ptr 构造函数（内部会调用 _M_weak_assign 成员函数来初始化 _M_weak_this 成员）。share_ptr 内部中的引用计数是线程安全的，但是引用的资源不是线程安全的。
Beyond the C++ Standard Library: An Introduction to Boost -- Library 1.4 shared_ptr
01-07 2427
shared_ptr头文件: "boost/shared_ptr.hpp"几乎所有稍微复杂点的程序都需要某种形式的引用计数智能指针。这些智能指针让我们不再需要为了控制被两个或多个对象共享的对象的生存期而编写复杂的逻辑。当引用计费降为零，没有对象再需要这个共享的对象，这个对象就自动被销毁了。引用计数智能指针可以分为插入式(intrusive)和非插入式(non-intrusive)两类。
PCL复制点云
com1098247427的博客
10-10 2240
复制点云
浅析Boost智能指针:scoped_ptr shared_ptr weak_ptr
09-05
【Boost智能指针详解：scoped_ptr、shared_ptr与weak_ptr】 智能指针是C++中用来自动管理动态分配内存的对象，它可以确保在适当的时间释放内存，以防止内存泄漏。Boost库提供了一组智能指针类型，包括scoped_ptr、...
JavaScript基础心法 深浅拷贝(浅拷贝和深拷贝)
12-09
前言 说到深浅拷贝，必须先提到的是JavaScript的...浅拷贝的意思就是只复制引用，而未复制真正的值。 const originArray = [1,2,3,4,5]; const originObj = {a:'a',b:'b',c:[1,2,3],d:{dd:'dd'}}; const cloneArray =
ES6变量声明与赋值：值传递、浅拷贝与深拷贝详解
02-24
ES6为我们引入了let与const两种新的变量声明关键字，同时也引入了块作用域；本文首先介绍ES6中常用的三种变量声明方式，然后讨论了JavaScript按值传递的特性以及多种的赋值方式，最后介绍了复合类型拷贝的技巧。在...
C++中的深拷贝与浅拷贝问题
01-08
浅拷贝问题 当用一个类对象去初始化这个类的另一个对象时，如果这个类没有提供拷贝构造函数以及重载=运算符，这时就会发生浅拷贝。如下代码所示 class Name { public: Name(const char *pname) { this->size=...
C++拷贝构造函数(深拷贝与浅拷贝)详解
09-05
深拷贝和浅拷贝是C++中处理对象复制时的两个关键概念，尤其在涉及到动态内存分配的情况。浅拷贝，也称为位拷贝，是指仅仅复制对象的成员变量的值，而不复制底层的资源。这意味着如果类的成员变量包含指针，那么新...
int const *ptr（常量指针）和int * const ptr（指针常量）
Yilia_yu的博客
03-01 1668
int const *ptr（常量指针）和int * const ptr（指针常量）的区分 读法呢，就是谁在前，先读谁 * const 指针常量，const * 常量指针。 const修饰的只有它后面的东西，前面的不相干。 const * ptr常量指针的意思是 ， *ptr是不可变的，也就是指向的地址内容是不能变的，指向的地址是可以变的，那么想要更改内容只能更改指针指向的地址。 * co
无法从“boost::shared_ptr＜pcl::RangeImage＞”转换为“const std::shared_ptr＜const pcl::PointCloud＜pcl::PointWit
Amelie_11的博客
11-23 6240
无法从“boost::shared_ptrpcl::RangeImage”转换为“const std::shared_ptr<const pcl::PointCloudpcl::PointWithRange>” 5.2可视化深度图像 报错： 源码： pcl::visualization::PointCloudColorHandlerCustom<pcl::PointWithRange> range_image_color_handler(range_image_ptr, 0,
【总结】C++：deep copy&shallow copy&智能指针（及：string类和shared_ptr简单实现）
从底层爬
12-23 1706
Ref： https://blog.csdn.net/w_j_f_/article/details/82717894 https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines https://www.cnblogs.com/qionglouyuyu/p/4620714.html（以智能指针为例解释深浅拷贝，string类深浅拷贝...
Pcl::PointCloud和pcl::PointCloud::Ptr类型的转换
lizhengze1117的博客
01-20 6730
pcl::PointCloud 和 pcl::PointCloud::Ptr类型的转换 加了ptr的是指针类型，两者可以互相转换 1.PointCloud::Ptr—&gt;PointCloud pcl::PointCloud&lt;pcl::PointXYZ&gt; cloud; pcl::PointCloud&lt;pcl::PointXYZ&gt;::Ptr cl...
PCL库中的不同点云数据结构之间的转换
qq_36812406的博客
07-03 1290
在使用PCL点云库时，常因为不同的点云数据存储方式不同，而导致在PCL点云库时带来一些麻烦。今天对常见在PCL库的一些点云数据类型之间的转换方式进行历出，方便大家参考。 常见ROS msg,PCLPointCloud2,PointXYZ三种数据类型之间的转换如下： 1.ROS msg to PCLPointCloud2 const sensor_msgs::PointCloud2Con...
error: ‘const class std::shared_ptr＜pcl::PointCloud＜pcl::PointXYZ＞ ＞‘ has no member named ‘__ge
lwf97055143的专栏
09-16 1989
error: 'const class std::shared_ptr' has no member named '__getMD5Sum'
pcl点云库运行错误 boost智能指针出错
bBoy_Stte的博客
12-15 2078
C2439“boost::shared_ptr<pcl::PointCloud>::px 未能初始化成员 在执行区域生长算法之前的法线提取步骤中，用于存储法线提取结果的OutputPointCloud实例化出错，pcl::Norma写成pcl::PointXYZ（出错在第47行），此类错误一般就是boost智能指针初始化出现了问题。 注：本人为pcl入门级小白(是真的很“白”)，由于...
点云库 pcl::PointXYZ pcl::PointCloud＜pcl::PointXYZ＞ pcl::PointCloud＜pcl::PointXYZ＞::Ptr pointCloud区别 持续
uranus1992的博客
11-01 4773
pcl::PointCloud<pcl::PointXYZ> cloud;//点云对象 pcl::PointCloud<pcl::PointXYZ>::Ptr cloudPtr (new pcl::PointCloud<pcl::PointXYZ>);//点云指针对象 pcl::PointXYZ overlapA 点 cloud = * cloudPtr; cloudPtr = cloud.makeShared(); cloud..points[1].x; cl
手写智能指针shared_ptr
08-24
shared_ptr 是 C++ 标准库中的智能指针之一，用于管理动态分配的对象。它可以跟踪对象的引用计数，并在没有引用时自动释放内存。下面是一个手写的简单版本： ```cpp template class shared_ptr { public: shared_...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值