유니버설 그룹 (연습, 틀릴 수 있음)

#ifndef STD_VAL_ARRAY_H_
#define STD_VAL_ARRAY_H_

class StdValArray {
public:
	StdValArray();
	StdValArray(int _element_size, int _pre_allocated_size = 0);
	~StdValArray();
	void Add(void *_data);
	void *GetIndex(int _index) const;
	int GetSize() const;
	void **GetData() const;
	bool IsEmpty() const;
	void *operator [](int _index) const;
	void Remove(int _index);
private:
	int element_size;
	int element_count;
	int allocated_count;
	void **p_value;
};	

#endif // STD_VAL_ARRAY_H

/*
	StdValArray.cpp

	General Array Container

	lvqinghou 2011-03-21 15:46
*/

#include "StdValArray.h"

#include <iostream>
#include <cstring>
#include <cstdlib>
using namespace std;

StdValArray::StdValArray() : element_size(0),
	element_count(0), allocated_count(0),
	p_value(NULL)
{
}

StdValArray::StdValArray(int _element_size, int _pre_allocated_size /*= 0*/) : 
	element_size(_element_size), element_count(0), 
	allocated_count(_pre_allocated_size), p_value(NULL)
{
	if (allocated_count == 0) {
		allocated_count = 13;
	}
	p_value = (void **)malloc(element_size * allocated_count);
	memset(p_value, 0, element_size * allocated_count);
}

StdValArray::~StdValArray()
{
	free(p_value);
}

void StdValArray::Add(void *_data)
{
	void **p_tmp = NULL;
	if (++element_count > allocated_count) {
		allocated_count *= 2;
		p_tmp = (void **)malloc(element_size * allocated_count);
		memset(p_tmp, 0, element_size * allocated_count);
		memcpy(p_tmp, p_value, element_size * (element_count - 1));
		free(p_value);
		p_value = p_tmp;
		p_tmp = NULL;
	}
	memcpy(p_value + element_size * (element_count - 1), _data, element_size);
}

void *StdValArray::GetIndex(int _index) const
{
	if (_index > element_count || _index <= 0)
		return NULL;
	return (p_value + element_size * (_index - 1));
}

int StdValArray::GetSize() const
{
	return element_count;
}

void **StdValArray::GetData() const
{
	return p_value;
}

bool StdValArray::IsEmpty() const
{
	return (element_count == 0);
}

void *StdValArray::operator [](int _index) const
{
	if (_index > element_count || _index <= 0)
		return NULL;
	return (p_value + (_index - 1) * element_size);
}

void StdValArray::Remove(int _index)
{
	if (_index > element_count || _index <= 0)
		return ;
	int i = _index;
	for (i = _index; i < element_count; i ++)
		memcpy(p_value + element_size * (i - 1), p_value + element_size * i, element_size);
	element_count --;
	memset(p_value + element_size * element_count, 0, element_size);
}