以下示例留下可能的内存泄漏,因为析构函数不会针对在其构造函数运行期间处理异常的对象运行.我在哪里处理这个内存泄漏？
#include <exception>
class MyClass {
public:
MyClass()
{
c = new char[5];
throw std::runtime_error("test");
}
~MyClass ()
{
delete[] c;
}
private:
char *c;
};
int main()
{
try
{
MyClass Obj;
}
catch (std::runtime_error)
{
}
}
这是我的代码
Node* Node::createNode(int n)
{
Node newNode(n);
Node *temp = &newNode;
return temp;
}
void Node::printNode(Node* node)
{
cout << node->data << "\t" << node->next << endl;
system("pause");
}
这是主要功能
int main(int argc, char* argv[])
{
Node *head = Node::createNode(10);
Node::printNode(head);
return 0;
}
问题,我原本打算打印10.相反,我的垃圾值为-858993460.我注意到,直到这一点,参数传递给函数,它保留正确的值.但是在函数printNode中,值会发生变化.所以我觉得函数调用出了问题.任何帮助,将不胜感激.
对于小程序,我们可以通过这种方式防止内存泄漏:
proc() {
//allocate memory for matrix
try {
}
catch {
//free matrix memory
}
...
//free matrix memory
}
如果我们的程序更复杂:
proc() {
//allocate memory for matrix
try {
}
catch {
//free matrix memory
}
...
try {
}
catch {
//free matrix memory
}
...
try {
}
catch {
//free matrix memory
}
...
//free matrix memory
}
它看起来有点笨拙.是一种更好的方法,更好的编程风格是否存在内存泄漏控制？据我所知,C++有auto_ptr,我们可以开发程序而不需要关心内存释放.
proc() {
//allocate auto_ptr
try {
}
catch {
}
...
}
但是,据我所知,auto_ptr甚至不适用于数组.因此,在一般情况下,这是不可接受的方式.
我正在写一个函数来加载一个txt文件并返回一个const char*下面的函数工作,我的问题是如果我不存储*pS然后调用delete pS,这个函数会导致内存泄漏吗？
const char* loadFile(string fname)
{
string line,text;
ifstream in(fname);
while(std::getline(in, line))
{
text += line + "\n";
}
string *pS = new string(text);
const char* data = pS->c_str();
return data;
}
该函数在我的代码中使用如下
static const char* pVS;
...
pVS = loadFile("VS.txt");
...
delete pVS;
这会删除字符串吗？
我制作了一个动态的对象数组.当我调用delete []时,程序崩溃并停止响应.但它确实有奇怪的行为:调用所有析构函数和崩溃.看看这段代码和输出.分配所有阵列的所有内存.
//main file
#include "myobject.h"
int size;
myObject *foo;
//some operations to estimate size
foo = new myObject[size];
//some operations with myObject
std::cout<<"size: "<<size<<"\n";
std::cout<<"Deleting object\n";
size=0;
delete [] foo;
下一个文件:
//myobject.h
class myObject
{
public:
int number;
Object1 ob1[64]
Object2 *ob2;
myObject(){ };
~myObject()
{
std::cout<<"delete "<<number<<"\n";
delete [] ob1;
delete [] ob2;
};
}
并输出:
size: 11
Deleting object
delete 10
delete 9
delete 8
delete 7
delete 6
delete 5
delete 4
delete 3
delete 2 …我需要一个智能指针用于我的项目,可以作为参数发送到几个方法.我从boost 检查了auto_ptr和shared_ptr.但IMO,这不符合我的要求.以下是我的发现
auto_ptr:当传递给另一个方法时,将转移所有权,并在该方法的范围结束时删除基础指针.我们可以通过引用传递auto_ptr来解决这个问题,但是没有编译时机制来确保它总是通过引用传递.如果错误地,用户忘记传递引用,则会产生问题.
boost :: shared_ptr:这看起来很有前途,可以满足我的需要.但我觉得这对我的项目来说太过分了,因为它很小.
所以我决定编写一个简单的模板化指针容器类,它不能被值复制并注意删除底层指针.这里是
template <typename T>
class simple_ptr{
public:
simple_ptr(T* t){
pointer = t;
}
~simple_ptr(){
delete pointer;
}
T* operator->(){
return pointer;
}
private:
T* pointer;
simple_ptr(const simple_ptr<T>& t);
};
这个实现是否正确？我已经将复制构造函数设置为私有,因此编译器会在有人尝试按值传递时发出警报.
如果指针被删除,则对析构函数的删除操作将抛出断言错误.我该如何解决这个问题？
我对C++很陌生,你的建议非常感谢.
谢谢
使用OpenGL/GLUT和C++制作游戏.
我听说在GLUT中管理键盘内容的最简单方法是使用bool数组.
基本上,这就是我所拥有的:
bool* keys = new bool[256];
...
void keyDown(unsigned char ch, int x, int y)
{
keys[ch] = true;
}
void keyUp(unsigned char ch, int x, int y)
{
keys[ch] = false;
}
然后,如果我想知道一个键的状态,我只需返回键[key].
我有一个类似的特殊键设置.现在,在我死后的游戏中,它会重置所有需要重置的值并再次启动游戏.直到现在,包括
keys = new bool[256];
以及特殊键数组的类似声明.对我来说没有任何意义的是偶尔,这种假设的数组重置会导致键中的部分或全部值变为两位或三位整数(因此总是评估为真,并使得玩家角色不受控制地移动,直到一个或显然失望的更多钥匙被压抑了.我怀疑这发生了,因为在结束游戏时,其中一个键被按下,从而混淆了C++,当它试图使整个数组失真并发现有一件事被证实是真的.
伙计,那令人困惑.据我所知,通过消除密钥的所有额外初始化,问题已得到解决.但我不明白.任何人都对我如何设法将一些bool变成整数有任何想法？
这两个之间的区别对我来说还不清楚。我所读到的内容非常庞大且复杂（就像C ++一样）。例如，这个属于多年前，也来自WikiPedia。这个问题本身可能很复杂。
我对它们的想法是，RAII是一种将其用于智能指针的机制，但是我不确定。我需要一个简单明了的答案。
您能以简单的语言用少量示例代码来解释它吗？请记住，我的C ++水平很低。
我是 C++ 新手，我试图用不同的方式释放一个对象。这是我的代码：
class foo{
public:
int* bar;
foo(int N){
bar = new int[N];
}
~foo(void){
delete[] bar;
}
};
int main(int argc, char* argv[]){
foo* F = new foo(10);
delete F;
return 0;
}
这工作得很好，但如果我这样写 main ：
int main(int argc, char* argv[]){
foo F = foo(10);
F.~foo();
return 0;
}
我最终会得到“检测到 glibc”。我想我应该以某种方式取消分配“bar”指针，因为它是在构造期间分配的。
因此我的问题是如何释放这样的对象？谢谢。
首先,这里讨论RAII和智能指针.
我一直认为Smart Pointer就像shared_ptr是RAII的一个好习惯,因为它在构造函数中获取堆内存资源
shared_ptr<A> pA(new pA());
并且可以通过引用计数及其析构函数在适当的时间释放内存.
但是,今天早上我的同事告诉我:
" 智能指针不是我认为的RAII.在STL中唯一可以严格称为RAII的是
std::lock_guard,其他只不过是RRID."
所以我弄错了什么？或者我的同事所说的实际上是没有意义的？