我正在创建一个跟踪学生的类。在这个类中,我使用一个重载的=来复制这些学生对象。为了跟踪它们的类,我使用了一个动态数组。该数组复制得很好;但是,当清除学生对象的变量时,以前从该对象复制的任何对象的数组也会被擦除。代码如下:
#include <iostream>
#include <string>
using namespace std;
class Student
{
string name; //Name
string* classList = NULL; //Empty array to store class n
在C++中,在保存new'd数据的指针上调用new是否会删除旧数据?
我想说的是,它不会,而且会导致泄漏。在已经包含数据的指针上调用new,肯定只会指向新数据,而我们就会失去对旧数据的引用?
我之所以这样问,是因为我在查看时注意到,在构造函数中,有人建议OP这样做:
MyString::MyString()
{
// A new, empty string contains zero characters plus a terminating zero.
nlength = 1;
nstring = new char[1];
nstring[0]
在c++中,可以在另一个类的构造函数中初始化一个类的对象吗?我通常只在main()中声明对象,但是我很好奇这是不是可能的,也是一种好的做法。有"new“和没有"new”运算符的case有什么含义?它在哪里被销毁?
例如,假设一个名称空间和一个带有"new“运算符的示例
class A{
private:
protected:
int *w, int *h;
public:
A(){
w = new int;
h = new int;
};
virtual int area (return ((*w)*(*h)) ;)
virtual ~A()
{
delet
我正在努力在c++上变得更好。我在main()中有一个Test类和下面的代码。
Test *pObj = new Test();
如果我们通过逐条指令进行调试,它首先转到新函数分配内存,然后调用构造函数。然后返回到main()函数。众所周知,构造函数不会返回任何东西。在这种情况下,为什么pObj会有由new分配的指针?你知道它是如何被编译器实现的吗?
我在某个地方看到了以下代码:
class Person {
private:
string *customerName;
public:
Person() {customerName = new string;}
void setCustomerName(char *s) {*customerName = s;}
};
int main()
{
Person person1;
Person person2;
person1.setCustomerName("Malcolm");
person
在下面的例子中
class X
{
int *r;
public:
X() {
cout << "X is created";
r = new int[10];
};
~X() {
cout<< "X is destroyed";
delete [] r;
};
};
class Y
{
public:
Y() {
X x;
throw 44;
};
~Y() {
P.S:我刚开始编程,所以请用简单的语言回答我的疑问。我找到了几个答案,但都听不懂。下面是复制构造函数和赋值操作符重载。
template <class T>
Mystack<T>::Mystack(const Mystack<T> &source) // copy constructor
{
input = new T[source.capacity];
top = source.top;
capacity = source.capacity;
for (int i = 0; i <= s
我在代码中使用了动态内存分配,在尝试删除指向子类的指针时遇到了问题。当我使用delete关键字时,我发现原来分配的内存没有被释放。该功能与原始基类一起工作得很好。
这是一个问题,因为我在arduino上运行代码,RAM很快就会耗尽,然后崩溃。
下面是一些示例代码:
class Base
{
public:
Base(){
objPtr = new SomeObject;
}
~Base(){
delete objPtr;
}
SomeObject* objPtr;
};
class Sub : public Base
{
int main()
{
A* x = new B(10, 20);
x->opt1();
delete x;
return 0;
}
int main()
{
B x(10, 20);
return 0;
}
第一个是内存泄漏,因为x是一个指向B对象的A对象。如果A不是指针,它还会有内存泄漏吗?
为什么第二个函数没有内存泄漏呢?我们不需要删除x?
class A
{
private:
int* a;
public:
A(int size) {
a = new int
我得到了错误:
没有运算符"[]“匹配这些操作数。
关于这一行:
cout << A[j].display(n)
但是当我取出[j]时,我得到的是错误:
类“列表”没有成员“显示”。
这是我的代码:
class list
{
protected:
int *p; // pointer to a list
int size; // dimension
public:
list(int x)
{
size = x;
p = new int[size];
}
void get(int
我可以在C‘’tor中声明新的变量,比如不同类中的一个吗?假设我有一个名为List的类和一个Node (嵌套在List类中),那么我想这样做:
List::List(int num)
{
Node Nod(num); //creating a new Node which is holding num
List_Head=&Nod; //List_Head is a Node pointer variable of List class
}
一旦我这样做,我将得到以下运行时错误
调试断言失败!
表达:_BLOCK_TYPE_IS_VALID(pHead->nBlockUse)
我在下面的代码中有一个疑问,在析构函数中有一个析构函数delete line[],我只想知道这个delete是否有堆栈溢出,这可能是递归调用析构函数的结果。
class Line {
public:
char *line;
Line(const char *s = 0) {
if (s) {
line = new char[strlen(s)+1];
strcpy(line, s);
} else {
line = 0;
}
}
~Line(
class A
{
private:
A () {}
public:
static A* getInstance ()
{
return new A ();
}
};
int main ()
{
A.getInstance ();
return 0;
}
会导致标题中所述的错误。我确实意识到,如果我在类A中创建一个变量,并在那里实例化它,然后直接返回它,错误就会消失。
但是,这里我想了解这个错误的含义,以及为什么我不能以这种方式使用它。
上面的文章指出,在对象构造过程中不会有内存泄漏。
下面的代码怎么样?这会导致内存泄漏吗?我看到示例应用程序的内存使用量增长缓慢(在任务管理器中),即使在强制GC收集之后也是如此。
namespace WindowsFormsApplication1
{
public partial class Form1 : Form
{
public Form1()
{
InitializeComponent();
}
private void Form1_Load(object sender, Ev