safeArray4(try-throw-catch)

※main.cpp파일

#include <iostream>

#include "safeArray.h"

#include "array.h"

#include "invalidindex.h"



int main() {



	int nums1[] = {1,2,3,4,5};

	SafeArray arr1(nums1,5);

	for (int i = 0; i<5; i++) {

		std::cout << "arr1["<<i << "] : " << arr1[i] << std::endl;

	}	

	

	

	try {

		double nums2[] = {1.1,2.2,3.3,4.4,5.5};

		SafeArray arr2(nums2,5);

		for (int i = 0; i<5; i++) {

			std::cout << "arr2["<<i << "] : " << arr2[i] << std::endl;

		}	

		arr2[5] = 6.6;

	} catch (const InvalidIndex& e) {  // 예외가 발생할 때 

		std::cerr << "boundary exception. index : " << e.getIndex() << std::endl;

		//handling!

	}

	

	 

		

	return 0;

}

※safeArray.h파일

#ifndef SAFEARRAY_H

#define SAFEARRAY_H

#include <cassert>

#include "array.h"

#include "invalidindex.h"



template <typename T>

class SafeArray:public Array<T> {

private:

	

public:

	explicit SafeArray(int size = Array<T>::getDefaultSize());

	SafeArray(const T *pArr, int size);

	virtual ~SafeArray(){} 

	

	bool operator==(const SafeArray<T>& rhs) const;

	

	virtual T& operator[](int index);   

	virtual const T& operator[](int index)const;

};



template <typename T>

SafeArray<T>::SafeArray(int size) 

:Array<T>(size)

{



}



template <typename T>

SafeArray<T>::SafeArray(const T *pArr, int size)

:Array<T>(pArr,size)

{



}



template <typename T>

bool SafeArray<T>::operator==(const SafeArray<T>& rhs) const {

	return this->Array<T>::operator==((Array<T>)rhs);

}



template <typename T>

T& SafeArray<T>::operator[](int index) {

	//assert(index >= 0 && index < this->Array<T>::size_);

	if (index < 0 || index >= this->Array<T>::size_) {

		throw InvalidIndex(index);

	}

	return this->Array<T>::operator[](index);

}



template <typename T>

const T& SafeArray<T>::operator[](int index) const{

	//assert(index >= 0 && index < this->Array<T>::size_);

	if (index < 0 || index >= this ->Array<T>::size_) {

		throw InvalidIndex(index);

	}

	return this->Array<T>::operator[](index);

}



#endif

※invalidindex.h파일

#ifndef INVALIDINDEX_H

#define INVALIDINDEX_H



class InvalidIndex {

private:

	int index_;

protected:



public:

	InvalidIndex(int index);

	int getIndex() const;

};

#endif

※invalidindex.cpp파일

#include "invalidindex.h"



InvalidIndex::InvalidIndex(int index) 

:index_(index)

{



}



int InvalidIndex::getIndex() const

{

	return index_;

}