C++常用类 shared_ptr

原创 2015年07月08日 21:18:04

unCopyable类

class unCopyable{
protected:
unCopyable(){}
~unCopyable(){}
private:
 unCopyable(const unCopyable &);
unCopyable & operator=(const unCopyable&);
}
class home :private unCopyable{}

注意上面的基类的protected类型的构造函数和析构函数,子类是private继承。private继承是实现继承。

赋值操作符:

widget & widget::operator=(const  widget& rh){

 if(this == &rh)

return *this;

delete pb;

pb = new Bitmap(*rh.pb);

reruen *this;

}

这种函数虽然考虑了两者相同的情况,但是没有考虑当new操作发生异常时 的情况。当异常是,pb会指向已经释放的内存,导致不确定行为。

更好的方式是

widget & widget::operator=(const  widget& rh){

Bitmap* porig = pb;

pb = new Bitmao(*rh.pb);

delete porig;

return *this;

}

这里即使两者相同,也不会有问题,只不过多做了一次拷贝,对效率有影响。我们可以考虑将判断语句加进去,但是判断语句会使代码变大,产生新的分支流,这两点都会降低CPU的效率。所以我们应该考虑自我赋值的发生频率有多高。

还有一个替代方案是copyandswap技术:

class widget{

private:

void swap(const widget&rh){}

public:

widget & widget::operator=(const  widget& rh){

widget temp (rh);

swap(temp);

return *this;

}

C++定义隐式转换函数

  C++中单参数构造函数若不声明为explict,在合适的场合可以产生隐式转换:由成员变量类型转换为类类型。

  下面的代码展示如何实现反向的转换: 

void changeFontSize(FontHandle f, int newsize);
class Font{
public:
    operator FontHandle() const   //隐式转换函数
    {
        return f;
    }
private:
    FontHandle f;
};

Font f;
int newsize;
changeFontSize(f, newsize);      //将Font隐式转换成FontHandle


 

   另外,两个或更多参数的non-explicit构造函数,如果所有形参都提供了默认实参,那么在需要一个类类型对象的表达式位置,提供一个first形参类型的对象,编译器也执行隐式转换,转换得到一个类对象。

