标签: reference-counting

Xcode 4静态分析器将此方法标记为具有过度释放的返回值,而在这种情况下似乎并非如此.

- (id)copyWithZone:(NSZone *)zone
{
    return [[[self class] allocWithZone:zone] initWithURL:self.url postString:self.postString];
}

有一个箭头从return关键字指向它后面的表达式,另一个从该表达式指向分析器警告.这是静态分析:

1. 方法返回具有+1保留计数的Objective-C对象
2. 对象发送-autorelease消息
3. 对象作为拥有引用返回给调用者(传递给调用者的单个保留计数)
4. 对象以+0(非拥有)保留计数返回给调用者
5. 具有+0保留计数的对象返回给调用者,其中预期+1(拥有)保留计数

静态分析仪是否不正确或此代码有问题？

根据要求,-initWithURL:postString:方法:

- (id)initWithURL:(NSURL *)u postString:(NSString *)p
{
    if ( (self = [super init]) ) 
    {
        self.url = u;
        self.postString = p;
    }
    return self;
}

即使在清理和重建项目后,我仍然会收到此警告.

更新:升级到Xcode 4.2后,Xcode静态分析器不再将此标记为问题.

每当我调用我的函数时,每个调用的内存使用量增加大约+ 10M,所以我认为这里有一些内存泄漏.

....
PyObject *pair = PyTuple_New(2), *item = PyList_New(0);

PyTuple_SetItem(pair, 0, PyInt_FromLong(v[j]));

if(v[j] != DISTANCE_MAX && (p[j] || d[0][j])){
  jp=j;
  while(jp!=istart) {
    PyList_Append(item, PyInt_FromLong(jp));
    jp=p[jp];
  }

  PyList_Append(item, PyInt_FromLong(jp));

  PyList_Reverse(item);
}

PyTuple_SetItem(pair, 1, item);

return pair;
....

当我阅读文档时,有些调用就像

void
bug(PyObject *list)
{
    PyObject *item = PyList_GetItem(list, 0);

    PyList_SetItem(list, 1, PyInt_FromLong(0L));
    PyObject_Print(item, stdout, 0); /* BUG! */
}

需要像这样引用引用计数

void
no_bug(PyObject *list)
{
    PyObject *item = PyList_GetItem(list, 0);

    Py_INCREF(item);
    PyList_SetItem(list, 1, PyInt_FromLong(0L));
    PyObject_Print(item, stdout, 0);
    Py_DECREF(item);
}

那么,我应该把Py_INCREF和Py_DECREF放在我的函数上？

我有一个相当大的PHP脚本泄漏内存.我已经能够找出泄漏的对象,但我无法找到脚本泄漏的位置.我的脚本的某些部分是保留对泄漏对象的引用.

有什么方法可以跟踪(并且最好是回溯)PHP对象在哪里/当它的引用计数增加或减少时？

考虑以下向量：

std::vector<std::shared_ptr<X>> myVector;

以及以下两个将给定元素添加到向量的函数：

void foo1(std::shared_ptr<X> x)
{
    myVector.push_back(x);
}

void foo2(const std::shared_ptr<X>& x)
{
    myVector.push_back(x);
}

我的理解是，这两个函数都将 a 推shared_ptr入X向量中，从而增加 的引用计数X。第一个函数导致引用计数的额外递增和递减，但这是不必要的。

我的理解正确吗？那么第二种选择是否更可取呢？

我很好奇,因为我在MSDN上找不到这个.我发现该Release()函数存在于各种COM对象中,我显然应该用它来删除指针.但我不确定它到底是什么回报？我以前认为它会返回剩余对象仍然存在的引用数,因此类似于:

while( pointer->Release() > 0 );

显然会释放对该指针的所有引用？

或者我没有看到什么？

*注意我正在从IDirect3DTexture9::Release()功能的概念谈论这个

我想使用智能指针实现一个简单的引用计数.变量pointer表示存储对象的指针,reference_count表示对象的副本总数.

• 如果我们使用NULL初始化一个对象:reference_count = -1 else reference_count = 1
• copy ctor和operator = increment reference_count
• 析构函数递减reference_count并且如果没有对指向对象的其他引用则执行其删除.

这是我的代码:

#ifndef smart_pointer_H
#define smart_pointer_H

