[C++] Class with char * member

[ms​]

So I've written the following class:

#define BUFLEN 100000

class myClass
{
	public:
		myClass();
		~myClass();

	private:
		char *buf;
};

myClass::myClass()
{
	buf = new char[BUFLEN];
}

myClass::~myClass()
{
}

This code is being executed as i want, but obviously it contains a memory leak. Simply deleting the allocated memory in the destructor doesn't help since I want to use this class in a vector. When an object is copied and then deleted the char * of the copy points to an invalid memory address.
After using the copy constructor as well I ended up with this code:

#define BUFLEN 100000

class myClass
{
	public:
		myClass();
		myClass(const myClass &rmyClass);
		~myClass();

	private:
		char *buf;
};

myClass::myClass()
{
	buf = new char[BUFLEN];
}

myClass::myClass(const myClass &rmyClass)
{
	*this = myClass;
	this->buf = new char[BUFLEN];
	memcpy(this->buf, rmyClass.buf, BUFLEN);
}

myClass::~myClass()
{
	delete buf;
}

This code runs, but after some time it throws a memory exception and I have no idea why.


Need help! ;O

[Shadow992]

Originally Posted by Disconnect

So I've written the following class:

#define BUFLEN 100000

class myClass
{
	public:
		myClass();
		~myClass();

	private:
		char *buf;
};

myClass::myClass()
{
	buf = new char[BUFLEN];
}

myClass::~myClass()
{
}

This code is being executed as i want, but obviously it contains a memory leak. Simply deleting the allocated memory in the destructor doesn't help since I want to use this class in a vector. When an object is copied and then deleted the char * of the copy points to an invalid memory address.
After using the copy constructor as well I ended up with this code:

#define BUFLEN 100000

class myClass
{
	public:
		myClass();
		myClass(const myClass &rmyClass);
		~myClass();

	private:
		char *buf;
};

myClass::myClass()
{
	buf = new char[BUFLEN];
}

myClass::myClass(const myClass &rmyClass)
{
	*this = myClass;
	this->buf = new char[BUFLEN];
	memcpy(this->buf, rmyClass.buf, BUFLEN);
}

myClass::~myClass()
{
	delete buf;
}

This code runs, but after some time it throws a memory exception and I have no idea why.


Need help! ;O

Hmm, i think the problem is that buf is an array (or can be one) and you are only deleting the first index, try this:

PHP Code:

#define BUFLEN 100000

class myClass
{
    public:
        myClass();
        myClass(const myClass &rmyClass);
        ~myClass();

    private:
        char *buf;
};

myClass::myClass()
{
    buf = new char[BUFLEN];
}

myClass::myClass(const myClass &rmyClass)
{
    *this = myClass;
    this->buf = new char[BUFLEN];
    memcpy(this->buf, rmyClass.buf, BUFLEN);
}

myClass::~myClass()
{
    delete[] buf;
} 


[ms​]

delete and delete[] appear to have the same result. However, I think I solved the problem.

#define BUFLEN 100000

class myClass
{
	public:
		myClass();
		myClass(const myClass &rmyClass);
		~myClass();
		myClass &myClass::operator=(const myClass &rmyClass)

	private:
		char *buf;
};

myClass::myClass()
{
	buf = new char[BUFLEN];
}

myClass::myClass(const myClass &rmyClass)
{
	buf = new char[BUFLEN];
	*this = myClass;
}

myClass::~myClass()
{
	delete buf;
}

myClass &myClass::operator=(const myClass &rmyClass)
{
	if (this != &rmyClass)
		memcpy(buf, rmyClass.buf, BUFLEN);
	return *this;
}

[Bot_interesierter]

kwt

[MrSm!th]

Originally Posted by Disconnect

delete and delete[] appear to have the same result. However, I think I solved the problem.

#define BUFLEN 100000

class myClass
{
	public:
		myClass();
		myClass(const myClass &rmyClass);
		~myClass();
		myClass &myClass::operator=(const myClass &rmyClass)

	private:
		char *buf;
};

myClass::myClass()
{
	buf = new char[BUFLEN];
}

myClass::myClass(const myClass &rmyClass)
{
	buf = new char[BUFLEN];
	*this = myClass;
}

myClass::~myClass()
{
	delete buf;
}

myClass &myClass::operator=(const myClass &rmyClass)
{
	if (this != &rmyClass)
		memcpy(buf, rmyClass.buf, BUFLEN);
	return *this;
}

It should not.
delete is for single elements, but if you allocate more than one element you should use delete[]!

[tim66613]

I think reference counting is the best way to solve your problem:

#define BUFLEN 100000

class myClass
{
	public:
		myClass();
		myClass(const myClass& rmyClass);
		~myClass();
		myClass& operator=(const myClass& rmyClass);


	private:
		struct _Holder
		{
			_Holder(char* p)
				: m_realPtr(p)
				, m_refCount(1)
			{
				// ctor
			}

			~_Holder()
			{
				delete[] m_realPtr;
			}

			char* m_realPtr;
			unsigned int /*uint32_t*/ m_refCount;
		};

		_Holder* m_data;
};

myClass::myClass()
{
	m_data = new _Holder(new char[BUFLEN]);
}

myClass::myClass(const myClass& rmyClass)
	: m_data(rmyClass.m_data)
{
	m_data->m_refCount++;
}

myClass::~myClass()
{
	if(--m_data->m_refCount == 0)
		delete m_data;
}

myClass& myClass::operator=(const myClass& right)
{
	right.m_data->m_refCount++;

	if(--m_data->m_refCount == 0)
		delete m_data;

	m_data = right.m_data;
}

Kind Regards Tim