  如,构造函数Rational(int num1 = 0,  int num2 = 1); Rational类中重载了operator*。表达式result = oneHalf * 2; 2发生隐式转换为Rational对象。result 和 onehalf为Rational对象。


隐式转换函数:

class Font{

private: 

FontHandle f;

public :

operator FontHandle() const{//隐式转换

return f;

}

}

void changeFrontSize(FontHandle f ,int size){}

Font font;

int size;

当以Font对象调用changeFrontSize函数时,便会执行隐式转换函数,这样

changeFrontSize(font,size);

用对象管理资源的原因:

因为异常会导致函数未执行完提前返回,所以我们正常的在函数末尾释放资源会因为异常的发生造成内存泄露。所以要才有对象管理资源,当对象离开作用域时,会自动执行其析构函数,这样就会保证资源的释放。

ecplicit关键字

隐式转换可以用explict关键字防止。其主要是防止一个类型的对象转换出另一个新的类型的新对象。

默认构造函数是用于构造对象的,这两个没什么太大关系,将默认构造函数声明为explicit可以防止参数类型对象生成一个类类型的临时对象。


关于C++的shared_ptr,只有在其通过复制构造函数和赋值操作符时,两者的引用计数才和对象持有者相关。从以下两个例子可以看出来:

# include <iostream>
# include <tr1/memory>
using namespace std;
class A {
public:
    A() {
        cout << "construct A!!!" << endl;
    }
    ;
    ~A() {
        cout << "destruct A!!!" << endl;
    }
    ;
};
class B: public A {
public:
    B() {
        cout << "construct B!!!" << endl;
    }
    ;
    ~B() {
        cout << "destruct B!!!" << endl;
    }
    ;
};
int main() {
//  B* ptrB0 = new B();
    B * pint = new B();
    std::tr1::shared_ptr<B> ptrB1(pint);

    std::tr1::shared_ptr<B> ptrB2(ptrB1);

    std::tr1::shared_ptr<B> ptrB3(ptrB1);
    cout << ptrB1.use_count() << endl;
    cout << ptrB2.use_count() << endl;
    cout << ptrB3.use_count() << endl;
}

这个打印出的结果是3

# include <iostream>
# include <tr1/memory>
using namespace std;
class A {
public:
    A() {
        cout << "construct A!!!" << endl;
    }
    ;
    ~A() {
        cout << "destruct A!!!" << endl;
    }
    ;
};
class B: public A {
public:
    B() {
        cout << "construct B!!!" << endl;
    }
    ;
    ~B() {
        cout << "destruct B!!!" << endl;
    }
    ;
};
int main() {
//  B* ptrB0 = new B();
    B * pint = new B();
    std::tr1::shared_ptr<B> ptrB1(pint);

    std::tr1::shared_ptr<B> ptrB2(pint);

    std::tr1::shared_ptr<B> ptrB3(pint);
    cout << ptrB1.use_count() << endl;
    cout << ptrB2.use_count() << endl;
    cout << ptrB3.use_count() << endl;
}

这个的打印结果是1.

这也就说明引用计数和所对应的对象不是强相关的,自我理解应该是这样,当shared_ptr初始化时(通过非同类对象),会申请一块内存进行引用计数。当通过同类对象进行初始化时,就会使用同一块内存,而不是新申请。也就是只有通过赋值操作符和复制构造函数才会使引用计数有效。

定义类时应该考虑的问题:

如果只是想简单的添加机能,首先要考虑是否只定义一个nonmember函数或templates就可以了。
定义一整个class家族的话,就应该定义class template。

对象切割问题:

子类对象以by value传递,并被视为一个基类对象,会导致基类的复制构造函数被调用,而造成此对象的行为像个derived对象的特化性质全部被切掉,仅留下base class 对象

pass by value和pass by const reference

内置类型和stl的迭代器和函数对象都适合传value。这样效率更高。之所以用reference,主要是因为reference高效且能避免切割问题。

non local static 对象的交互问题

当不同文件的nonlocal static对象之间存在依赖关系时,我们可以吧其转换为local static对象,通过在函数中定义static对象,并返回其引用,这样就可以保证在别的对象获取到这个对象时,其已经时初始化过的。
但不论是local还是non local,在多线程下等待某事发生都会有麻烦,处理这种麻烦的一种做法是,在单线程启动阶段手工调用所有reference return函数,这样就可以消除与初始化有关的”竞速形式“。

对封装而言只有private(封装)和其他(不封装)两种访问权限。protected并不比public更具有封装性。


相关文章推荐

C++ Primer : 第十二章 : 动态内存之shared_ptr类

shared_ptr智能指针详解
  • JY_95
  • JY_95
  • 2015年08月21日 08:54
  • 462

C++ Primer : 第十二章 : 动态内存之shared_ptr类实例:StrBlob类

shared_ptr示例
  • JY_95
  • JY_95
  • 2015年08月21日 09:55
  • 1108

C++基础::shared_ptr 编程细节(一)

1. shared_ptr 的两面性(类实例,“指针”) 2. shared_ptr 的一个副作用 3. 以 shared_ptr 类类型为容器类型的容器之间的赋值...

C++ shared_ptr

std::shared_ptr属于STL库,它的作用和auto_ptr相似,也是管理一个对象指针,提供一个释放内存的封装操作,但是它可以和其他shared_ptr对象共享对指针的管理。 它的实现原理...

说说C++智能指针(1): 关于shared_ptr

shared_ptr是新的标准库的一个主要成员,作为一个非嵌入式的智能指针,其设计可谓已经是绞尽脑汁。当然,还有很多人对它提出了不满。没有完美的设计,只有合适的设计。1. shared_ptr最大的特...

Effective C++之std::tr1::shared_ptr的使用

Effective C++之std::tr1::shared_ptr的使用

C++ - "shared_ptr"的使用方法 及 代码

"shared_ptr"的使用方法 及 代码   智能指针(smart pointer)是C++11的新特性. 指针在无人使用时, 自动释放动态内存. 通过"use_count"计数, 并判断是否无人...

C++之智能指针shared_ptr

今天看到Mozilla的SharedPtr.h的实现方式,花了点时间,看懂了,写篇博客,以备记录。 SharedPtr.h中封装的是谷歌的base中的linked_ptr。 主要代码如下: ...

C++ 11智能指针之shared_ptr

 shared_ptr是一个引用计数智能指针,用于共享对象的所有权。它可以从一个裸指针、另一个shared_ptr、一个auto_ptr、或者一个weak_ptr构造。还可以传递第二个参数给sh...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:C++常用类 shared_ptr
举报原因:
原因补充:

(最多只允许输入30个字)