我试图从child_prog() to返回一个数组main()。代码如下所示：
#include<stdio.h>
#include<stdlib.h>
int* child_prog(int some_input);
void main(void){
int C[10];
int some_input;
C = child_prog(some_input);
}
int* child_prog(int some_input){
static int out[10];
// ...
// ... some wizardry
return out;
}
现在编译器生成一个错误，说它不能分配给C（这是一种int[]类型）从child_prog（这是一种int*类型）返回的值。事实上，当我创建C一个int*和malloc它 10ints个内存时，程序运行良好。但我不明白为什么编译器不能分配给C（定义为C[10]指针child_prog的数组）从（定义为static int out[10]指针的数组）返回的值。
假设我们有模板类
template <typename T>
class MyTem{
public:
bool is_T_Pointer(){
<...>
}
};
class Cls : MyTem<Cls>{
<...>
};
int main(void){
Cls* classOnHeap = new Cls(); /* T is pointer */
Cls classOnStack; /* T is not pointer */
<...>
}
我知道这是一个不好的例子，但如果有人能帮我找出 T 是否是来自模板类的指针，那就太好了。
请记住，我们具有与基类相同类的模板的继承。
不必是完整的实现，一个模糊的技术就足够了
可能重复:
在哪些情况下alloca()有用吗？
我最近碰巧看到了alloca()函数的使用.谷歌搜索告诉我,它用于在堆栈上分配空间.我无法抓住申请表吗？此外,使用它有任何陷阱吗？
较新 Rust 版本的更新：以下代码包含已弃用（并已删除）的构造。box x用。。。来代替Box::new(x)。
我正在研究 Rust 的最基本概念，并对上一个问题有一个后续问题：为什么二元 + 运算符不能与两个 &mut int 一起使用？
我想在堆上创建一个int，并将其传递给另一个函数进行修改。
我想出了这个：
fn increment(number: &mut Box<int>) {
**number = **number + **number;
println!("{}", number);
}
fn main() {
let mut test = box 5;
increment(&mut test);
println!("{}", test);
}
这打印
10
10
这就是我想要的。
然而，**看起来很奇怪，我想我也可以写这样的东西：
fn increment(number: &mut int) {
*number = *number + *number;
println!("{}", number);
}
fn main() {
let mut test = box 5;
increment(&mut* test); …我对学习编程语言比较陌生，我觉得我对面向对象编程语言的理解有 20% 到 25%，更具体地说是 C# 语言。所以我真的提出了这个问题，但我不知道它的答案对我学习语言的过程的实际意义（如果有的话），但我真的觉得我有必要提出这个问题。
当一个方法被调用执行时，我知道它的所有局部变量及其参数和返回值实际上都存在于堆栈内存中。而方法本身作为实例化对象或静态类的成员，或作为非静态类的静态成员从堆内存中调用。
现在我的问题是，当该方法被调用到堆栈中时，是只有变量和参数将存在于堆栈中，还是整个方法及其所有代码块都将存在于堆栈中时刻（执行）？
此查询源自对实例化方法（或静态方法）内的代码块性质的类似比较，当该方法被调用时和未被调用时，与成员的性质相比非静态类，而类被实例化为对象，而不是。
现在，非静态类的成员被认为是一个蓝图，即它们以不可接近且无功能的形式存在（不能调用字段和方法，不能更改字段的值，方法不能改变值），但是这个蓝图可以实例化为一个具有其成员的具体功能对象。
现在，如果堆中实例化方法内的代码块只不过是一个蓝图，当方法被调用时，该蓝图实际上会在堆栈中“实例化”，以执行它们在堆栈中的任务，然后被删除任务完成时的堆栈。在这里，栈可以被看作是程序实际执行的地方，而另一方面，堆中的所有东西，包括静态类和对象以及堆本身，都将被看作仅仅是数据和指令的存储位置。不时借用和利用堆栈，堆栈实际上执行了我们整个程序的任务。
但是，如果堆栈内存实际上并不包含正在执行的方法的代码，并且堆栈只获取方法局部变量和参数的临时值，而方法本身在堆中并同时执行编码来自其堆位置的指令，仅将值借给进程中的堆栈。这里的堆栈看起来只是一个变量的值持有者，而对象和静态类及其方法是程序的实际执行者，它们在堆本身中，并且一个实例化的方法（或静态方法）及其代码具体存在并在堆中运行。
第三种可能性是两个内存（堆栈和堆）都不是代码执行的实际位置，而是在处理器本身的某个地方发生数据的执行和更改，堆和堆栈都只是存储位置对于在接受、保存和清理数据和指令方面的不同使用模式，仅此而已。
很抱歉问了这么长的问题，我不知道对我作为程序员的回答有多大帮助，但这确实让我头疼了几天，我在文本中找不到答案是为初学者设计的，所以我真的不知所措！
我专门使用 C++：当我在函数中创建一个对象时，这个对象会保存在堆栈上还是堆上？
我问的原因是因为我需要保存一个指向对象的指针，并且可以创建该对象的唯一位置是在函数内，所以如果我有一个指向该对象的指针并且该方法完成，则该指针可能指向垃圾后。--> 如果我将指向对象的指针添加到列表（它是类的成员）然后方法完成，我可能会让列表中的元素指向垃圾。
所以再次 - 当在方法中创建对象时，它是保存在堆栈中（函数结束后它将无关紧要）还是保存在堆中（因此我可以指向它而不会引起任何问题..） ?
例子：
class blah{
private:
list<*blee> b;
public:
void addBlee() {
blee b;
blee* bp = &b;
list.push_front(bp);
}
}
你可以忽略语法问题——以上只是为了理解概念和困境......
谢谢大家！
当我执行 objdump -x -d name_of_some_c_executable 时，我在任何地方都看不到堆栈或堆段。为什么？
**Clarification**:
objdump is defined as a program for displaying various
information about object files.
我所说的“name_of_some_c_executable”是什么意思：我有一个 name.c，我做 gcc name.c -o name，然后我做 objdump -x -d name。
我在这里读到“允许实现忽略”Common Lisp 中的动态范围声明，我想知道它是否实际上在 CLISP 实现中被忽略了。
我尝试使用以下代码进行测试：
(let ((b (cons 1 2)))
(declare (dynamic-extent b))
(list b))
返回：
((1 . 2))
我的猜测是它被忽略了，但我想确定一下。
另外，如果它被忽略，我有没有办法将内存显式分配给堆栈而不是堆？
我写了一些代码，试图在Free store（堆内存）上创建一个指针。我认为这是不可能的，但无论如何我都尽力了。
下面的代码基本上是在堆上创建一个指针向量，然后使向量中的那些指针指向堆上的一些整数。我想知道向量中称为vec的那些指针是否在堆上？我还想知道在使用这样的向量时释放分配的空间的正确方法是什么。最后一条delete语句使程序崩溃，因此我将其注释掉。我不知道是否有内存泄漏。
vector<int*> *vec = new vector<int*>();
vec->push_back(new int(1));
vec->push_back(new int(2));
vec->push_back(new int(3));
cout << (*vec)[0] << " " << (*(*(vec))[0]) << endl;
cout << (*vec)[1] << " " << (*(*(vec))[1]) << endl;
cout << (*vec)[2] << " " << (*(*(vec))[2]) << endl;
delete (*vec)[0];
delete (*vec)[1];
delete (*vec)[2];
//delete [] vec;
考虑以下代码段，您可以在其中从MyType实例参数获取浮点数（或相应类型）：
void myMethod(MyType floatArgument) {
float myFloat = (float)MyType.Value;
if (myFloat < 100) {
//not meaningfull code
}
}
如果在侦听器中不断调用该方法，或者在物理或图形引擎的更新中不断调用该方法，那么将其设为这样的类变量是否在效率方面会更好？：
private float myFloat
void myMethod(MyType floatArgument) {
myFloat = (float)MyType.Value;
if (myFloat < 100) {
//not meaningfull code
}
}
该变量仅在本地范围内使用，因此每次都会在堆栈中创建 AFAIK。所以从它创建一个类变量会更快，这样即使该变量的内存也会在堆上并且内存消耗会更高，代码会运行得更快。
我知道对于一个浮点数来说可能没什么大不了的，但是把它当作是很多变量或一个大数据类的实例。
这个推理正确吗？