我使用Java Stack遇到了一个非常棘手的问题.
Stack<Integer> s=new Stack(), ss=new Stack();
s.push(1024); ss.push(1024);
System.out.println(s.peek());
System.out.println(ss.peek());
System.out.println((s.peek()==ss.peek()));
System.out.println((s.peek()<ss.peek()));
System.out.println((s.peek()<=ss.peek()));
System.out.println((s.peek()!=ss.peek()));
见上面的代码.但为什么输出是这样的？
1024
1024
false
false
true
true
这是Java中的错误吗？有人帮忙....谢谢,凯
我正在研究一个真正简单的堆栈实现,我似乎无法弄清楚为什么我有内存泄漏.我对代码的期望是在push()中分配了5个节点,在displayAndDestroy()中释放了5个节点.但是Valgrind说我已经分配了6个节点的数据并且只释放了5个.我一直在盯着这个,我不确定我哪里出错了.
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
typedef struct STACK{
char data[100];
struct STACK *next;
} stack;
stack *push( stack *oldTop, char *data )
{
stack *newTop = malloc(sizeof(stack));
newTop->next = oldTop;
if(!data){
strcpy(newTop->data, newTop->next->data);
} else{
strcpy(newTop->data, data);
}
return( newTop );
}
void displayAndDestroy( stack *top )
{
stack *currentTop = top;
stack *temp;
int i=0;
while(currentTop){
printf("stack%d: %s\n", i, currentTop->data );
temp = currentTop->next;
free(currentTop);
currentTop = temp;
i++;
}
}
stack *initializer( stack *top, char *fileName …我有类stackLL和pop()函数在main中使用时会创建一个seg错误.这是代码:这是结构和类定义:
struct llNode{
int data;
llNode* next;
};
class stackLL{
public:
stackLL();
void push(int x);
int pop();
void print();
private:
llNode* head;
};
这是成员函数定义:
int stackLL::pop(){
if (head == NULL){
return false;
}
else {
llNode *tmp= new llNode;
cout<<"The integer is: "<<head -> data;
tmp = head;
head = tmp -> next;
delete tmp;
return tmp -> data;
}
}
这是main中的实现:
stackLL sll;
情侣线
sll.pop();
我想知道为什么我不能将一个抽象对象数组初始化到堆栈而不是堆.
这里有一些类似于我的C++代码在最后一行失败了.我主要只是对处理堆与堆栈的问题背后的原因感到好奇.提前致谢!
#define ARRAY_SIZE 10
class Obj {
public:
virtual void fn() =0;
};
class Sub : public Obj {
public:
void fn() {
// ...
}
};
Obj * o1_array[ARRAY_SIZE];
Obj * o2_array = new Obj[ARRAY_SIZE]; // Compiler Error
在GCC C中,有没有办法将数据推送/弹出到C返回堆栈？
我不是在谈论实现自己的堆栈(我知道如何做到这一点); 我的意思是使用现有的C返回堆栈来显式推送/弹出参数(当然,在同一级别的大括号内).
例如,类似于:
extern int bar;
void foo(void) {
PUSH(bar);
bar = 12;
doSomething(); // that depends on the value of bar
bar = POP(); // restore original value of bar
}
如果有任何简单的方法可以做到这一点,我认为这将是一个更明确的替代方案,明确使用像"oldBar"这样的局部变量.
考虑以下程序(请参阅此处的实时演示)
import std.stdio;
class myclass
{
public:
int get_a()
{
return a;
}
private:
int a=3;
}
int main()
{
myclass m; // It should be myclass m=new myclass();
writefln("%d",m.get_a());
return 0;
}
C++支持自动(堆栈分配)和动态(堆分配)对象.但为什么每个类对象必须在D中动态分配？为什么D不支持堆栈分配的对象？
另一个令人惊讶的事情是,ideone编译器错误为:
prog.d(14): Error: null dereference in function _Dmain
但是当我在dmd2编译器上的本地机器上尝试它时,它给了我运行时错误而不是编译时错误.为什么？为什么这个程序的行为有所不同？以下是我在dmd2给出的本地机器上的错误.
object.Error@(0): Access Violation
----------------
0x00402056
0x00405F9B
0x00405EB1
0x00403D93
0x7651EE6C in BaseThreadInitThunk
0x7758377B in RtlInitializeExceptionChain
0x7758374E in RtlInitializeExceptionChain
我试图找出在Common Lisp中清空列表(看作堆栈)的方法.
我想出了这个:
(defun emptystack ()
(dolist (var *stack*) (pop *stack*)))
但它在编译时生成警告(VAR已定义但从未使用过).
然后我认为这样做会更简单:
(setq *stack* nil)
但是,我仍然想知道是否有任何方法像第一个函数那样手动完成,但没有任何未使用的变量.
我曾经有一位教授告诉我,这std::stack通常是使用双链表实现的,如果您只需要访问顶部,这将是多余的.
他的结论是用一个std::vector或一个链表实现的用户定义的堆栈结构可以节省内存空间.
无论哪种方式,我都可能使用STL版本(没有浪费精力),但std::stack真的浪费了这样的记忆吗？
我参加了一个代码编写的面试,我不得不预测代码的输出.
int foo() {
int a;
a = 5;
return a;
}
void main() {
int b;
b = foo();
printf ("The returned value is %d\n", b);
}
答案对我来说是如此明显,我回答了5.但是面试官说答案是不可预测的,因为函数会在返回后从堆栈中弹出.有人可以在此澄清我吗？