template < typename T > class smart_pointer
{
    private:
        T*    pointer;      
        int reference_count;    

    public:

        smart_pointer() : pointer(0), reference_count(-1) {}

        smart_pointer(T* p) : pointer(p)
        {
            if (p != NULL)
            {
                this->reference_count = 1;
            }

            else
            {
                this->reference_count = -1;
            }
        }

        smart_pointer(const smart_pointer <T> & p) : pointer(p.pointer),     reference_count(p.reference_count + 1) {}
        bool operator == (const smart_pointer <T>& …

我正在使用ctypes从python中使用C库.有一个带有void*参数的回调函数我用作ctypes.py_object.注册回调时,对象指针将提供给库.但是当它不再从python代码引用时,它应该被销毁.我希望它能够存活,直到调用回调函数.我怎么做？

callback_t=ctypes.CFUNCTYPE(None, ctypes.py_object)
clib.register_callback.argtypes=[callback_t, ctypes.py_object]
clib.register_callback.restype=None

class Object:
    def __init__(self, val):
        self.val=val

def callback(obj):
    print(obj.val)

callback_c=callback_t(callback)

def calledByOtherCode(val):
    clib.register_callback(callback_c, Object(val))

似乎MapViewOfFile增加了文件映射内核对象的引用计数.

引自MSDN描述MapViewOfFile:

文件映射对象的映射视图维护对象的内部引用,并且文件映射对象在释放对它的所有引用之前不会关闭.因此,要完全关闭文件映射对象,应用程序必须通过调用UnmapViewOfFile并通过调用并关闭文件映射对象句柄来取消映射文件映射对象的所有映射视图CloseHandle.可以按任何顺序调用这些函数.

此外,从Windows到C/C++,第5版:

上面的代码显示了用于操作内存映射文件的"预期"方法.但是,它没有显示的是,当您调用时,系统会增加文件对象和文件映射对象的使用计数MapViewOfFile...

尽管如此,我的实际测试表明相反.我在Windows 10 64位上使用Visual Studio 2015.测试程序如下:

#include <windows.h>

int main() {
  HANDLE h = CreateFileMappingA(INVALID_HANDLE_VALUE, NULL, PAGE_READWRITE, 0, 128, "test");
  void* p_memory = MapViewOfFile(h, FILE_MAP_WRITE, 0, 0, 0);
  CloseHandle(h);
  h = OpenFileMappingA(FILE_MAP_WRITE, FALSE, "test");
  DWORD dw = GetLastError(); // ERROR_FILE_NOT_FOUND
}

OpenFileMapping呼叫因上一个错误而失败ERROR_FILE_NOT_FOUND.当我取消CloseHandle通话时,一切都会好的.这意味着该CloseHandle调用消除了文件映射内核对象的最后引用计数并将其销毁.这反过来意味着MapViewOfFile实际上不会增加​​对象的引用计数.

我想确定发生了什么,以及MapViewOfFile关于文件映射内核对象的引用计数的确切语义是什么.

看这个例子：

#include <iostream>
#include <memory>

class Foo {
public:
    Foo()  { std::cout << "Foo()\n";  }
    ~Foo() { std::cout << "~Foo()\n"; }
};

int main(){
    auto deleter = [](Foo* p) {
        if(!p) { std::cout << "Calling deleter on nullptr\n"; }
        delete p;
    };

    std::shared_ptr<Foo> foo;
    std::cout << "\nWith non-null Foo:\n";
    foo = std::shared_ptr<Foo>(new Foo, deleter);
    std::cout << "foo is " << (foo ? "not ":"") << "null\n";
    std::cout << "use count=" << foo.use_count() << '\n';
    foo.reset();

    std::cout << "\nWith nullptr and …

我想了解为什么以下似乎在 Rust 中无法正常工作。

我想对一个向量进行分块，并给每个线程一个块来处理它。我尝试使用 Arc 和 Mutex 组合来相互访问我的 vec。

这是我的第一次（明显的）尝试：声明 vec，将其分块，将块发送到每个线程中。根据我的理解，它应该有效，因为 Chunk 方法保证不重叠的块。

use std::sync::{Arc, Mutex};
use std::thread;

fn main() {
    let data = Arc::new(Mutex::new(vec![0;20]));
    let chunk_size = 5;
    let mut threads = vec![];
    let chunks: Vec<&mut [u8]> = data.lock().unwrap().chunks_mut(chunk_size).collect();

    for chunk in chunks.into_iter(){
        threads.push(thread::spawn(move || {
                inside_thread(chunk)
            }));
    }

}
fn inside_thread(chunk: &mut [u8]) {
    // now do something with chunk
}

该错误表明数据不够活跃。愚蠢的我，通过分块，我创建了指向数组的指针，但没有将 Arc 引用传递到线程中。所以我改变了几行，但这没有意义，因为我的线程中有一个未使用的引用！？

for i in 0..data.lock().unwrap().len() / 5 {
        let ref_to_data = data.clone();
        threads.push(thread::spawn(move || { …