标签: reference-counting

我正在实现一个人为的例子,以遵循本教程中的引用计数:

struct Bar
{
    Bar () : refs(1) {}
    int x;
    int y;
    int z;

    unsigned refs;
};

class Foo
{
    public:
        Foo () 
        {
            bar = new Bar;
            bar->x = 5;
            bar->y = 10; 
            bar->z = 15;
        }

        Foo (const Foo &other) : bar(other.bar)
        {
            ++bar->refs;
        }

        Foo& operator = (const Foo &other)
        {
            if (&other != this)
            {
                if (--bar->refs < 1)
                    delete bar;
                bar = other.bar;
                // this would fix it: ++bar->refs;
            }

            return *this; …

我搜索了许多链接并阅读了很多文章,但我找不到确切的区别retain和assign..

我正在尝试以下方法:

NSMutableArray *arr1 = [[NSMutableArray alloc] initWithObjects:@"1",@"2",@"3", nil];
NSMutableArray *arr2=[arr1 retain];
NSMutableArray *arr3 = arr1; //Assign

[arr1 addObject:@"66"];

NSLog(@"Array one   : %@",arr1);
NSLog(@"Array two   : %@",arr2);
NSLog(@"Array three : %@",arr3);

输出:

Array one   : (
    1,
    2,
    3,
    66 
)  

Array two   : (
        1,
        2,
        3,
        66
)  

Array three : (
        1,
        2,
        3,
        66 
)

以上示例给出了相同的输出.

考虑到上面的例子,我如何定义assign和之间的区别retain？

如果以上示例有错,请提供更好的示例提供答案.

在下面的代码中，命名的对象a是它自己的一个属性，它创建了一个引用循环。

class MyClass(object):
     pass

 a = MyClass()
 a.obj = a

如果我当时调用del a，我应该不会摆脱对 的所有引用a，因为 的自引用性质a应该防止它具有非零引用计数。

我不确定为什么引用循环会阻止引用计数变为 0。有人可以向我解释这一点，一步一步吗？

我可以创建Rc零（强）引用吗？这个怎么做？

我正在做参考文献计数有向图。空的有向图将表示为Rc具有零引用的变量。

如果不可能，我可以使用Option<Rc>，但效率低且不方便。

https://en.cppreference.com/w/cpp/memory/shared_ptr/use_count状态：

在多线程环境中，use_count 返回的值是近似值（典型实现使用 memory_order_relaxed 加载）

但这是否意味着use_count()在多线程环境中完全没有用呢？

考虑以下示例，其中该类Circular实现了一个循环缓冲区std::shared_ptr<int>。

向用户提供了一种方法 - ，它检查中元素get()的引用计数是否大于 1（我们不希望这样做，因为这意味着它由先前调用 的用户持有）。nextstd::array<std::shared_ptr<int>>get()

如果是<= 1，则将 的副本std::shared_ptr<int>返回给用户。

在这种情况下，用户是两个线程，除了喜欢调用get()循环缓冲区之外什么都不做——这就是他们的人生目的。

在实践中，当我执行该程序时，它会运行几个周期（通过将 a 添加counter到循环缓冲区类进行测试），然后抛出异常，抱怨下一个元素的引用计数器为> 1。

use_count()这是多线程环境下返回的值是近似值这一说法的结果吗？

是否有可能调整底层机制，使其具有确定性并按照我希望的方式运行？

如果我的想法是正确的 -在 的函数内部，元素use_count()的（或者更确切地说，用户的实际数量）next永远不应该增加到 1 以上，因为只有两个消费者，并且每次线程调用 时，它已经释放了旧的（已复制）（这又意味着剩余的驻留应该只有 1 的引用计数）。get()Circularget()std::shared_ptr<int>std::shared_ptr<int>Circular::ints_

#include <mutex>
#include <array>
#include <memory>
#include <exception>
#include <thread>

class Circular {
    public:
      Circular() {
          for …

如果我们重写 malloc 和 new 函数，我们可以跟踪第一个创建的指针。但是我如何跟踪和计算使用此分配的内存的其他指针和函数？（下面代码中的q指针）我应该覆盖赋值运算符和函数调用吗？如果是的话怎么办？如果解决方案是对类、构造函数和析构函数使用引用计数，我必须将所有普通指针定义​​更改为类类型？我不想更改源代码，只想包含一个库并计算指向已分配内存的指针。

int \xe2\x88\x97 p = (int\xe2\x88\x97)malloc(10 \xe2\x88\x97 sizeof (int));  \nint * q= p;  \n

我一直试图找到Qt的引用计数的实现位置和方式.QBasicAtomicInt和QAtomicInt使用ref()和deref()函数,它们提供有效的引用计数API.这些函数以原子方式递增和递减值,但这些函数在库中实现的位置是什么？我试图了解Qt究竟是如何实现原子引用计数的.谢谢.

我正在实施一个smartpointer模板,有一件事让我感到困惑; 将smartpointer作为参数传递给另一个函数时,如何增加引用计数器？我重载什么操作符来增加引用计数？

例如:

class test
{
   test() {  }
   ~test() {  }
};

void A() 
{
    SmartPointer<test> p;
    B(p);
}

void B(SmartPointer<test> p)
{
    C(p);
}

void C(SmartPointer<test> p)
{
    // p ref count is still 1 and will be destroyed at end of C
}

谢谢

是否可以有2个不同的对象共享相同的参考计数器？

说我有

shared_ptr<Foo> myFoo;
shared_ptr<Bar> myBar;

我希望两个对象都存活,直到有一个对Foo或Bar的引用(所以可能没有人引用Bar,但是因为引用Foo都不会被删除).

SWIFT代码

 override func viewDidLoad() {
            super.viewDidLoad()
            var v1 = ViewController()
            let v2 = ViewController2()
            print("\(CFGetRetainCount(v1)) and \(CFGetRetainCount(v2))")
        }

在Swift引用计数打印为2和2

目标C代码

- (void)viewDidLoad {
    [super viewDidLoad];
    ViewController *v1 = [[ViewController alloc]init];
    ViewController2 *v2 = [[ViewController2 alloc]init];
    NSLog(@"%ld and %ld",CFGetRetainCount((__bridge CFTypeRef)(v1)),CFGetRetainCount((__bridge CFTypeRef)(v2)));
} 

在Objective C中,引用计数打印为1和1

为什么参考计数在目标c和swift中有所不同？

我是 C++ 的新手，正在尝试对 shared_ptr (WIP) 进行非常基本的实现。我试图在通过取消引用找到基础值后立即在析构函数中删除堆分配的指针。虽然取消引用发生得很好，但删除 '''ref_count''' 变量会导致问题。有人可以帮忙吗？'''

#include<iostream>

template<typename T>
class shared_ptr{
 private:
  T* native_ptr_ = nullptr;
  int* ref_count_ = nullptr;

  inline void increment_count() {
    *ref_count_++;
  }

  inline void decrement_count() {
    *ref_count_--;
  }

 public:
  shared_ptr() {
    std::cout << "shared_ptr: empty constructor" << std::endl;
    native_ptr_ = nullptr;
    ref_count_ = nullptr;
  }

  shared_ptr(T* ptr) {
    std::cout << "shared_ptr: constructor" << std::endl;
    if (ptr) {
      native_ptr_ = ptr;
      ref_count_ = new int(1);
    }
  }

  ~shared_ptr() {
    std::cout << "shared_ptr: destructor" << std::endl; …

注意到如何妥善执行在当前Objective-C的引用计数(见这里和这里),我敢肯定,必须有在那里提供类似于C++的东西图书馆shared_ptr和weak_ptr语义没有所有这些荒谬的额外的调用retain,并release应自动调用何时(指针)变量超出范围

这可能在ObjC上吗？我知道ObjC没有析构函数,所以当变量超出范围时,没有办法自动调用,但这些retain/ release调用怎么可能真的有必要呢？我是以错误的方式绕过这个吗？

use_count()使用iteratorde-reference 打印共享指针时,下面的程序输出意外值std::vector:

#include<iostream>
#include<memory>
#include<vector>

class A;

typedef std::shared_ptr<A>            sharedPtr;
typedef std::vector<sharedPtr>        sharedPtrVect;
typedef sharedPtrVect::const_iterator vectItr;

class A
{
  public:
    A(int inp): m_Val(inp) { /*std::cout << "*** A ctor called: " << m_Val << " ***" <<std::endl;*/ }
    ~A() { /*std::cout << "### A dtor called: " << m_Val << " ###" <<std::endl; */}

    int getVal() const { return m_Val; }

  private:
    int m_Val;
};

int main()
{
  sharedPtrVect myVect1, myVect2;
  vectItr myVectItr;
  std::shared_ptr<A> tmpPtr; …