相关疑难解决方法(0)

Objective C引入了一项名为ARC的技术,使开发人员免于内存管理的负担.这听起来不错,我认为如果g ++也有这个功能,C++开发人员会非常高兴.

ARC允许您将内存管理的负担放在(Apple LLVM 3.0)编译器上,从不再考虑保留,释放和自动释放

所以,如果LLVM3.0可以做到这一点,我认为g ++也可以让C++开发人员摆脱内存管理的艰巨任务,对吧？

将ARC引入C++有什么困难吗？

我的意思是:如果我们不使用智能指针,我们只使用new/ new[],编译器是否可以为我们做些什么来防止内存泄漏？例如,自动将新指针更改为智能指针？

struct Foo
{
    Foo(int i)
    {
        ptr = new int(i);
    }
    ~Foo()
    {
        delete ptr;
    }
    int* ptr;
};

int main()
{
    {
        Foo a(8);
        Foo b(7);
        a = b;
    }
    //Do other stuff
}

如果我理解正确,编译器将自动为其创建赋值运算符成员函数Foo.但是,这只需要输入ptrin 的值b并将其放入a.a最初分配的内存似乎丢失了.我可以a.~Foo();在进行赋值之前进行调用,但我听说你应该很少需要显式调用析构函数.所以让我们说我编写一个赋值运算符Foo,删除int左操作数的指针,然后将r值赋给l值.像这样:

Foo& operator=(const Foo& other) 
{
    //To handle self-assignment:
    if (this != &other) {
        delete this->ptr;
        this->ptr = other.ptr;
    }
    return *this;
}

但是,如果我这样做,那么当Foo a和Foo …

我std::list<std::string>在我目前的项目中工作.但是有一个与此相关的内存泄漏.所以我分别测试了有问题的代码:

#include <iostream>
#include <string>
#include <list>

class Line {
public:
    Line();
    ~Line();
    std::string* mString;
};

Line::Line() {
    mString = new std::string("XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX");
}

Line::~Line() {
    //mString->clear(); // should not be neccessary
    delete mString;
}

int main(int argc, char** argv)
{
    // no memory leak
    while (1==1) {
        std::string *test = new std::string("XXXXXXXXXXXXXXXXXXXXXXXX");
        delete test;
    }

    // LEAK!
    // This causes a memory overflow, because the string thats added
    // to the list is not deleted when the list …

我这样做:

MyClass myObject = *new MyClass();

但是很多人说我应该这样做:

MyClass *myObject = new MyClass();

是否存在性能差异.或者完全使用第二种方法的逻辑原因？我只是喜欢使用第一种方法摆脱指针混淆.

为了分配动态内存,我一直在C++中使用向量.但是最近,在阅读一些源代码时,我发现使用"new int [size]"并在一些研究中发现它也分配了动态内存.

谁能给我建议哪个更好？我从算法和ICPC的角度来看？

哪个选项是在Visual C++创建(和管理)的线程更好的:C++ 11 std::thread或WinAPI功能(如CreateThread,_beginthreadex等),为什么？

我对C++有点新,到目前为止一直在用Obj-C和Java编程.

说,我有一节课:

class Person {

private:
   Wife *current_wife;
   //.....
};

所以我需要实现一个setter方法来改变Wife实例变量.

像这样:

Person::SetCurrentWife (Wife *new_wife) {

    current_wife = new_wife;
}

这将是一个副本.

所以从主循环或我调用的东西:

Person *some_person = new Person();
...
Wife *wife = new Wife ();
some_person->SetCurrentWife(wife);

所以我很困惑:这里会有内存泄漏吗？我应该在这里或在Person的析构函数中删除妻子对象吗？在Obj-C中,我会释放当前的妻子,然后向上面的妻子对象发送一条保留消息,但在C++中使用setter方法的正确方法是什么？

我有一个构造函数,使用new运算符分配几个内存块.

X::X() {
    a = new int[100];
    b = new char[100];
    c = new float[100];
}

我的问题是,如果分配c失败,并且构造函数抛出异常,将会为内存a和b自动被删除？

据我所知,对于两个向量声明:

//TYPE 1
std::vector<cls> vec;     //cls is user defined datatype(A class)

向量的内存在堆栈上分配,向量中的内容的内存在堆上分配.

以下声明也是如此(如果我错了,请纠正我):

//TYPE 2
std::vector<cls*> vec;    //cls is user defined datatype(A class)

现在,当Type 1中的向量超出范围时,将为存储在其中的对象释放内存.

但是如果我插入如下的元素(假设我有正确的重载构造函数)然后向量超出范围,那么在类型2中会发生什么:

vec.push_back(new cls(5));

我明确地尝试调用clear但是没有调用析构函数.是否会自动释放内存并调用析构函数.如果不是那么如何实现.

此外,如果我将vector声明为vector,那么为向量分配的内存以及内容:

std::vector<cls*> *vec = new std::vector<cls*>;

什么时候需要new在Java中使用关键字.我知道你应该在创建像这样的对象的实例时使用它:

TextView textView = new TextView(this);

有时在代码中我注意到new没有使用,我感到困惑..在这行代码中:

    AssetManager assetManager = getAssets();

为什么不像这样创建AssetManager的实例:

AssetManager assetManager = new AssetManager();

那么它被设置为等于getAssests()？

什么时候应该new使用？

谢谢!