标签: memory-management

public class Concept {    
    int num;    
    public static void main(String args[])    
    {    
        Concept obj1=new Concept();    
        Concept obj2=obj1;    
        obj1.num=100;    
        obj2.num=200;    
        System.out.println(obj1.num);    
        System.out.println(obj2.num);    
        //obj1.num=null;    

        obj2.num=500;    

        System.out.println(obj1.num);    
        System.out.println(obj2.num);    
    }   

}     

在这里,这是一个简单的java程序.

输出是

200
200
500   
500

内存分配如何在这里工作？如何将null设置为Obj1.num = null？

我将在一个文件中给出大约100k坐标.但元素的数量并不固定.我想将它们存储在数据结构中,这将是插入/顺序读取/删除最快的数据结构.而数据结构在循环中顺序迭代.需要移除25%至70%的元素.此外,坐标的顺序很重要.

在这种情况下,在C++中插入/顺序读取/删除的最快数据结构是什么？

#include "stdafx.h"
#include "Cfriend.h"

int _tmain(int argc, _TCHAR* argv[])
{
    std::string * TempName = new std::string;
    std::cout << "Name your friend:\n";
    std::getline (std::cin, TempName);
    Cfriend * MyFriend = new Cfriend();
    return 0;
}

嗨,我是新来的.我正在尝试创建一个简单的过程,玩家可以为其分配名称Cfriend,但问题是它不会让我分配cin给TempName.

我希望能够TempName在完成后立即从内存中删除.

我试图用C++编写代码,从文件读取,一系列点,将其存储在动态数组中,然后打印回来.

这是我给出的规范:

"我们希望利用我们可以使用动态内存的事实,因此我们不是根据我们的估计在开始时分配足够大的内存量,而是实现以下算法:

最初,分配的内存非常少.

在循环的每次迭代中(从文件读取并存储到动态数组中),我们跟踪:

• 数组最大大小(分配的内存).
• 数组中的元素数.

当由于新插入而导致元素数量大于数组最大大小时,内存重新分配需要按如下方式进行:

• 分配另一个具有更大最大大小的动态数组.
• 将前一个数组中的所有元素复制到新数组中.
• 释放为前一个阵列分配的内存区域.
• 获取指向前一个数组的指针以指向新数组.
• 在数组末尾添加新项.这就是我的问题所在.

从我下面的代码中,我认为其他一切都很好但是最后一个要求,即在数组末尾添加新项目.

当数组Max_Size超过文件的元素数时,代码工作正常,但是当我尝试扩展num_elements时,结果是文件中的额外数字只保存为零

.

另外,分配还不允许使用向量.对不起,我忘了提这个,我是stackoverflow的新手,有点编程.

请帮忙

#include <iostream>
#include <fstream>
#include <cstdlib>
using namespace std;

struct point {  
    double x;
    double y;
};

