标签: heap

这显然不是看起来像它不会是一个最佳实践.有人可以解释为什么它不是最佳实践或如何工作？任何提供解释的书籍或文章将不胜感激.

//The constructor
public Page_Index() {

    //create a local value
    string currentValue = "This is the FIRST value";

    //use the local variable in a delegate that fires later
    this.Load += delegate(object sender, EventArgs e) {
        Response.Write(currentValue);
    };

    //change it again
    currentValue = "This is the MODIFIED value";

}

输出的值是第二个值"已修改".编译器魔术的哪个部分使这个工作？这跟跟踪堆上的值并稍后再次检索它一样简单吗？

[编辑]:鉴于一些评论,改变原来的一些句子......

我昨天看到了一个问题(对我来说)另一个问题.请看下面的代码:

public class Class1
{
   int A; //as I uderstand, int is value type and therefore lives in the stack
}

class Class2
{
    Run()
   {
       Class1 instance1 = new Class1();
       instance1.A = 10;  //it points to value type, but isnt this reference (on heap)?
   }
}

或者在创建Class1的实例时,它的字段类型也在堆上创建？但后来我不明白什么时候它真的会在堆栈上,因为几乎总是你需要创建一个对象实例才能使用它.

很抱歉这样一个愚蠢的问题,但Python文档令人困惑.

链接1:队列实施 http://docs.python.org/library/queue.html

它说那个队列有一个优先队列的构造.但我找不到如何实现它.

class Queue.PriorityQueue(maxsize=0)

链接2:堆实现 http://docs.python.org/library/heapq.html

在这里,他们说我们可以使用heapq间接实现优先级队列

pq = []                         # list of entries arranged in a heap
entry_finder = {}               # mapping of tasks to entries
REMOVED = '<removed-task>'      # placeholder for a removed task
counter = itertools.count()     # unique sequence count

def add_task(task, priority=0):
    'Add a new task or update the priority of an existing task'
    if task in entry_finder:
        remove_task(task)
    count = next(counter)
    entry = [priority, count, task]
    entry_finder[task] = entry
    heappush(pq, entry)

def remove_task(task): …

Ruby是否在堆上分配所有内容,或者是否有任何存储在堆栈中的实例？我的印象是所有变量基本上都在堆栈上,并且包含对堆上对象的透明引用.我这个想法是否正确？这个实现是否具体？

另外,如果是在堆栈上分配变量并且仅包含隐藏指针的情况,那么变量本身(忽略它们指向的对象)消耗了多少字节？

编辑:

问这个问题是因为我试图弄清楚光纤的4kB堆栈限制是否会成为这个问题的一个问题.似乎(使用MRI 1.9.3)每个变量本身消耗一个字节,并且与光纤相关的开销很小,这使得可用的堆栈大小减少了几个字节.

此代码将在第4,045次迭代时失败:

count = 0
loop do
  count += 1
  puts count
  varlist = String.new
  count.times do |i|
    varlist += "a#{i} = 1\n"
  end
  s = "fiber = Fiber.new do \n #{varlist} \n end \n fiber.resume"
  eval(s)
end

试着在Chrome开发者工具中了解堆分析器.我在快照中看到几个可到达的对象,其中一些有黄色背景,有些没有.这是什么意思？有什么不同？

在这种情况下,颜色图例并不完全有用,因为它本身具有黄色背景(wtf).

我将如何动态分配多维数组？

我看到堆大小会随着应用程序的需要自动增加,直到手机的最大堆大小为止.我还看到最大堆大小因设备而异.

所以我的第一个问题是,Android设备上的典型Max Heap大小是多少？我已经在一部手机上测试了内存分配,该手机能够使用超过40mb的堆,而另一部手机在20的mbs中发出OutOfMemory错误.常用设备中最低的是什么,普通设备上最高的是什么？有标准还是平均？

第二个问题,更重要的一个问题,是如何确保您能够使用每台设备可用的资源,但避免使用太多？我知道有一些方法,比如onLowMemory(),但这些方法似乎只适用于整个系统内存,而不仅仅是特定应用程序的堆.

有没有办法检测设备的最大堆大小,还检测可用堆内存何时达到应用程序的低点？

例如,如果设备仅允许最大堆24mb并且应用程序接近分配的限制,那么它可以检测并缩小.但是,如果设备可以舒适地处理更多,它将能够利用可用的东西.

谢谢

原本就@Als一个pedantics战争回答在这里,它也引发了C++聊天室的讨论.

Herb Sutter的这篇文章区分了两者,但也有十多年的历史,因为它显然是在2000年之前编写的,并且还讨论了标准草案,它只能代表C++ 98草案.尽管如此,作为委员会的一部分,我仍然希望赫伯能够对这些东西有所了解.

我知道这个和这个问题/答案,但第二个引用了Herb的文章,而第一个引用另一个来源,简单地拒绝使用术语"堆",也就是说它们都不完全令人满意.此外,我在SO上找不到任何free-store或freestore标签(直到这个问题,我现在创建了前一个).

现在,真的有什么区别,如果有的话？

与SO上的很多问题和答案相关,我已经了解到最好引用其生命周期被管理为驻留在自动存储而不是堆栈中的对象.

此外,动态分配的对象不应该被称为驻留在堆上,而应该被称为动态存储.

我知道有自动,动态和静态存储,但从来没有真正理解自动堆栈和动态堆之间的区别.为什么前者更受青睐？

我不是在询问堆栈/堆的含义或内存管理的工作原理.我问为什么术语自动/动态存储优于术语堆栈/堆.

我试图做一个最小堆¹的longS IN C++使用STL make_heap等,但我比较似乎并不正确比较.以下是我目前的比较器:

struct greater1{
    bool operator()(const long& a,const long& b) const{
        return a>b;
    }
};

然而,当我std::pop_heap(humble.begin(),humble.end(),g);在那里g是一个实例greater1和humble一个堆谁使[9,15,15,25],当sort_heap被调用时,我得到一个15弹出.

我的比较器是否正确？可能出了什么问题？

编辑:
我意识到我正在运行没有比较器的sort_heap,而当我运行它这个比较器时,我得到[15,15,9,25]了sort_heap.现在我在想我的比较器肯定不起作用,但不确定原因.

¹默认情况下,STL创建一个最大堆,所以我需要一个比较器.