c++ primer 中的 句柄 怎么理解?

[Sou2012]

c++ primer 中的 句柄 怎么理解?

看得不太懂，哪位能举例？

[Sou2012]

[Quote=引用 1 楼 lingyin55 的回复:]
是说这个？
http://topic.csdn.net/u/20080904/09/3b95fa97-26e5-450c-83eb-68009f29fe21.html
[/Quote]

不是这个，

是一个句柄类（包装类）的作用？

[adventurelw]

其实就是使用了计数功能的智能指针类，使你可以比较方便处理动态分配的类型指针（包括实际指向派生类的基类指针，而这也是主要的用途）而不必担心释放内存空间的问题。

[Sou2012]

[Quote=引用 3 楼 adventurelw 的回复:]
其实就是使用了计数功能的智能指针类，使你可以比较方便处理动态分配的类型指针（包括实际指向派生类的基类指针，而这也是主要的用途）而不必担心释放内存空间的问题。
[/Quote]

能举例说明 句柄和智能指针的写法吗，简单点的，呵

[Sou2012]

[Quote=引用 14 楼 fjin_bird 的回复:]
句柄类是真正实现功能的类,而使用句柄类的类更象是个接口类.
[/Quote]

不太理解，有谁能举2个例子吗，一个是不使用句柄的，一个是使用句柄的？

[aaaa3105563]

帮顶··

[Sou2012]

[Quote=引用 5 楼 adventurelw 的回复:]
晕，例子书上有啊，那个个人认为并不复杂

C/C++ code
class Base
{
public:
virtual ~Base();
virtual printf() { std::cout << "Class Base"; }
virtual Base *clone() const { return new Base(*this); }
};

class Derived : public Base
{
public:
printf() { std::cout << "Class Derived"; }
Derived *clone() const { return new Derived(*this); }
};

class Handle
{
…
[/Quote]

程序有错吧

array[0]->printf();

array里放的是 Handle的引用吧，

[ysysbaobei]

顶

[Sou2012]

#include <cstdlib>
#include <iostream>

using namespace std;

class Base {
public:
    virtual ~Base() {};
    virtual void printf() const { std::cout << " Class Base " << std::endl; }
    virtual Base* clone() const { return new Base(*this); }
};

class Derived: public Base {
public:
    void printf() const { std::cout << " Class Derived " << std::endl; }
    Derived* clone() const { return new Derived(*this); }
};

class Handle {
private:
    Base *p;
    std::size_t *count;
    void gc() { if (--*count == 0) { delete p; delete count; } } 
public:
    Handle(): p(0), count(new std::size_t(1)) {}
    Handle(const Handle &h): p(0), count(new std::size_t(1)) {}
    Handle& operator=(const Handle &rhs)
    {
        ++*count;
        gc();
        p = rhs.p;
        count = rhs.count;
        return *this;
    }
    ~Handle() { gc(); }
    Handle(const Base &b): p(b.clone()), count(new std::size_t(1)) {}
    
    const Base& operator*() const { if(p) { return *p; } }
    const Base* operator->() const { if(p) { return p; } }
};

int main(int argc, char *argv[])
{
    Base *b1 = new Base;
    Base *b2 = new Derived;
    
    Handle array[2] = { Handle(*b1), Handle(*b2) };
    
    array[0]->printf();
    array[1].operator->()->printf();
    
    system("PAUSE");
    return EXIT_SUCCESS;
}

[Sou2012]

[Quote=引用 3 楼 adventurelw 的回复:]
其实就是使用了计数功能的智能指针类，使你可以比较方便处理动态分配的类型指针（包括实际指向派生类的基类指针，而这也是主要的用途）而不必担心释放内存空间的问题。
[/Quote]

这些方便，能举例吗，我看不出来，有什么方便的？

[fjin_bird]

句柄类是真正实现功能的类,而使用句柄类的类更象是个接口类.

[Sou2012]

没有人出来说说啊

[crst_zh]

用对象来包装一下，主要是利用对象在出作用域是自动析构这一点
构造和析构自动调用，称对出现
这样就不用担心new和delete匹配的问题，并且，最主要的还是在new和delete之间函数返回的问题。
都不用操心了，你仅仅需要子在需要的时候new就行了。

[findcsdn]

句柄就是对象的ID号。
系统中有一个列表存放系统对象， 需要调用对像功能的时候，就把句柄(ID)传入， 系统根据ID号找到对应的对象，然后做相应处理。
比如closehandle()函数 就是传入一个ID号，然后销毁对应的对象。

调用closehandle时，随便传入数值，可能导致系统崩溃，当然也要看操作权限。

[Sou2012]

谢谢了！

[adventurelw]

晕，例子书上有啊，那个个人认为并不复杂

class Base
{
 public:
     virtual ~Base();
     virtual printf() { std::cout << "Class Base"; }
     virtual Base *clone() const { return new Base(*this); }
};

class Derived : public Base
{
public:
     printf() { std::cout << "Class Derived"; }
     Derived *clone() const { return new Derived(*this); }
};

class Handle
{
private:
   Base *p;
   std::size_t *use;
   void decr_use() { if(--*use == 0) { delete p; delete use; } }
public:
   Handle() : p(0), use(new std::size_t(1)) {}
   Handle(const Base &b) : p(b.clone()), use(new std::size_t(1)) {}
   Handle(const Handle &h) : p(h.p), use(h.use) { ++*use; }
   ~Handle() { decr_use(); }
   Handle &operator =(const Handle &h)
   {
       ++*h.use;
       decr_use();
       p = h.p;
       use = h.use;
       return *this;
   }
   const Base *operator *() const { if(p) return p; }//此处本来应该有异常处理，懒得写了，只要保证指针有确定指向就没有问题
   const Base &operator ->() const { if(p) return *p; }
};

//使用
int main()
{
    Base *b1 = new Base;
    Base *b2 = new Derived;
    Handle array[2] = {Handle(b1), Handle(b2)};
    array[0]->printf();//打印Base内容
    std::cout << std::endl;
    array[1]->printf();//打印Derived内容
    return 0;//无需delete;当然，这个用法很土
}    

[adventurelw]

Handle array[2] = {Handle(b1), Handle(b2)};
这里错了
应该是 Handle array[2] = {Handle(*b1), Handle(*b2)};

[adventurelw]

const Base *operator *() const { if(p) return p; }//此处本来应该有异常处理，懒得写了，只要保证指针有确定指向就没有问题
const Base &operator ->() const { if(p) return *p; }


这里也错了，写得太急，交换一下花括号中的内容
const Base *operator *() const { if(p) return *p; }//此处本来应该有异常处理，懒得写了，只要保证指针有确定指向就没有问题
const Base &operator ->() const { if(p) return p; }

[lpf000]

查一下汉语"句柄" 差不多 就这意思

[fairchild811]

句柄是操作系统在生成对象时分配给对象的唯一标识!
通过句柄可以获取操作系统提供的服务!
句柄不同于指针,如果你得到一个对象的指针,那你就可以在此对象上为所欲为!那操作系统就惨了!于是系统不给你指针,而给你一个加了限制的,用于跟踪对象的指针的标识——句柄!系统使用句柄向外提供服务就相对安全了！
操作系统是通过API提供服务的，对于用户来说，句柄等同于对象指针，但实际上句柄和指针根本不是一回事

[nicky_zs]

一种RAII技术，用于方便管理资源而使用的。你再仔细看看，这个是不难理解的。