int main () {

    ifstream inputfile;

    inputfile.open("datainput.txt");

    if(!inputfile.is_open()){
    cout << "could not open file" << endl;
        exit(EXIT_FAILURE);
    }

    //initially very little memory is allocated
    int Max_Size = 10;
    int num_elements = 0;
    point *pp = new point[Max_Size];


    //read from file and store in dynamic array …

我的场景是这样的,我有一个从mysql表中获取的巨大数据集

$data = $somearray; //say the number of records in this array is 200000

iam循环这些数据,处理一些功能并将这些数据写入excel文件

 $my_file = 'somefile.csv';
 $handle = fopen($my_file, 'w') or die('Cannot open file:  ' . $my_file); file
     for($i=0;$i<count($data);$i++){
         //do something with the data
         self::someOtherFunctionalities($data[$i]); //just some function    
         fwrite($handle, $data[$i]['index']); //here iam writing this data to a file
      }
 fclose($handle);

我的问题是循环得到内存耗尽...它显示" 致命错误允许内存大小... "无论如何都是在没有耗尽的情况下处理这个循环

由于服务器的限制我无法增加php内存限制

ini_set("memory_limit","2048M");

我不关心它需要的时间..即使它需要几个小时......所以我做了 set_time_limit(0)

我遇到了一些分配代码的问题.该计划基于针对大学生的在线竞赛问题档案.

这是头文件:

#include <iostream>
#include <cmath>
using namespace std;

class Vito
{
public:
    Vito(int relative_count); //constructor
    ~Vito(); //destructor
    int min(); //finds minimum "distance" between vito's relatives

private:
    int *streets; //pointer to array of street numbers
    int sum(int index); //generates sum of distances for each of vito's relatives
    void getStreetNums(); //retrieves street numbers from user
    int relatives; //used globaly to set number of repititions
};

Vito::Vito(int relative_count = 0)
{
    int *streets = new int[relative_count]; //allocates memory for array streets
    relatives …

我想释放一些我没有指针的内存块.在我的计划,我打电话malloc顺序,希望内存中创建的malloc(1),malloc(4),malloc(5)是连续的.然后,当我只有指针时,我释放这些内存malloc(5).但我想不出如何做到这一点; 我不能简单地创建一个引用ptr [-5]地址的指针,然后释放5个字节的内存？如何才能做到这一点？

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

int main(){

    malloc(1);
    malloc(4);
    char* ptr = malloc(5);

    free(ptr);
}

我正在编写一个程序,我必须管理一个字符串数组.在整个程序中,系统地删除/修改字符串,直到只剩下一个字符串.

我使用此函数删除不再需要的字符串:

void remove_element(char **array, int index, int array_length)
{
    int i;
    for(i = index; i < array_length - 1; i++){
        array[i] = array[i + 1];
    }
    free(array[array_length]);
}

一旦我完成了数组,我使用此函数来确保所有字符串都是空闲的:

void free_fragments(char **frags){
    int i = 0;
    while((frags[i] != NULL) && sizeof(frags[i] != 0)){
        free(frags[i]);
        i++;
     }
    free(frags);
}

然而,当我这样做时,valgrind给了我一个"无效的free()/ delete/delete []/realloc()"错误,特别抱怨free_fragments中的"free(frags [i])"行.

我理解free_fragments似乎有点多余,只是因为理论上我可以在每个元素上调用remove_element,直到剩下一个,然后remove_element,但是当我尝试这样做时,我仍然得到一个无效的free()错误,但是这次抱怨remove_element.如果我在完成数组后不调用free_fragments,则会出现内存泄漏.

我对指针的理解非常初学,所以请帮我调试一下并提高我的理解力!

class A            // Normal Class
{  
  static int i;    // Static int variable  
  int j;           // Normal int variable  
}  

假设我即创建了两个对象A1,A2.
两个对象是否为变量i或公共Permgen空间分配了单独的内存

什么尺寸A1,A2？假设假设大小int为2个字节.

许多程序员提倡使用make_shared它,因为它减少了键入并减少了编程错误.然而,在某些情况下使用构造函数shared_ptr是不可避免的.其中一种情况是你有一个你想要拥有的现有指针shared_ptr,因为它shared_ptr<Foo>(&existing_ptr)是错误的代码.相反,你必须使用笨重的shared_ptr<Foo>(shared_ptr<Foo>(), p).你不仅要重复自己,还要创建一个临时对象.

int main()
{
    using namespace std;

    Foo foo;
    foo.n = 1;
    {
        auto ptr = make_shared<Foo>(move(foo));
        ptr->n = 42;
        cout << ptr->n << " " << foo.n << '\n';
    }
    {
        auto p = &foo;
        auto ptr = shared_ptr<Foo>(shared_ptr<Foo>(), p);
        ptr->n = 42;
        cout << ptr->n << " " << foo.n << '\n';
    }

    return 0;
}

Foo::Foo()
Foo::Foo(Foo &&)
42 1
Foo::~Foo()
42 42
Foo::~Foo()

什么是有一个更简洁的方式shared_ptr …