标签: dynamic-memory-allocation

有没有办法posix_memalign std :: vector而不先创建向量的本地实例？我遇到的问题是我需要告诉posix_memalign分配多少空间我不知道怎么说

sizeof(std::vector<type>(n)) 

没有实际创建新的矢量.

谢谢

有没有人在一个大项目中使用了Andrei Alexandrescu的Modern C++ Design中的SmallObjectAllocator？我想实现这个分配器,但在我的项目中使用之前我需要一些关于它的意见.我做了一些测试,看起来非常快,但测试是在一个小的测试环境中进行的.我想知道它是多么快很多小物体(如事件,智能指针等),以及有多少额外的内存,它使用时.

考虑一下代码

auto p = new T( U(std::move(v)) );

然后是初始化器U(std::move(v)).让我们假设T( U(std::move(v)) )不抛出.如果在底层内存分配之后评估初始化程序,则代码是强异常安全的.否则,事实并非如此.如果抛出内存分配,v就已经被移动了.因此,我对内存分配和初始化程序评估之间的相对顺序感兴趣.它是定义的,未指定的,还是什么？

我相信这已经被问了一百万次，但我找不到解释它的答案。有人告诉我永远不要这样做，但我还没有真正理解为什么。为什么这样的事情不算动态分配内存，为什么那么糟糕？

int a;
scanf("%d",&a);
int arr[a];

如果我创建一个保留 1kb 整数数组 int[1024] 的循环，并且我希望它分配 10000 个数组，我可以通过从多个线程运行内存分配来使其更快吗？

我希望它们在堆中。

让我们假设我有一个多核处理器来完成这项工作。

我已经尝试过这个，但它降低了性能。我只是想知道，我只是编写了错误的代码还是我对内存分配不了解？

答案是否取决于操作系统？如果是这样，请告诉我它在不同平台上的工作方式。

编辑：

整数数组分配循环只是一个简化的例子。不要打扰告诉我如何改进它。

是的,另一种realloc与std::vector问题.我知道你要说什么,我同意,忘记手动内存分配,只需使用一个std::vector.不幸的是,我的教授禁止我使用STL的任何东西进行这项任务.

所以,是的,我有一个动态数组,T我需要它可以调整大小,我不能使用std::vector.我可以回到黑暗时代,malloc与家人一起完成整个事情,但如果我可以使用new那将是非常棒的.

我已经阅读了大量的std::vector帖子,其中每个人都说"不,你不能这样做,使用",但它们都是在2011年8月之前发布的,我希望自C +曙光以来可能有所改变的希望+11.那么告诉我,我是幸运的,还是我必须恢复到C风格的内存分配？

我正在从KandR C编程书中做一些有趣的练习.该程序用于从用户输入的一组行中查找最长行,然后打印它.

这是我写的(部分,部分内容直接取自本书): -

#include <stdio.h>
#include <stdlib.h>

int MAXLINE =  10;
int INCREMENT = 10;

void copy(char longest[], char line[]){
    int i=0;

    while((longest[i] = line[i]) != '\0'){
        ++i;
    }
}

int _getline(char s[]){
    int i,c;

    for(i=0; ((c=getchar())!=EOF && c!='\n'); i++){
        if(i == MAXLINE - 1){
            s = (char*)realloc(s,MAXLINE + INCREMENT);

            if(s == NULL){
                printf("%s","Unable to allocate memory");
                //  goto ADDNULL;
                exit(1);
            }

            MAXLINE = MAXLINE + INCREMENT;
        }
        s[i] = c;
    }

    if(c == '\n'){
        s[i] = c;
        ++i; …

我很抱歉问另一个新手问题,但谷歌不能帮助我(或者我可能只是不理解它).

我正在尝试编写一个能够存储一些简单连接数据的类.我的早期概念如下所示:

struct connectionElement{
 string ip;
 SOCKET soc;
};

class ConnectionData{
 private:
  vector<connectionElement> connections;

 public:
  ConnectionData();
  ~ConnectionData();

  void addConnection(string ip, SOCKET soc);
};

void ConnectionData::addConnection(string ip, SOCKET soc) {
 connectionElement newElement;
 newElement.ip = ip;
 newElement.soc = soc;
 connections.push_back(newElement);
 return;
}

现在我已经读过,一旦代码到达范围结束,在不使用new的情况下初始化的对象将被分离.因为我是一个java人,并且不知道shi*关于内存分配,我想知道在addConnection()中初始化新connectionElement的正确方法是什么.

我是否必须使用new来防止数据被删除,或者编译器是否假设以后可能再次访问存储的结构？如果我使用new运算符,我必须在线程终止之前手动删除所有对象,还是自动执行？

该网站上的许多答案都提到delete()调用析构函数。但下面的示例代码似乎delete()在析构函数内部调用。当对象在堆栈和堆中初始化时，delete() 的正确用法是什么？

点击查看来源。

#include <iostream>
using namespace std;
 
class SmartPtr {
    int* ptr; // Actual pointer
public:
    // Constructor: Refer https:// www.geeksforgeeks.org/g-fact-93/
    // for use of explicit keyword
    explicit SmartPtr(int* p = NULL) { ptr = p; }
 
    // Destructor
    ~SmartPtr() { delete (ptr); }
 
    // Overloading dereferencing operator
    int& operator*() { return *ptr; }
};
 
int main()
{
    SmartPtr ptr(new int());
    *ptr = 20;
    cout << *ptr;
 
    // We don't need to call delete ptr: …

下面的代码允许您查看被删除的变量的大小：

#include <iostream>
#include <stdlib.h>
using namespace std;

struct P {
    static void operator delete(void* ptr, std::size_t sz)
    {
        cout << "custom delete for size " << sz <<endl;
        delete (ptr); // ::operator delete(ptr) can also be used
    }
    static void operator delete[](void* ptr, std::size_t sz)
    {
        cout << "custom delete for size " << sz <<endl;
        delete (ptr); // ::operator delete(ptr) can also be used
    }
};

int main()
{
    P* var1 = new P;
    delete var1;

    P* var2 …