例如,如果我要编写此代码:
var t = time_t()
time(&t)
let x = localtime(&t) // returns UnsafeMutablePointer<tm>
println("\(x.memory.tm_hour): \(x.memory.tm_min): \(x.memory.tm_sec)")
......是否还需要做以下事情？
x.destroy()
x.dealloc(1)
或者我们没有分配内存,因此不需要解雇它？
如果我们想象一个函数返回一个UnsafeMutablePointer:
func point() -> UnsafeMutablePointer<String> {
let a = UnsafeMutablePointer<String>.alloc(1)
a.initialize("Hello, world!")
return a
}
调用此函数将导致指向一个永远不会被销毁的对象的指针,除非我们自己做脏工作.
我在这里问的问题是:从一个localtime()呼叫收到的指针有什么不同吗？
模拟器和操场都使我们能够向dealloc(1)返回的指针发送一个调用,但是我们应该这样做还是稍后通过其他方法对返回的指针进行解除分配？
目前我错误地认为我们确实需要销毁和释放.
最后的假设是错误的.我不需要发布,因为我没有创建对象.
我在Apple dev论坛上收到了相同查询的一些答案.
一般来说,你的问题的答案是肯定的.如果你收到一个指向你将负责在C中释放的内存的指针,那么你仍然有责任在从swift调用时释放它... [但]在这种特殊情况下你不需要做任何事情.(JQ)
例程本身为结果维护静态内存,您不需要释放它们.(如果你这样做可能会是一件"坏事")...一般来说,你不知道是否需要释放UnsafePointer所指向的东西....它取决于指针获取其值的位置.(ST)
UnsafePointer的dealloc()与free()不兼容.将alloc()与dealloc()和malloc和co配对.用free().如前所述,您正在调用的函数应该告诉您是否是您对释放结果的响应...只有在指针引用的内存中有非平凡的内容*时才需要destroy(),例如强引用或Swift结构或枚举.一般来说,如果它来自C,你可能不需要销毁()它.(事实上,你可能不应该销毁()它,因为它没有被Swift初始化.)......*"非平凡的内容"并不是官方的Swift术语.我正在使用类比C++概念"平凡可复制"(虽然不一定是"微不足道").(STE)
我现在写了一篇博客文章,概述了关于发布不安全指针的发现和假设,这些指针从StackOverflow,Apple Dev论坛,Twitter和Apple关于分配内存和释放它的旧文档(ARC之前)获取信息.看到这里.
Martin Fowler 有一个Money类,有一个货币分配程序.该例程根据给定的比率列表分配资金,而不会通过舍入而损失任何价值.它会将任何余数值传播到结果上.
例如,由"比率"(1,1,1)分配的100美元将产生(34美元,33美元,33美元).
这是allocate功能:
public long[] allocate(long amount, long[] ratios) {
long total = 0;
for (int i = 0; i < ratios.length; i++) total += ratios[i];
long remainder = amount;
long[] results = new long[ratios.length];
for (int i = 0; i < results.length; i++) {
results[i] = amount * ratios[i] / total;
remainder -= results[i];
}
for (int i = 0; i < remainder; i++) {
results[i]++;
}
return results;
}
(为了这个问题,为了简单起见,我冒昧地用long取代Money类型.)
问题是,我怎么知道它是正确的？除了最终的for-loop之外,这一切似乎都是不言而喻的.我认为,为了证明函数是正确的,在最终的for循环中证明以下关系是正确的就足够了:
remainder < …基本上我想做那样的事情:
int[3] array_func()
{
return {1,1,1};
}
int main(int argc,char * argv[])
{
int[3] point=array_func();
}
但这在C++中似乎不合法.我知道我可以使用向量,但是因为我知道数组的大小是常数,所以似乎可能会发生性能损失.new如果可以的话,我也想避免使用,因为在堆栈上分配东西更容易,也可能提高性能.
这里有什么解决方案？
Linux glibc分配器似乎表现得很奇怪.希望有人可以对此有所了解.这是我的源文件:
first.cpp:
#include <unistd.h>
#include <stdlib.h>
#include <list>
#include <vector>
int main() {
std::list<char*> ptrs;
for(size_t i = 0; i < 50000; ++i) {
ptrs.push_back( new char[1024] );
}
for(size_t i = 0; i < 50000; ++i) {
delete[] ptrs.back();
ptrs.pop_back();
}
ptrs.clear();
sleep(100);
return 0;
}
second.cpp:
#include <unistd.h>
#include <stdlib.h>
#include <list>
int main() {
char** ptrs = new char*[50000];
for(size_t i = 0; i < 50000; ++i) {
ptrs[i] = new char[1024];
}
for(size_t i = …在我allocator通过阅读一些文章
(cppreference和我们内存不足)来研究几天之后,
我对如何控制数据结构以某种方式分配内存感到困惑.
我很确定我误解了一些东西,
所以我将把剩下的问题分成很多部分,以便让我的错误更容易被引用.
这是我(错误)理解的: -
假设这B::generateCs()是一个C从列表中生成列表的函数CPrototype.
在B::generateCs()被使用B()的构造函数: -
class C {/*some trivial code*/};
class CPrototype {/*some trivial code*/};
class B {
public:
std::vector<C> generateCs() {
std::vector<CPrototype> prototypes = getPrototypes();
std::vector<C> result; //#X
for(std::size_t n=0; n < prototypes.size(); n++) {
//construct real object (CPrototype->C)
result.push_back( makeItBorn(prototypes[n]) );
}
return result;
}
std::vector<C> bField; //#Y
B() {
this->bField = generateCs(); //#Y …我正在将一个游戏移植到Android(有很多代码,而且很少是我的),而DalvikVM告诉我(通过LogCat)关于垃圾收集的所有内容.在代码中的某个时刻,我得到了一个"GC释放x对象/ x ms"消息流,基本上告诉我~15万个对象刚被删除,并且它需要一整秒.
我想知道这些来自哪里!我很确定我没有故意创造那么多物品.
那么,有没有办法获得...基本上与该消息相反？在创建任何对象时打印日志消息的东西？
这样我就可以跨过代码,检查生成了多少消息,并查看代码的哪些部分正在生成对象.我怀疑某种形式的对象创建是循环的一部分,但如果可能的话,这将是一种简单的方法来确定.
我正在使用Eclipse 3.4.2,如果这是相关的.
有任何想法吗？
是否有一个Python模块可以让我将非平凡用户类的实例放入共享内存？
我的意思是直接在共享内存中分配,而不是酸洗进出.
multiprocessing.Value并且multiprocessing.Array不适用于我的用例,因为它们似乎只支持原始类型和数组.
到目前为止我唯一发现的是POSH,但它在八年内没有改变.这表明它要么是超稳定的,要么是过时的.在我花时间试图让它发挥作用之前,我想知道是否有其他我尚未发现的替代品.
我只需要在Linux上工作.
如何在函数中为2d数组分配动态内存？我试过这种方式:
int main()
{
int m=4,n=3;
int** arr;
allocate_mem(&arr,n,m);
}
void allocate_mem(int*** arr,int n, int m)
{
*arr=(int**)malloc(n*sizeof(int*));
for(int i=0;i<n;i++)
*arr[i]=(int*)malloc(m*sizeof(int));
}
但它不起作用.
该方法getNextAvailableVm()以循环方式为特定数据中心分配虚拟机.(此方法返回的整数是分配的机器)
在数据中心中,可能存在具有不同配置集的虚拟机.例如 :
5 VMs with 1024 memory
4 VMs with 512 memory
Total : 9 VMs
对于这个数据中心,与具有512内存的机器相比,具有1024内存的机器将获得任务2次.
因此,此数据中心的计算机将通过getNextAvailableVm()以下方式返回:
0 0 1 1 2 2 3 3 4 4 5 6 7 8
这是当前的方式,机器正在返回.但是有一个问题.
可能存在这样的情况:当一台特定的机器繁忙且无法分配任务时.相反,下一台具有最高内存的机器必须分配任务.我无法实现这一点.
例如 :
0 (allotted first time)
0 (to be allotted the second time)
but if 0 is busy..
allot 1 if 1 is not busy
next circle check if 0 is busy
if not busy allot 0 (only when machine …鉴于代码:
class Foo {
std::vector<int> items;
std::map<int, int> dictionary;
};
如果没有任何东西被添加到上面的矢量或地图中,还是会分配一块缓冲存储器吗？(换句话说,缓冲区分配总是在容器创建期间发生,还是可以在调用push_back之类的函数之前推迟？)
是否存在处理初始STL容器缓冲区分配时间的标准,或者是否允许STL容器和编译器之间的行为不同？
注意:这个问题不是关于这样的容器会增加类Foo大小的额外字节.
(这个问题的一个相关子集强调分配大小是C++中向量的初始容量.)