请注意以下代码:
class A { public: virtual void Foo() = 0; int Bar; };
class B : public A { public: B( float X ); void Foo(); private: float X; };
class C : public A { public: C( float Y ); void Foo(); private: float Y; };
现在,在某些功能中,让我说我这样做:
A*& pToA = pToDerived; // allocated as A* pToDerived = new B( ... );
pToA = pToC; // allocated as A* pToC = new C( ... );
这有效吗?如果是这样,即使pToA
是对pToDerived
指针的引用,它是否会导致内存泄漏?
SSCS
假设Node
有两种或更多种类型,它来自它。这是我目前正在实施的链表的片段,为了正常工作,可能需要多态,因为它不是通用的。 newnode
是传递给插入函数的参数。
Node* iNode;
for( iNode = mStart; iNode != mEnd; iNode = iNode->Next )
{
if ( iNode->Key == k ) // Replace current node with newnode
{
newnode->Next = iNode->Next;
newnode->Prev = iNode->Prev;
*iNode = *newnode;
delete newnode;
return; // We're done, so we quit.
}
}
// Node doesn't alreay exist, so we add it.
Node*& uglyhack = mEnd;
iNode->Next = newnode;
newnode->Prev = iNode;
uglyhack = newnode;
答案 0 :(得分:3)
这与做
相同pToDerived = pToC;
这没有任何内在错误。只有在你从不删除对象时才会泄漏内存,就像平常一样。
在更新的代码中,您可以这样做:
iNode->Next = newnode;
newnode->Prev = iNode;
mEnd = newnode;
它会是一样的。
答案 1 :(得分:2)
假设您有以下内容:
// See http://codepad.org/8mG6YiLy
class A { public: virtual void Foo() = 0; int Bar; };
// Added definitions for these so that this would compile
class B : public A {
public: B( float x ) : X(x) {}
virtual void Foo() {} // Once virtual, always virtual
private: float X;
};
class C : public A {
public: C( float y ) : Y(y) {}
virtual void Foo() {}
private: float Y;
};
int main()
{
A* pToDerived = new B(3.14);
// pToDerived -> B
A*& pToA = pToDerived;
// pToDerived -> B
// pToA IS pToDerived
A* pToC = new C(2.718);
// pToDerived -> B
// pToC -> C
// pToA IS pToDerived
pToA = pToC;
// pToDerived -> C
// pToC -> C
// pToA IS pToDerived
// One object of type B no longer has pointers pointing to it
}
此代码泄漏了两个对象 - 一个类型B
(发生在pToA = pToC
语句中)和一个类型C
(当main
返回时发生) 。在这种情况下,“参考”实际上并没有在这里发挥很大作用。在C ++中,引用只是其他对象的别名。你不能“重新安置”它们。也就是说,一旦引用引用某些内容,它就永远不会再引用任何其他内容。
在这种情况下,当您创建pToA时,您创建了对指针的引用 - 在这种情况下指针为pToDerived
。使用此引用不会影响内存管理或某些代码在正确位置调用delete
的责任。