相关疑难解决方法(0)

我一直在使用C++,我一直在想新的关键字.简单地说,我应该使用它吗？

1)使用新关键字...

MyClass* myClass = new MyClass();
myClass->MyField = "Hello world!";

2)没有新的关键字......

MyClass myClass;
myClass.MyField = "Hello world!";

从实现的角度来看,它们看起来并没有什么不同(但我确定它们是......)但是,我的主要语言是C#,当然第一种方法就是我习惯的方法.

困难似乎是方法1更难用于std C++类.

我应该使用哪种方法？

更新1:

我最近使用new关键字作为堆内存(或免费存储)用于超出范围的大型数组(即从函数返回).在我使用堆栈之前,导致一半的元素在范围之外被破坏,切换到堆使用确保元素是完整的.好极了!

更新2:

我的一位朋友最近告诉我,使用new关键字有一个简单的规则; 每次打字new,输入delete.

Foobar *foobar = new Foobar();
delete foobar; // TODO: Move this to the right place.

这有助于防止内存泄漏,因为您总是必须将删除放在某处(即,当您将其剪切并粘贴到析构函数或其他方式时).

可能重复:
为什么你想要在堆而不是堆栈上分配内存？

Test2 *t2 = new Test2();
t2->test();

Test2 t3;
t3.test();

为什么我要创建Test2类型的指针对象？为什么不做Test2的非指针版本？我为什么要做指针对象？

在这里找到答案:

• 为什么你想要在堆而不是堆栈上分配内存？
• 何时最好使用堆栈而不是堆,反之亦然？
• 何时使用"new"而何时不使用C++？
• 我什么时候应该在C++中使用new关键字？
• 在C++中适当的堆栈和堆使用
• C++中的堆栈,静态和堆

我认为在重新分配动态分配的指针时,我们都理解删除的必要性,以防止内存泄漏.但是,我很好奇,C++在多大程度上强制要求使用delete？例如,采取以下计划

int main()
{
     int* arr = new int[5];
     return 0;
}

虽然所有意图和目的都没有发生泄漏(因为你的程序结束了,操作系统会在它返回后清理所有内存),但标准是否还需要 - 或建议 - 在这种情况下使用delete [] ？如果没有,还有其他原因你会在这里删除[]吗？

#include <iostream>

struct person_t{
        int age;
};

person_t get_person1(){
        person_t person;
        person.age = 10;
        return person;
}

person_t * get_person2(){
        person_t *person = new person_t;
        person->age = 20;
        return person;
}

int main(){
        person_t person1 = get_person1();
        person_t *person2 = get_person2();
        std::cout << person1.age << std::endl;
        std::cout << person2->age << std::endl;
        delete person2;
        return 0;
}

我想知道从函数返回结构的最安全的方法是什么.

正如在这里和这里的问题的答案中所说,当你创建一个对象时get_person1(),该对象将在它超出范围之后被销毁.

但是当我搜索"如何从函数c ++返回一个结构"时,它建议我使用方法一(带有get_person1())(这里的例子).但我认为该方法会在调用函数后销毁对象,我认为方法2是最安全的.

我错了吗？或者关于这个话题的任何意见..？

谢谢!!

我刚刚在C++上重读了一些代码(我现在正在学校学习Java),而且当我必须使用删除时,我有点困惑.

例如:声明两个对象时:

Fraction* f1;
Fraction* f2;

并像这样创建f1和f2:

f1 = new Fraction(user_input1, user_input2);
f2 = new Fraction(user_input3, user_input4);

下次我想使用newoperator创建一个新对象时,是否必须先删除？我很困惑,因为我习惯在java中使用垃圾收集器来处理对象及其删除.在重新使用新内容之前是否必须删除？

if (f1) delete f1;

if (f2) delete f2;

//initialize again...

我觉得这应该很简单但无论出于什么原因我都无法让它发挥作用.

我正在尝试创建一个类的实例,可以传递给其他函数并直接编辑.

例如:

main()
{
    ClassFoo foo = new ClassFoo();
    someFunction(foo);
}

void someFunction(ClassFoo& f)
{
    f.add("bar");
}

问题是,在编译时,我最终会遇到此错误.

no viable conversion from 'ClassFoo *' to 'ClassFoo'
    ClassFoo foo = new ClassFoo();
             ^    ~~~~~~~~~~~~~~~

