effective c++避免返回handles指向对象内部成分(2)

原创 2015年11月21日 15:03:03
class Point
{
public:
    Point(int _x,int _y):x(_x),y(_y){}
    void setX(int _x){x = _x;}
    void setY(int _y){y = _y;}
    int getX()const{return x;}
    int getY()const{return y;}
private:
    int x,y;
};
class RectData
{
public:
    RectData(Point _ulhc,Point _lrhc):ulhc(_ulhc),lrhc(_lrhc){}
    Point ulhc,lrhc;
};
class Rectangle
{
public:
    Rectangle(Point ul,Point lr):
        pData(new RectData(ul,lr)){}
    const Point& upperLeft()const{return pData -> ulhc;}
    const Point& lowerRight()const{return pData -> lrhc;}
private:
    shared_ptr<RectData>pData;
};
const Rectangle foo(const Rectangle & r){return r;}
int main()
{
    const Rectangle rec(Point(0,0),Point(1,1));
    const Point* p = &(foo(rec).upperLeft());
    //foo函数返回的是一个新的,暂时的rectangle对象,对象没有名字,我们叫他temp
    //语句执行完,temp被销毁,间接导致temo内的points析构
    //导致p指针指向一个不再存在的对象
}

后面又补充了一些shared_ptr的有关学习
但是有些不清楚,为何不需要为Base声明一个virtual析构函数
下面都是从cppreference上面找的
总结:初学一个语法,看文档还是不错的选择,如果想深入学习的话可以上网在博客上找一找

#include <iostream>
#include <memory>
#include <thread>
#include <chrono>
#include <mutex>

struct Base
{
    Base() { std::cout << "  Base::Base()\n"; }
    // Note: non-virtual destructor is OK here
    ///why??
    ~Base() { std::cout << "  Base::~Base()\n"; }
};
struct Derived: public Base
{
    Derived() { std::cout << "  Derived::Derived()\n"; }
    ~Derived() { std::cout << "  Derived::~Derived()\n"; }
};

void thr(std::shared_ptr<Base> p)
{

    std::shared_ptr<Base> lp = p; // thread-safe, even though the
                                  // shared use_count is incremented
    std::this_thread::sleep_for(std::chrono::seconds(1));
    {
      static std::mutex io_mutex;
      std::lock_guard<std::mutex> lk(io_mutex);
      //When a lock_guard object is created, it attempts to take ownership of the mutex it is given.
      //When control leaves the scope in which the lock_guard object was created,
      //the lock_guard is destructed and the mutex is released.
      std::cout << "local pointer in a thread:\n"
                << "  lp.get() = " << lp.get()
                << ", lp.use_count() = " << lp.use_count() << '\n';
    }
}

int main()
{
    std::shared_ptr<Base> p = std::make_shared<Derived>();
    //Constructs an object of type T and wraps it in a std::shared_ptr
    //using args as the parameter list for the constructor of T.
    //template< class T, class... Args >
    //shared_ptr<T> make_shared( Args&&... args );

    std::cout << "Created a shared Derived (as a pointer to Base)\n"
              << "  p.get() = " << p.get()
              << ", p.use_count() = " << p.use_count() << '\n';
    std::thread t1(thr, p), t2(thr, p), t3(thr, p);
    p.reset(); // release ownership from main
    std::cout << "Shared ownership between 3 threads and released\n"
              << "ownership from main:\n"
              << "  p.get() = " << p.get()
              << ", p.use_count() = " << p.use_count() << '\n';
    t1.join(); t2.join(); t3.join();
    std::cout << "All threads completed, the last one deleted Derived\n";
}
版权声明:http://blog.csdn.net/c337134154

条款28:避免返回handles指向对象内部成分

首先说明,在第三版中,这一条款有两处明显的错误: 第一是在124页下面:这立刻带给我们两个教训:第一,成员变量的封装性最多只等于“返回其引用”的函数的访问级别。本例中虽然ulhc和urhc都被声明为...
  • thefutureisour
  • thefutureisour
  • 2012年09月12日 09:52
  • 1181

Effective C++:条款28:避免返回 handles 指向对象内部成员

(一) 有时候为了让一个对象尽量小,可以把数据放在另外一个辅助的struct中,然后再让一个类去指向它。看下面的代码: class Point { public: Point(int x, int ...
  • u010470972
  • u010470972
  • 2014年06月24日 09:48
  • 705

effective c++ 避免返回handles指向对象内部成分

一开始感觉这样 的翻译很别扭,应该是:避免返回指向内部对象的handles。 总结性说法: 避免返回指向内部对象的handles(包括:引用,指针,迭代器)。遵守这个条款可增加封装性,帮助cons...
  • likun_tech
  • likun_tech
  • 2012年03月07日 14:03
  • 336

28 避免返回handles指向对象内部成分——effective c++

这样做有两个问题: a) 降低对象的封装性。把内部结构暴露在外面。 b) 调用const函数,但是仍然可以更改对象。 有一个办法可以解决第二个问题,即返回的handles加上一个const限制,...
  • chgaowei
  • chgaowei
  • 2011年04月08日 21:46
  • 1153

effective c++ 避免返回handles指向对象内部成分(1)

class Point { public: Point(int _x,int _y):x(_x),y(_y){} void setX(int _x){x = _x;} void...
  • c337134154
  • c337134154
  • 2015年11月20日 21:10
  • 372

条款28 避免返回handles指向对象内部成分

/*条款28 避免返回handles指向对象内部成分*/ /*handles: 指针,引用,迭代器*/ //设计一个矩形类,为了对象尽可能小,把点放在一个助的struct 内 #include #in...
  • sbfksmq
  • sbfksmq
  • 2015年09月09日 21:16
  • 165

条款28:避免返回handles指向对象内部成分

结论1:避免返回handles(包括references、指针、迭代器)指向对象内部成分
  • u013540854
  • u013540854
  • 2014年06月08日 19:48
  • 316

条款28:避免返回handles指向对象内部成分

条款28:避免返回handles指向对象内部成分    (Avoid returning "handles" to object internals.)内容:    这里所谓的handles一般包括内...
  • scofieldzhu
  • scofieldzhu
  • 2009年07月01日 16:11
  • 550

避免返回handles指向对象内部内容

References, 指针和迭代器统统都是所谓的handles(号码牌,用来取得某个对象)。 返回handles一方面降低了类的封装性,即令成员函数返回一个访问级别较低的成员;另一方面会造成虽然...
  • hello_qingwen
  • hello_qingwen
  • 2014年03月30日 17:06
  • 407

C++之避免返回handles指向对象内部成分(28)---《Effective C++》

条款28:避免返回handles指向对象内部成分在讨论今天这个条款之前,我们先来看看如下代码:class Point{ public: Point(int x,int y); ... ...
  • u014038273
  • u014038273
  • 2017年07月26日 22:11
  • 100
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:effective c++避免返回handles指向对象内部成分(2)
举报原因:
原因补充:

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