这是析构函数是否足够或者我必须迭代删除新节点？

#include "stdafx.h"  
#include<iostream>  
using namespace std;  
struct node{  
    int row;  
    int col;  
    int value;  
    node* next_in_row;  
    node* next_in_col;  
};  

class MultiLinkedListSparseArray {  
private:  
    char *logfile;  
    node** rowPtr;  
    node** colPtr; // used in constructor  
    node* find_node(node* out);  
    node* ins_node(node* ins,int col);  
    node* in_node(node* ins,node* z);  
    node* get(node* in,int row,int col);  
    bool exist(node* so,int row,int col);  
    //add anything you need
public:  
    MultiLinkedListSparseArray(int rows, int cols);  
    ~MultiLinkedListSparseArray();  
    void setCell(int row, int col, int value);  
    int getCell(int row, int col);  
    void display();  
    void …

Ubuntu 10.10 gcc 4.4.4

我只是在尝试分配和释放.

但是,当一个对象被多次释放时,我试图避免这个问题.

但是,当我测试时,我注意到创建和释放的obj没有返回到null状态.那么有什么条件我可以设置,如果这确实发生将避免？

我也试过在free之后将对象设置为NULL.但是,它仍然试图释放该对象.

这是对这个问题的引用,只是让你知道不重复: 释放已分配的内存

我的代码如下:

#include <stdio.h>
#include "objects.h"

int main(void)
{
    obj_t *obj = NULL;

    obj = create_object();

    destroy_object(obj);

    destroy_object(obj);

    return 0;
}

==

#ifndef OBJECTS_H_INCLUDED
#define OBJECTS_H_INCLUDED

typedef struct Obj_t obj_t;

obj_t* create_object();
void destroy_object(obj_t *obj);

#endif /* OBJECTS_H_INCLUDED */

==

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

#include "objects.h"

struct Obj_t {
    int obj_id;
};

obj_t* create_object()
{
    obj_t *obj = malloc(sizeof obj);

    return obj;
}

void destroy_object(obj_t *obj)
{
    if(obj != NULL) { …

首先,我希望这不是一个公开的.我是一名java程序员,现在改为c ++.在java中你可以这样做

 Object obj = new Object();

根据我的理解,你可以在c ++中做同样的事情(看看java中的obj如何只保存在变量中作为参考),如下所示:

Object* obj = new Object();

我的问题是:这个对象存活了多长时间？只要指针有效,它会活着吗？还有,这可能会成为一个对象的成员初始化吗？如果指针被保存为可变成员(直到你存储它的那个对象是破坏者),那么对象是否会存在？

Srry任何错别字.祝你有美好的一天!

我一直在研究一个简单的光线跟踪器,我遇到了内存不足的问题.我为visual studio下载了Visual Leak Detector,它告诉我以下功能导致内存泄漏.我不知道为什么这些会被认为是泄漏:

Point* Point::copy() {

    Point* result = new Point(x, y, z);

    return result;
}

Point* Point::crossProduct(Point* other) {

    double crossX = y*(*other).getZ() - z*(*other).getY();
    double crossY = z*(*other).getX() - x*(*other).getZ();
    double crossZ = x*(*other).getY() - y*(*other).getX();

    Point* cross = new Point(crossX, crossY, crossZ);

    return cross;
}

注意我在创建和使用此处显示的复制功能后才发现有关复制构造函数的信息.如果我要重做项目,我会使用复制构造函数.现在,当我使用这些函数时,我确保在我正在使用的任何变量上调用"delete".例如:

Point* n = AB.crossProduct(&AC);
...
delete n;

我认为这应该处理任何内存泄漏我错了吗？Visual Leak Detector是否因为它在一个单独的文件中而无法识别泄漏？

我有一个简单的容器类,指向一个抽象类,我有函数来获取/设置容器类中的指针.更具体地说,这个类看起来像这样:

class Container
{
    Abstract* thing;
public:
    void set(Abstract &obj)
    {
        thing = &obj; //danger of dangling pointer
    }

    Abstract* get()
    {
        return thing;
    }
};

Abstract是一个抽象类.可以看出,存在悬挂指针的危险.我知道我可以制作一个对象的副本(新),然后指向它.但我无法创建抽象类的实例.有什么解决方案吗？

以下是更多信息:

类定义

class Abstract
{
public:
    virtual void something() = 0;
};

class Base : public Abstract
{
    int a;
public:
    Base() {}
    Base(int a) : a(a){}
    virtual void something()
    {
        cout << "Base" << endl;
    }
};

class Derived : public Base
{
    int b;
public:
    Derived() {}
    Derived(int a, int …

当运行以下代码时,我得到垃圾输出.我已经调试了足够的数据,以便在我尝试访问时找出错误hobbies[i]->hobby.任何帮助,将不胜感激.我一直想弄清楚发生了几个小时的事情.

int Graph::addUserToHobby(std::string hobby, std::string id){
  int key = ((int)hobby[0] + (int)hobby[1])%HASHMAP_SIZE;
  int collisions = 0;
  while(hobbies[key] != NULL && hobbies[key]->hobby.compare(hobby) != 0 ){
    key++;
    collisions++;
    if(key >= HASHMAP_SIZE){
      key = 0;
    }
  }

  if(hobbies[key] == NULL){
    hobbylist hob;
    hob.hobby = hobby;
    hob.list.push_back(findVertex(id));
    hobbies[key] = &hob;
  }
  else{
    hobbies[key]->list.push_back(findVertex(id));
  }
  return collisions;

}

void Graph::displayHobbies(){

  for(int i=0; i<HASHMAP_SIZE; i++){
    if(hobbies[i] != NULL){
      cout << hobbies[i]->hobby << ": ";
      for(unsigned int j=0; j<hobbies[i]->list.size()-1; j++){
        cout << hobbies[i]->list[j]->name << ", …

对于C ++，有一个类似的，非常受欢迎的问题，但对于Rust，我找不到类似的现有问题。

那么，什么是用例Box，Rc，Ref，RefMut（其他人？）拉斯特？

这个问题的重要部分（对我个人而言）：什么时候应该使用智能指针代替引用？

我知道《锈皮书》非常非常彻底地解释了它，但我希望在主题上有一个简洁明了的“备忘单”，其中可能包含本书中缺少的一些实际示例。

问题

让成员函数返回类型成为您要返回的实际对象的超类的正确方法是什么？

问题

Clang tidy 警告我返回subClassA或subClassB丢弃我对myMethod. 我也没有得到任何输出 - 大概是因为我不小心丢弃了覆盖的myMethod.

编码

#include <iostream>

using namespace std;

class SuperClass {
public :
    SuperClass() {
        cout << "I'm the superclass" << endl;
    };

    virtual std::string myMethod();
};

class SubClassA : public SuperClass {
public:
    SubClassA() : SuperClass() {
        cout << "I'm subclass A" << endl;
    }

    std::string myMethod() override {
        return "A";
    }
};

class SubClassB : public SuperClass {
public:
    SubClassB() : SuperClass() { …

这是关于智能指针（例如唯一指针）的一个很好的答案：什么是智能指针，我应该何时使用？.

这是他们提供的一个示例，作为唯一指针的最简单用法：

void f()
{
    {
       std::unique_ptr<MyObject> ptr(new MyObject(my_constructor_param));
       ptr->DoSomethingUseful();
    } // ptr goes out of scope -- 
      // the MyObject is automatically destroyed.

    // ptr->Oops(); // Compile error: "ptr" not defined
                    // since it is no longer in scope.
}

然而，这引出了一个问题：在这种情况下，目标是简单地删除对象（释放内存），当它超出范围时，唯一指针指向，为什么不把整个对象放在堆栈上呢？ ， 像这样？？

void f()
{
    {
       MyObject myobj(my_constructor_param);
       myobj.DoSomethingUseful();
    } // myobj goes out of scope -- 
      // and is automatically destroyed.

    // myobj.Oops(); // Compile error: "myobj" not defined
                     // since it is no longer …

将shared_ptr复制到数组:是否应该使用它？

根据这篇文章,使用smart_ptr包装数组的好方法是定义一个删除函数,并将删除函数单独传递给带有原始数组的smart_ptr.

我将重构我的代码,比如使用smart_ptr包装原始数组.这是一个例子:

原始代码:

    class MyList{
    public:
       MyList(int size = 0);
       void Resize(int size);
       ~MyList();
    private:
       int* myArray; 
       int* head_;
       size_t size_;
    }

    MyList::MyList(int size){
        myArray = new int[size]; //allocated memory when object is being created 
        head_ = list_;
        size_ = size;
    }

    void MyList::Resize(int size) {
        if (!list_) {
             delete myArray;
             size_ = 0;
        }
        myArray = new int[size];
        head_ = list_;
        size_ = size;
    }

    MyList::~MyList(){
       delete myArray;
       head …

我正在阅读 C++ 中的智能指针，我很惊讶超过 99% 的给定示例实际上是相当糟糕的示例，因为在这些情况下可以避免动态分配。我同意仅在 STL 容器不起作用的上下文中使用智能指针。例如，在动态数组 ( std::vector) 中，性能很重要，因此最好拥有经过良好测试的代码而不使用任何智能指针。

这里我认为是一个不好的例子，因为在这种情况下unique_ptr不是解决方案，但堆栈分配将是正确的方法。

MyObject* ptr = new MyObject(); 
ptr->DoSomething(); 
delete ptr; 

那么什么是 C++ 中智能指针的好例子或用途呢？

换种说法是什么设计模式需要将指针的所有权转移到另一个对象？

请查看以下代码

#include <iostream>

using namespace std;

class Memory
{
private:
    int *memory;

public:
    Memory()
    {
        memory = new int[3];

        for(int i=0;i<3;i++)
        {
            memory[i] = i;
            cout << memory[i] << endl;
        }
    }

    ~Memory()
    {
        delete[] memory;
    }
};

int main()
{
    cout << "Running" << endl;

    Memory m;
    // do I have to invoke ~Memory() ?

    int *secondMemory = new int[5];
    //How to clear the memory of 'secondMemory' ?

    system("pause");
    return 0;


}

在这里,我已经清除memory了类的析构函数中动态分配的数组的内存.但我的问题是

1. 我必须调用~Memory()吗？
2. 如何清除'secondMemory'的记忆？

这些问题在代码的适当位置作为注释询问.请帮忙!

编辑 …

让我们说我的系统有4GB的RAM,某个程序在执行过程中只消耗100 MB的内存,并且运行时间有限,只有30秒.难道你不认为在执行该程序期间根本不释放内存是一个好主意(通过提高性能)吗？无论如何,在该程序终止时,这些100 MB将被释放.