它还说其他候选构造函数不可行,但是在我的ClassFoo类中我确实有一个如下所示的构造函数:

ClassFoo::ClassFoo()
{}

那么我怎样才能ClassFoo在函数中完成变量的编辑？

可能的重复:
在C++中何时使用"new"和何时不使用？
我什么时候应该在C++中使用new关键字？

似乎我可以在没有使用这个词的情况下编程new,我也不必担心删除任何东西,所以我为什么要调用它？

根据我的理解,这是因为我会耗尽堆栈内存.

它是否正确？我想我的主要问题是,我该new什么时候打电话？

可能的重复:
在C++中何时使用"new"和何时不使用？
我什么时候应该在C++中使用new关键字？

A a;和之间有什么区别A a = new A();？

编辑:

A* a = new A();

我的错.

来自更多的Java背景我想知道如何通过引用返回一个新对象.我希望Fraction该类是不可变的,以便每个操作都返回一个带有操作结果的新对象.

这将是我在Java中的代码:

class Fraction {
    int numerator;
    int denominator;

    // Constructor

    Fraction multiply(Fraction other) {
        return new Fraction(other.numerator * this.numerator, 
                            other.denominator * this.denominator);
    }

}

但是,如果我在C++中这样做,我会创建内存泄漏,因为我无法清理初始化Fraction对象,因为我只有对象的引用.那么,我如何在C++中处理这个问题呢？

class Fraction {
private:
    int32_t numerator;
    int32_t denominator;
 public:
    Fraction(int32_t numerator, int32_t denominator) {
        this->numerator = numerator;
        this->denominator = denominator;
    }

    Fraction& operator*(Fraction& other) {

        auto numerator = other.numerator * this->numerator;
        auto denominator = other.denominator * this.denominator;

        return *(new Fraction(numerator, denominator))
    }
};

我对C++ /指针并不熟悉,但试图实现单链表.

我只是创建一个Node(head)并Node在head每次将新的一个添加到列表后添加.

struct Node {
    int key;
    Node *next;

    Node() : key(-1), next(nullptr) { }
    Node(int k) : key(k), next(nullptr) { }
};

void AddNode(Node *head, int key) {    // Create a new node & add it after the head
    Node newNode(key);
    newNode.next = head->next;
    head->next = &newNode;
}

void PrintNode(Node *nptr, string pre, string post) {
    cout << pre << "(" << nptr << "), " << nptr->key << ", …

我一直试图通过阅读一些文本和查找内容来理解 C++ 中的内存分配。我经常看到人们应该总是在“new”之后调用“delete”。但是，我也看到这样的代码：

void LinkedList::add(int data){
    Node* node = new Node();
    node->data = data;
    node->next = this->head;
    this->head = node;
    this->length++;
}

在链表或堆栈等结构中。

我在 SO 上看到了一些很好的解释，例如：

为什么 C++ 程序员应该尽量减少“new”的使用？ 在 C++ 中，何时使用“new”，何时不使用？

但是，我仍然很困惑为什么不在这里为新节点调用“删除”。

编辑：让我澄清我的问题。我明白为什么不立即以相同的方法调用 delete 。但是，在相同的代码中，我没有看到与添加匹配的删除语句。我假设一旦程序结束，一切都会被删除，但我很困惑，没有明显匹配的删除语句（即：计算代码中的所有新闻，计算代码中的所有删除，它们不匹配）。

编辑：这是我正在查看的来源：https : //www.geeksforgeeks.org/linked-list-set-2-inserting-a-node/

他们的链表的代码：

// A complete working C++ program to demonstrate
//  all insertion methods on Linked List
#include <bits/stdc++.h>
using namespace std;
 
// A linked list node
class Node
{
    public:
    int data;
    Node *next;
};
 
/* Given a reference (pointer …

可能重复:
点(.)运算符和C++中的 - >有什么区别？

使用点符号和指针方式有什么区别？

使用或不使用指针实例化对象.

实例化w/oa指针=然后使用点表示法

实例化w/a指针=然后使用 - >

两者有什么不同？何时以及为什么要使用另一个？

假设我有一个执行某些任务的函数。该函数返回一个指向int的指针。我的问题是：我是否必须取消分配内存，还是可以使用这种通用格式？

int *do_something()
{
    int *local{ new int };
    //do_something_here

    return local;
    delete local;
}

int main()
{
   int *result{ new int };

   result = do_something();
   delete result;
   return 0;
}