是std::array<int,10>(没有我自己使用new)保证在堆栈中分配,而不是由C++ - Standard分配？
要清楚,我不是故意的new std::array<int, 10>.我主要想知道,如果允许标准库new在其实现中使用.
为什么必须动态分配Objective-c对象？为什么我必须使它成为指向对象的指针,与C++不同,我可以在堆栈上创建它们？谢谢.
cocoa objective-c-runtime foundation static-allocation dynamic-allocation
这是我在网上找到的一个小型图书馆:
const char* GetHandStateBrief(const PostFlopState* state)
{
static std::ostringstream out;
// ... rest of the function ...
return out.str().c_str()
}
在我的代码中,我这样做:
const char *d = GetHandStateBrief(&post);
std::cout<< d << std::endl;
现在,起初d包含垃圾.然后我意识到,当函数返回时,我从函数中获取的C字符串将被销毁,因为它std::ostringstream是在堆栈上分配的.所以我补充说:
return strdup( out.str().c_str());
现在我可以从函数中获取我需要的文本.
我有两个问题:
我理解正确吗？
后来我注意到out(类型std::ostringstream)分配了静态存储.这是不是意味着在程序终止之前该对象应该留在内存中？如果是这样,为什么不能访问该字符串？
在C语言中，在小型嵌入式系统上，有什么理由不执行以下操作？
const char * filter_something(const char * original, const int max_length)
{
static char buffer[BUFFER_SIZE];
// Checking inputs for safety omitted
// Copy input to buffer here with appropriate filtering, etc.
return buffer;
}
这本质上是一个实用函数，源是可能已损坏的闪存，我们进行一种“安全复制”以确保我们有一个以空结尾的字符串。我选择使用静态缓冲区并使其对调用者只读。
一位同事告诉我，我这样做在某种程度上不尊重缓冲区的范围，对我来说，这对于我们拥有的用例来说非常有意义。
有理由不这样做吗？
非常感谢所有回复的人。您基本上证实了我对此的想法，对此我深表感谢。我一直在寻找不这样做的主要原因，但我认为没有。澄清几点：
租用/线程安全不是问题。它是一个具有单个运行循环的小型（裸机）嵌入式系统。该代码永远不会从 ISR 中调用。
在这个系统中，我们并不缺乏内存，但我们确实想要非常可预测的行为。出于这个原因，我更喜欢静态地声明这样的对象，尽管它可能有点“浪费”。我们已经遇到了在堆栈上不小心声明的大对象的问题，这导致间歇性崩溃（现已修复，但需要一段时间才能诊断）。所以总的来说，我更喜欢静态分配，只是为了具有非常可预测性、可靠性和下游潜在问题较少。
所以基本上这是针对特定系统设计采取某种方法的情况。
我在阅读这篇文章时看到了这样的内容：“本文假设您至少已经基本了解并理解 GNU/Linux 系统中的内存映射是如何工作的，特别是堆栈中静态分配的内存与堆栈中动态分配的内存之间的区别堆。”
这让我很困惑，因为我认为堆栈和堆是动态分配的，意味着仅在必要时分配，而全局变量和在函数内部声明为“静态”的变量是静态分配的，意味着始终分配。
例如，如果我有
void f() {
int x = 1;
...
}
仅当调用函数 f() 时，值 1 才会被放入堆栈，并且堆栈指针只会递增。同样，如果我有
void f() {
int x = malloc(1 * sizeof(int));
...
}
仅当调用 f() 时才会分配堆内存。但是，如果我有“int x = 1;” 在程序的全局部分或“static int x = 1;” 在函数体内，每当我运行该程序时，该内存都将在数据部分中分配值为 1。
我对这一切有错吗？
c heap-memory dynamic-memory-allocation stack-memory static-allocation
我试图静态分配一些结构,每个结构包含两个成员:一个指向结构数组的指针,以及该数组的大小.
这是代码的工作版本:
#define ARRAY_SIZE(x) (sizeof((x)) / sizeof((x)[0]))
struct conf_element {
char *key;
enum conf_elem_type val_type;
void *val_p;
tok_t *(*fn_p)(const char *js, jsmntok_t *tok);
};
struct conf_schema {
struct conf_element *conf_elems;
size_t size;
};
struct conf_element conf_schema_antennae_elems[] = {
{"key1_nm", LEAF_INT, NULL, NULL},
{"key2_nm", LEAF_INT, NULL, NULL}
};
struct conf_schema conf_schema_antennae = {
conf_schema_antennae_elems,
ARRAY_SIZE(conf_schema_antennae_elems)
};
但是,不是单独定义数组,然后在定义结构时引用该数组,我想用数组文字初始化指针,以便在结构定义中包含它,以便我相信增加可读性:
struct conf_schema conf_schema_antennae = {
(struct conf_element []) {
{"key1_nm", LEAF_INT, NULL, NULL},
{"key2_nm", LEAF_INT, NULL, NULL}
},
/* the size of that ^ …我想在swift中创建一个结构,它具有一个固定数量的小值(例如16个浮点数)作为实例数据.要求此结构不将这些值存储在堆上,以便结构实例的地址是实例变量的地址.还要求这些值可以通过下标在结构内部访问,就像数组一样.
在C中,你只需简单地定义这种东西:
struct Matrix4x4 {
float elements[16];
...
} myMatrix;
使用此代码,sizeof(Matrix4x4) == 64以及&myMatrix == &myMatrix.elements[0]; 在Swift中,如果我类似地将elements变量定义为类型[Float],则矩阵实例仅包含指向数组的指针,因为Array<Float>实例是存储在堆上的对象.
有没有办法在swift中获得实例变量的静态分配而不放弃类似数组的下标访问的便利性和效率？
我写了以下代码:
int tester(int n)
{
int arr[n];
// ...
}
这段代码使用g ++编译,没有警告.
我的问题是 - 如何？参数n在运行时是已知的,在数组中是静态分配的.gcc是如何编译的？
我正在分配一个相当大的,大约100GB的内存块.确切的大小在编译时始终是已知的.
我应该静态分配吗？
static char data[DATA_SIZE];
还是使用mmap？
data = mmap(NULL, DATA_SIZE, PROT_READ|PROT_WRITE, MAP_ANONYMOUS|MAP_PRIVATE|MAP_LOCKED|MAP_UNINITIALIZED, -1, 0)
对于前者,应用程序(忽略启动时间)似乎运行速度略快.
忽略失败的分配,每种方法的优缺点是什么？
我知道这个答案违反了reinterpret_cast规则,但它也假设子阵列将被线性分配.
我相信这不能保证,但是当我搜索标准时,我发现我的信心摇摆不定.如果我静态分配2D数组,如下所示:
int foo[][4] = { { 5, 7, 8 },
{ 6, 6 },
{},
{ 5, 6, 8, 9 } };
我可以假设所有元素都将线性分配吗？也就是说,如果foo[0]是在地址0x00000042,将:
foo[1] 在地址0x00000052foo[2] 在地址0x00000062foo[3] 在地址0x00000072这些地址是十六进制的,是的,它们为4元素子阵列提供了空间sizeof(int) == 4; 它们可能也可能不是零初始化.
我知道可以增加动态分配的数组的大小.
但是我可以增加静态分配数组的大小吗？如果有,怎么样？
编辑:虽然这个问题是针对C语言的,但也要考虑其他语言.是否可以使用任何其他语言？
假设我们有以下代码：
void foo() {
char buffer[100];
}
在foo（）返回之前，C语言中是否有一种（最好是可移植的）方式从运行时堆栈中释放缓冲区（又称添加esp，在程序集中为100 ）？
c memory-management local-variables static-allocation stack-pointer