SmartPointer Smar指针

#include<iostream>

using namespace std;

// private class for use by HasPtr only
class U_Ptr
{
    /**
    *因为在这个例子中所有的复制都是复制的“变量的常引用”,所以将U_Ptr这个变量的use增加,其他的HasPtr的use也会跟随着改变,
    *【目标变量一直就只有一个,所有的复制都只是改变指针而已】
    */
    friend class HasPtr;
    int *ip;
    size_t use;
    U_Ptr(int *p): ip(p), use(1) { }
    ~U_Ptr() { delete ip; }
};

/*** smart pointer class: takes ownership of the dynamically allocated
*          object to which it is bound
* User code must dynamically allocate an object to initialize a HasPtr
* and must not delete that object; the HasPtr class will delete it
***/
class HasPtr
{
     public:
         // HasPtr owns the pointer; pmust have been dynamically allocated
         HasPtr(int *p, int i): ptr(new U_Ptr(p)), val(i) { }
         // copy members and increment the use count
         HasPtr(const HasPtr &orig):
                ptr(orig.ptr), val(orig.val) { ++ptr->use; }
         HasPtr& operator=(const HasPtr&);
         // if use count goes to zero, delete the U_Ptr object
         ~HasPtr() { if (--ptr->use == 0) delete ptr; }
     public:
         // copy control and constructors as before
         // accessors must change to fetch value from U_Ptr object
         int *get_ptr() const { return ptr->ip; }
         int get_int() const { return val; }
         // change the appropriate data member
         void set_ptr(int *p) { ptr->ip = p; }
         void set_int(int i) { val = i; }
         // return or change the value pointed to, so ok for const objects
         // Note: *ptr->ip is equivalent to *(ptr->ip)
          int get_ptr_val() const { return *ptr->ip; }
          void set_ptr_val(int i) { *ptr->ip = i; }
          int get_usecount(){return ptr->use;}
     private:
         U_Ptr *ptr;
         // points to use-counted U_Ptr class
         int val;
};

HasPtr& HasPtr::operator=(const HasPtr &rhs)
{
          ++rhs.ptr->use;     // increment use count on rhs first
          if (--ptr->use == 0)
                delete ptr;    // if use count goes to 0 on this object, delete it
          ptr = rhs.ptr;      // copy the U_Ptr object
          val = rhs.val;      // copy the int member
          return *this;
}
int main()
{
    int obj;cout<<"obj="<<obj<<endl;;

HasPtr ptr1(&obj,0);cout<<"usecount1="<<ptr1.get_usecount()<<endl;
    HasPtr ptr2(ptr1);cout<<"usecount1="<<ptr1.get_usecount()<<endl;cout<<"usecount2="<<ptr2.get_usecount()<<endl;
    HasPtr ptr3(ptr1);cout<<"usecount1="<<ptr3.get_usecount()<<endl;cout<<"usecount2="<<ptr2.get_usecount()<<endl;

cout<<"int_A:"<<ptr1.get_int()<<"   int_B:"<<ptr2.get_int()<<"  int_C:"<<ptr3.get_int()<<endl;
    ptr1.set_int(9527); // changes val member only in ptr1
    cout<<"int_A:"<<ptr1.get_int()<<"   int_B:"<<ptr2.get_int()<<"  int_C:"<<ptr3.get_int()<<endl;

cout<<"ptr_val_A:"<<ptr1.get_ptr_val()<<"   ptr_val_B:"<<ptr2.get_ptr_val()<<"  ptr_val_C:"<<ptr3.get_ptr_val()<<endl;
    ptr1.set_ptr_val(123); // sets object to which both ptr1 and ptr2 point
    cout<<"ptr_val_A:"<<ptr1.get_ptr_val()<<"   ptr_val_B:"<<ptr2.get_ptr_val()<<"  ptr_val_C:"<<ptr3.get_ptr_val()<<endl;

cout<<"========================================";
}

时间: 2025-01-15 12:59:56

SmartPointer Smar指针的相关文章

STL(1)---从对-&gt;运算符的重载到灵巧指针再到迭代器

首先->也就是指针间接引用运算符一定是 一个成员函数,必须返回值是一个对象或者对象的引用,或者必须返回一个指针,被用于选择指针间接引用运算符箭头所指的内容 所谓灵巧指针就是一个对象表现的像一个指针,这时候这个指针比一般的指针具有与生俱来的灵巧性,常称作灵巧指针 所谓迭代器就是一个对指针进行封装的结构,通过对指针封装从而对数据结构中的数据进行访问,从而使指针不直接接触数据,既安全有方便用户 #include <iostream> #include<vector> using n

