Simple Lib

#include <iostream>
#include <new>
#include <typeinfo>
#include <cstdlib>

#ifndef SIMPLE
#define SIMPLE

namespace simple
{
	// 例外用クラス
	/* コンストラクタ引数にとるエラーメッセージを出力し
	   プログラムを終了させる。									 */
	class index_err
	{
	public:
		explicit index_err( const char* msg )
		{
			std::cerr << msg << std::endl;
			exit( EXIT_FAILURE );
		}
	};
	//	汎用配列クラス
	/* ・要素数はコンストラクタに指定した個数分
		境界検証をする												 */
	template <class T> class Array
	{
	public:
		// コンストラクタ
		/* 働き：サイズ1の要素を定義する
			   メンバ変数の初期化 								 */
		Array() : set_size( 1 )
		{
			count = 0;
			data = NULL;
			try {
				data = new T [set_size];
			}catch ( std::bad_alloc ba ) {
				std::cerr << "Allocation failed\n";
			} 
			catch ( index_err idxErr ){ }
		}
		
		// コンストラクタ オーバロード
		/*	働き：引数に取った数の要素数をnew演算で確保する
				メンバ変数の初期化 
			引数：ゼロ以上の正の整数								 */
		explicit Array( const int size ) : set_size( size )
		{
			count = 0;
			data = NULL;
			try {
				valid_index_range( size ); 
				data = new T [set_size];
			}
			catch ( std::bad_alloc ba ) {
				std::cerr << "Allocation failed\n";
			} 
			catch ( index_err idxErr ){ }
		}
		// コピーコンストラクタ
		/* クラスオブジェクトのコピーを作成する					 */ 
		Array( const Array& ob ) : set_size( this-> set_size )
		{
			count = 0;
			data = NULL;
			try {
				valid_index_range( ob.set_size ); 
				data = new T [ ob.set_size ];
			}catch ( std::bad_alloc ba ) {
				std::cerr << "Allocation failed\n";
			}
			catch ( index_err idxErr ){ }

			// 引数オブジェクトの保持するメンバからコピー
			for( int i = 0; i < set_size; ++i ){
				this-> data[i] = ob.data[i];
			}
		}
		// デストラクタ
		/* コンストラクタでnewした領域を解放する */
		~Array() { if ( data ) delete [] data; }
		
		// put関数 
		/*	働き：外部から1つのデータをクラスメンバに格納する
				　データを格納したらカウンタ（インデックス）を一つ進める
				  配列の先頭から格納
			引数：実行時に特定されるT型
			戻値：なし													*/
		void put( T arg )
		{
			int index = 0;

			if ( count < set_size ) index = count;
			data[ index ] = arg;
			++count;
		}
		// pull関数
		/*	働き：put関数によってメンバに格納されている値を取り出す
				  データを取り出しても取り出したデータは破棄しない
				  取り出し位置は先頭のみ。
			引数：なし
			戻値： T 型												 */
		T pull( )
		{
			if ( 0 < set_size ) {
				return data[ 0 ]; // 先頭要素のみ返す
			}
		}
		// pull関数 オーバロード
		/*	働き：引数により指定されたインデックスの指し示す要素を返す
			引数：取得したい配列ののインデックス( 正のint )
			戻値： T型													 */
		T pull( int index )
		{
			try {
				// indexがゼロ以上でint型かチェック
				valid_index_range( index );
				// indexが定義済みの範囲かチェック
				defined_range( index );
			}
			catch( index_err idxErr ){ }
			return return data[ index ];
		}
		// size関数
		/*	働き：配列の要素数を返す
			引数：なし
			戻値：要素数（int）*/
		int size() const { return set_size; }

		const T &operator [] ( int index ) const
		{
			try {
				// indexがゼロ以上でint型かチェック
				valid_index_range( index );
				// indexが定義済みの範囲かチェック
				defined_range( index );
			}
			catch( index_err idxErr ){ }
			return data[ index ];
		}
		T &operator [] ( int index )
		{
			try {
				// indexがゼロ以上でint型かチェック
				valid_index_range( index );
				// indexが定義済みの範囲かチェック
				defined_range( index );
			}
			catch( index_err idxErr ){ }
			return data[index];
		}
		// 代入演算子のオーバロード：つかれたお(´・ω・`)

	private:
		int count;
		const int set_size;
		T* data;

		// valid_index_range関数
		/*	働き：配列の添字アクセスに利用する値が正当であるか判定する
				負の数ではないことと、整数であることをチェック。
			引数：調べたいインデックス(int)
			戻値：なし													*/
		void valid_index_range( int target_idx )
		{
			int type_int = 0;
			// 正の数がチェック
			if ( target_idx < 0 ) {
				throw index_err("Size is less then zero");
			}
			// 引数がintかチェック
			if ( typeid( type_int ) != typeid( target_idx ) ) {
				throw index_err("Type Err: argument is not integer");
			}
		}
		// defined_range関数
		/*	働き：配列の境界検証を行う
			引数：チェックしたい配列のインデックス（int）
			戻値：なし													*/
		void defined_range( int target_idx )
		{
			if ( 0 > target_idx || target_idx >= set_size ) {
				throw index_err("index outbound");
			}
		}
	};
}
#endif

int main()
{
	simple::Array<int> n( 5 );
	n.put( 1 );
	n.put( 2 );
	
	std::cout << n[5];
	

	int r = n.pull();
	return 0;
}