亲子关系所有权的推荐模式

我是c++的新手，我试图理解引用计数内存。在下面的代码中，我有两个方法来返回矩形向量

vector<RectangleRef> &rectanglesRef() { return rects_; }
vector<RectangleRef> rectangles() { return rects_; }

我不确定的是，如果他们中的任何一个在堆栈上为调用者创建一个新的向量?

当ClassA在一个向量中包含许多ClassB时，您希望能够公开的推荐模式是什么?

void addRectangle(RectangleRef r) { rects_.push_back(r); }
void removeRectangle(RectangleRef r);
vector<RectangleRef> rectangles() { return rects_; }

或者你只是让调用者访问内部结构并允许他们随意添加/删除东西?

如果Rectangle类要保留指向它所属的Test类的回指针，则使用

typedef std::weak_ptr<Test> TestWeakRef;
...
TestWeakRef test_;

正确的成语?

谢谢你的帮助。

代码:

#include <iostream>
#include <limits>
#include <vector>
using namespace std;
class Point {
public:
    Point() {
        x_ = 0.0;
        y_ = 0.0;
    }
    Point(double x, double y) {
        x_ = x;
        y_ = y;
    }
    double x() const { return x_; }
    double y() const { return y_; }
    void setX(double x) { x_ = x; }
    void setY(double y) { y_ = y; }
    void offset(double dx, double dy) {
        setX(x() + dx);
        setY(y() + dy);
    }
    bool operator == (Point const &point) {
        return x() == point.x() && y() == point.y();
    }
    void operator = (Point const &point) {
        setX(point.x());
        setY(point.y());
    }
private:
    double x_;
    double y_;
};

class Size {
public:
    Size() {
        width_ = 0.0;
        height_ = 0.0;
    }
    Size(double width, double height) {
        width_ = width;
        height_ = height;
    }
    double width() const { return width_; }
    double height() const { return height_; }
    double area() const { return width() * height(); }
    void setWidth(double width) { width_ = width; }
    void setHeight(double height) { height_ = height; }
private:
    double width_, height_;
};
class Rectangle {
public:
    Rectangle() {
        origin_ = Point();
        size_ = Size();
    }
    Rectangle(double x, double y, double width, double height) {
        origin_ = Point(x, y);
        size_ = Size(width, height);
    }
    Point origin() const { return origin_; }
    Size size() const { return size_; }
private:
    Point origin_;
    Size size_;
};
typedef std::shared_ptr<Rectangle> RectangleRef;
typedef std::weak_ptr<Rectangle> RectangleWeakRef;
class Test {
private:
    vector<RectangleRef> rects_;
public:
    Test() {
        rects_ = vector<RectangleRef>();
        for (int i = 0; i < 100; i++) {
            RectangleRef ptr = make_shared<Rectangle>(i*1.0, 0.0, 1.0, 1.0);
            rects_.push_back(ptr);
        }
    }
    vector<RectangleRef> &rectanglesRef() { return rects_; }
    vector<RectangleRef> rectangles() { return rects_; }
};
int main(int argc, const char * argv[]) {
    vector<RectangleRef> r;
    vector<RectangleRef> r1;
    if (true) {
        Test t = Test();
        r = t.rectangles();
        r1 = t.rectanglesRef();
        if (r1 == r) { cout << "they matchn"; }
    }
    // insert code here...
    //std::cout << r->origin().x() << "n";
    return 0;
}