String & Vector

class string
{
public:

	string(const char* data)
	{
		mSize = strlen(data);
		mCapacity = mSize * 3;
		mData = new char[mCapacity];
		memcpy(mData, data, mSize + 1/*null character*/);
	}

	size_t length() const
	{
		return mSize;
	}

	void operator+=(const char* data)
	{
		//메모리 크기 체크
		size_t tokenSize = strlen(data);
		size_t newSize = mSize + tokenSize;
		size_t newCapacity = newSize * 3;

		// true : 메모리 크기 재할당
		if (mCapacity < newSize + 1/* null character*/)
		{
			// 메모리 복사
			char* newData = new char[newCapacity];
			memcpy(newData, mData, mSize); // 기존 데이터 복사
			memcpy(newData + mSize, data, tokenSize + 1); // 추가 데이터 복사

			// 기존 메모리 정리
			memset(mData, 0, mCapacity);
			delete[] mData;
			mData = newData;
		}
		// false : 기존 메모리 사용
		else
		{
			memcpy(mData + mSize, data, tokenSize + 1); // 추가 데이터 복사
		}

		// 멤버 변수 값 업데이트
		mCapacity = newCapacity;
		mSize = newSize;
	}

	char& operator[](int idx) const
	{
		return mData[idx];
	}

	friend std::ostream& operator<<(std::ostream& out, string& s)
	{
		out << s.mData;
		return out;
	}

private:

	char* mData;
	size_t mSize;
	size_t mCapacity;
};


int main()
{
	std::string strA("Hello");
	int len = strA.length();
	strA += " World";
	std::cout << strA[4];

	string strB("Hello");
	strB += " World~~~~~~~~~";
	strB[4] = 'a';
	std::cout << strB;

	return 0;
}

---

template<typename T>
class vector
{
public:
	vector()
	{
		mCapacity = 0;
		mSize = 0;
		mData = nullptr;
	}

	~vector()
	{
		if (mData != nullptr)
		{
			delete[] mData;
			mData = nullptr;
		}
	}

	void push_back(T data)
	{
		// Capacity 체크
		if (mCapacity < mSize + 1)
		{
			changeMemorySize((mSize + 1) * 3);
		}

		// 데이터 삽입
		mData[mSize] = data;
		++mSize;
	}

	const size_t size() const
	{
		return mSize;
	}

	T& operator[] (int i) const
	{
		return mData[i];
	}

	void clear()
	{
		memset(mData, 0, mSize * sizeof(T));
		mSize = 0;
	}

	void resize(const size_t size)
	{
		changeMemorySize(size);
	}

private:

	void changeMemorySize(size_t cap)
	{
		
		T* temp = new T[cap];

		// 메모리 크기를 수정할 때
		if (0 < mCapacity)
		{
			// 메모리가 더 커질때
			if (mCapacity < cap)
			{
				memcpy(temp, mData, sizeof(T) * mCapacity);
			}
			// 메모리가 더 작아졌을 때
			else
			{
				memcpy(temp, mData, sizeof(T) * cap);
			}

			// 기존 메모리 정리
			memset(mData, 0, mCapacity);
			delete[] mData;
		}
		
		// 기존 멤버 변수 업데이트
		mData = temp;
		mCapacity = cap;
	}

private:
	T* mData;
	size_t mCapacity;
	size_t mSize;
};

int main()
{
	vector<int> vec;
	vec.push_back(1);
	vec.push_back(2);
	vec.push_back(3);
	vec.push_back(4);
	vec.push_back(5);

	for (int i = 0; i < vec.size(); i++)
	{
		std::cout << vec[i];
	}

	vec.resize(10);

	for (int i = 0; i < vec.size(); i++)
	{
		vec[i] = i;
	}

	vec.clear();

	return 0;
}