基于引用计数的智能指针

编程语言中实现自动垃圾回收机制方式有好几种,常见的有标记清除,引用计数,分代回收等. C++需要手动管理垃圾,可以自己实现一个智能指针.最简单的是引用计数的思路 template <class T> class SmartPointer { T* obj; unsigned int* count; SmartPointer(T* ptr) { obj = ptr; count = new int; *count = 1; } SmartPointer(SmartPointer &p)

C++中智能指针的设计和使用

转载请标明出处,原文地址:http://blog.csdn.net/hackbuteer1/article/details/7561235      智能指针(smart pointer)是存储指向动态分配(堆)对象指针的类,用于生存期控制,能够确保自动正确的销毁动态分配的对象,防止内存泄露.它的一种通用实现技术是 使用引用计数(reference count).智能指针类将一个计数器与类指向的对象相关联,引用计数跟踪该类有多少个对象共享同一指针.每次创建类的新对象时,初始化指针并将引用计数置为

智能指针的实现--使用引用计数实现以及原理

一.智能指针 在C++语言编程时,当类中有指针成员时,一般有两种方式来管理指针成员:一是采用值型的方式管理,每个类对象都保留一份指针指向的对象的拷贝:另一种更优雅的方式是使用智能指针,从而实现指针指向的对象的共享. 智能指针(smart pointer)的一种通用实现技术是使用引用计数(reference count).智能指针类将一个计数器与类指向的对象相关联,引用计数跟踪该类有多少个对象共享同一指针. 每次创建类的新对象时,初始化指针并将引用计数置为1:当对象作为另一对象的副本而创建时,拷贝

C++11中智能指针的原理、使用、实现

目录 理解智能指针的原理 智能指针的使用 智能指针的设计和实现 1.智能指针的作用 C++程序设计中使用堆内存是非常频繁的操作,堆内存的申请和释放都由程序员自己管理.程序员自己管理堆内存可以提高了程序的效率,但是整体来说堆内存的管理是麻烦的,C++11中引入了智能指针的概念,方便管理堆内存.使用普通指针,容易造成堆内存泄露(忘记释放),二次释放,程序发生异常时内存泄露等问题等,使用智能指针能更好的管理堆内存. 理解智能指针需要从下面三个层次: 从较浅的层面看,智能指针是利用了一种叫做RAII(资

C++ 带有指针成员的类处理方式

在一个类中,如果类没有指针成员,一切方便,因为默认合成的析构函数会自动处理所有的内存.但是如果一个类带了指针成员,那么需要我们自己来写一个析构函数来管理内存.在<<c++ primer>> 中写到,如果一个类需要我们自己写析构函数,那么这个类,也会需要我们自己写拷贝构造函数和拷贝赋值函数. 析构函数: 我们这里定义一个类HasPtr,这个类中包含一个int 类型的指针.然后定义一个析构函数,这个函数打印一句话. HasPtr.h 类的头文件 1 #pragma once 2 #if

【C/C++学院】0904-boost智能指针/boost多线程锁定/哈希库/正则表达式

boost_array_bind_fun_ref Array.cpp #include<boost/array.hpp> #include <iostream> #include <string> using namespace std; using namespace boost; void mainA () { array <int, 5> barray = { 1, 2, 3, 4, 5 }; barray[0] = 10; barray.at(4)

【转】C++面试题(四)——智能指针的原理和实现

C++面试题(四)——智能指针的原理和实现 tanglu2004 http://blog.csdn.net/worldwindjp/   C++面试题(一).(二)和(三)都搞定的话,恭喜你来到这里,这基本就是c++面试题的最后一波了. 1,你知道智能指针吗?智能指针的原理.     2,常用的智能指针.     3,智能指针的实现. 1答案:智能指针是一个类,这个类的构造函数中传入一个普通指针,析构函数中释放传入的指针.智能指针的类都是栈上的对象,所以当函数(或程序)结束时会自动被释放, 2,

C++中的智能指针

众所周知.C++中对堆内存的申请与释放全然由用户来控制,这就造成用户在使用的时候常常造成内存泄漏.野指针.反复释放等常见的挂掉问题,所以我们有必要提供一套机制.使得用户仅仅需申请对应的内存,不用管释放的问题,事实上这属于著名的RAII(Resource Acquisition Is Initialization)技术 .在C++中这样的技术称作"智能指针",C++中的智能指针技术越来越受到广泛应用.以下简要介绍下智能指针. 从以上描写叙述中能够看出,我们须要提供一套内存显式申请与隐式释