据我所知,在Java中,堆栈内存保存原语和方法调用,堆内存用于存储对象。
假设我有一堂课
class A {
int a ;
String b;
//getters and setters
}
类a中的原语A将存储在哪里?
为什么堆内存存在?为什么我们不能把所有东西都存储在堆栈上呢?
当该对象被垃圾收集时,与所反对的对象关联的堆栈是否被销毁?
如果运行以下代码,会发生什么情况..
while (true) {
String x = new String("ABC");
}
在记忆力方面?
字符串x是在堆栈上还是在堆上分配的?程序最终会不会因为内存溢出而崩溃,或者垃圾收集会阻止它吗?new关键字总是在堆上创建对象吗?什么时候在堆栈上创建对象?
谢谢!
我昨天看到一个问题,它(对我)提出了另一个问题。请看下面的代码:
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)?
}
我有一些fortran代码,看起来像这样:
subroutine foo(mx,my,mz)
real pts(3,mx,my,mz)
end
子例程中实际上从未使用过数组pts --我只是在重构代码时忘了删除它。现在,由于fortran没有堆栈和堆的概念,这取决于编译器在哪里分配‘t-这是gfortran中数组大小的函数,但我还不能弄清楚portland组编译器是如何处理这个问题的。
有没有可能知道it是在堆栈、堆上分配的,还是完全优化出来的(可能是这样的)?有没有可能在不知道堆栈溢出的情况下(也就是没有运行时错误)?我的直觉是,应该可以通过查看编译器生成的程序集来判断,但我不知
我正在开发一个使用XNA和C#的游戏,并试图避免调用每一帧的new struct()类型代码,因为我认为这会吓坏GC。“等等,”我对自己说,"struct是一种值类型。GC不应该被调用,对吧?“好吧,这就是为什么我在这里问。
对于值类型会发生什么,我只有一个非常模糊的概念。如果我在函数调用中创建了一个新的结构,那么该结构是在堆栈上创建的吗?它会被简单地推送和弹出,而性能不会受到影响吗?此外,如果我需要在一次调用中创建多个实例,是否会有一些内存限制或性能影响?
以下面的代码为例:
spriteBatch.Draw(tex, new Rectangle(x, y, width, heigh
我正在createString()函数中创建一个String对象并返回对它的引用。当我打印在hashCode中创建的对象和返回到main方法的对象时,引用指向同一个对象。我的问题是-
在createString()函数堆栈中创建的对象在main方法中超出作用域,那么为什么要从main方法访问它呢?
import java.util.*;
public class Temp {
public static void main(String[] args) {
Temp temp = new Temp().createString();
System.out.pri
我读过,只有原语存储在堆栈内存中,对象存储在堆内存中。在下面的程序中,我递归地调用一个方法,在发生堆栈溢出错误之前检查最大堆栈大小。
public class MaxStackSize {
static int i =0;
public static void main(String[] args) {
method1();
}
public static void method1()
{
i++;
System.out.println(i);
method1();
}
}
这里'i‘的最大输出是53481。
如果我将HashSet对象添加到该方法并填
在研究链接列表实现时,我需要弄清楚引用和对象是如何存储在堆栈和堆中的,在这种场景中,它自己拥有引用,
public class MyLinkedList {
private Node head;
private int listCount;
public MyLinkedList() {
head = new Node("0");
listCount = 0;
}
public void add(Object data) {
Node nodeTemp = new Node(data)
与堆相比,我对堆栈的了解是非常基本的,但是当涉及到数组时,据我所知,这样的东西是在堆栈上创建的。
float x[100];
而像这样的东西是在堆上创建的。
float* x = new float[100];
但是,如果我创建一个模板数组类并以“堆栈”数组类型(比如float[100])传递它,会发生什么呢?示例:
#include <iostream>
using namespace std;
template <class T>
class Array {
public:
int size;
T* data;
Array(int si
请看下面的简单代码。d是堆栈上指向堆上demo对象的指针。该对象包含val。这在类的上下文中看起来是一个堆栈变量,但对象是在堆上分配的。。。。那么val到底在哪里呢?
class demo
{
int val;
public:
demo() : val(5) {};
};
demo* d = new demo();
假设我有一个类,它有两个公共静态方法,它们控制它的一个私有实例。该类的基本结构如下:
public class MyClass {
private static MyClass myclass = null;
private final Process, OutputStreamWriter, Strings, ints, etc....
private class constructor....
private class methods....
public static void command(String cmd)
我们知道委托是指函数的引用类型。
using System;
namespace Testing_Delegates
{
class Program
{
delegate void fun_delegate();
fun_delegate response;
static void Main(string[] args)
{
Program p = new Program();
p.fun();//Calling function directly
p.response += p.fun;//Setting
如果我是正确的,本地定义的基本数据类型将在堆栈上。但是,如果将基元数据类型定义为on对象实例的一部分,则该基元将位于堆上。
class Test
{
int y=10; // defined as part of the class
public void function1(){
int x = 5; // defined locally
}
public static void main(String[] args)
{
Test obj = new Test();
}
}
那么,在上面的代码中,x会存
我按照下面的代码做了一个对象初始化:
namespace PatternPractice
{
public class TestClass
{
private DecoratorClass decoratorClass;
public TestClass()
{
}
public void addTest()
{
decoratorClass = new DecoratorClass();
testMethod(decoratorClass);
}
public void testMeth
我想知道在动态创建2d数组时分配了多少大小 假设我在c++中动态创建一个一维数组,结果如下所示 int* p = new int[10]; 这意味着堆内存中有40字节,栈内存中有8字节(根据我的编译器),但我很困惑,如果我将2d数组设为(对于10*10 2d数组),将分配多少内存 int** p = new int*[10];
for(int i = 0; i < 10; i++) {
p[i] = new int[10];
} 我的堆栈和堆中将分配多少内存,它在堆栈中是80字节,在堆中是400字节或其他什么
下面是我为合并两个链接列表(MergeTwoLists(ListNode list1, ListNode list2))而编写的方法。以下是整个计划:
using System;
using System.Collections.Generic;
using System.Collections;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace LinkedList
{
public class ListNode
{
public int val;