cbytearry

#pragma once
class CByteArray
{
public:
	CByteArray();
	CByteArray(const CByteArray& byteArray);
	~CByteArray();

	CByteArray& operator= (const CByteArray& byteArray);

	void Append(const CByteArray& buffer);
	void Append(const char* buffer, const size_t size);
	void Resize(size_t size);
	CByteArray right(size_t size);

	char* constData() const;
	char* data();
	size_t size() const;
private:
	char* m_pData;
	size_t m_nSize;
};

#include "pch.h"
#include "CByteArray.h"
#include <assert.h>
#include <string.h>

CByteArray::CByteArray() :
	m_pData(nullptr)
	, m_nSize(0)
{}

CByteArray::~CByteArray()
{
	if (m_pData != nullptr)
	{
		delete[] m_pData;
		m_pData = nullptr;
	}
}

CByteArray::CByteArray(const CByteArray& byteArray)
{
	if (byteArray.constData() != nullptr && byteArray.size() > 0)
	{
		m_pData = new char[byteArray.size()];
		memcpy(m_pData, byteArray.constData(), byteArray.size());
	}
	m_nSize = byteArray.size();
}

CByteArray& CByteArray::operator= (const CByteArray& byteArray)
{
	if (m_pData != nullptr)
	{
		delete[] m_pData;
		m_pData = nullptr;
		m_nSize = 0;
	}
	if (byteArray.constData() != nullptr && byteArray.size() > 0)
	{
		m_pData = new char[byteArray.size()];
		memcpy(m_pData, byteArray.constData(), byteArray.size());
		m_nSize = byteArray.size();
	}
	return *this;
}

void CByteArray::Append(const CByteArray& buffer)
{
	Append(buffer.constData(), buffer.size());
}

void CByteArray::Append(const char* buffer, const size_t size)
{
	if (size > 0 && buffer != nullptr)
	{
		if (m_pData != nullptr && m_nSize > 0)
		{
			char* pData = m_pData;
			m_pData = new char[m_nSize + size];
			memcpy(m_pData, pData, m_nSize);
			memcpy(m_pData + m_nSize, buffer, size);
			m_nSize = m_nSize + size;
		}
		else {
			m_pData = new char[size];
			memcpy(m_pData, buffer, size);
			m_nSize = size;
		}
	}
}

void CByteArray::Resize(size_t size)
{
	assert(size >= 0);
	if (m_nSize != size)
	{
		if (size == 0)
		{
			if (m_pData != nullptr)
			{
				delete[] m_pData;
				m_pData = nullptr;
			}
		}
		else {
			m_pData = new char[size];
		}
		m_nSize = size;
	}
}

CByteArray CByteArray::right(size_t size) 
{
	assert(m_nSize >= size && m_pData != nullptr);
	char* pRightData = m_pData + (m_nSize - size);

	CByteArray byteArray;
	byteArray.Append(pRightData, size);
	return byteArray;
}

char* CByteArray::constData() const
{
	return m_pData;
}

char* CByteArray::data()
{
	return m_pData;
}

size_t CByteArray::size() const
{
	return m_nSize;
}