잡1
#ifndef __GROWABLE_ARRAY_H__
#define __GROWABLE_ARRAY_H__
#include "Array.h"
using namespace std;
template <typename T>
class GrowableArray :public Array<T> {
public:
GrowableArray(int size);
virtual T &operator[] (int i) override;
};
// 생성자
template <typename T>
GrowableArray<T>::GrowableArray(int size) {
// size가 0 이하의 값이면 에러메시지를 출력하고 종료
if (size <= 0) {
cerr << "Negative size error!\n";
exit(-1);
}
// size가 양수이면 new를 사용하여 배열 data를 할당, len 값 초기화
this->data = new T[size];
if (this->data == NULL) {
cerr << "Memory allocation error!\n";
exit(-1);
}
this->len = size;
}
// 배열에 원소를 대입하거나 값을 반환하는 부분으로 []연산자의 다중정의이다.
template <typename T>
T &GrowableArray<T>::operator[] (int i){ // left value : 배열에 원소를 삽입
// 배열의 인덱스가 범위 내에 있으면 해당 원소를 리턴
if (0 <= i && i < this->len) {
return this->data[i];
}
// 그렇지 않으면 사이즈가 가능할 때까지 크기를 2배 늘려서 추가된 공간은 0으로 초기화
else {
// 필요한 만큼 크기를 확보
int new_len = this->len;
while (new_len <= i)
new_len *= 2;
// 새로운 배열에 메모리를 할당
T *new_data = new T[new_len];
if (new_data == NULL) {
cerr << "Memory allocation error!\n";
exit(-1);
}
// 새로운 배열에 기존 배열의 내용을 복사
for (int i = 0; i < this->len; i++)
new_data[i] = this->data[i];
for (int i = this->len; i < new_len; i++)
new_data[i] = 0;
// 기존 배열의 메모리를 해제
T *t = this->data;
this->data = new_data;
this->len = new_len;
delete[] t;
// 0을 반환
return this->data[i];
}
}
#endif // __GROWABLE_ARRAY_H__
//////////////////////////////////////////////
#include <stdio.h>
#include <malloc.h>
#include <stdlib.h>
#define BNUM 256
#define LIMIT 72
void Remove_Blanks_At_The_End(char *line);
void Print_Line(char *line, int *Count, int *B_Flag);
void Get_Blanks_Chars(char *line, int Start, int *N_Blanks, int *N_Chars);
///////////////////////////////////////////////////////////////////////////////////
#include <iostream>
#include <windows.h>
#include "GrowableArray.h"
using namespace std;
/*
int main(void) {
cout << "GrowableArray<int> Test" << endl;
GrowableArray<int> g(10);
int i;
for (i = 0; i < g.length(); i++)
{
g[i] =(int) (2 * i + 3);
}
cout << "g(10)"; g.print();
g[13]=13;
cout << "g(26)"; g.print();
// GrowableArray test (double)
cout << "GrowableArray<double> Test" << endl;
GrowableArray<double> dg(10);
for (i = 0; i < dg.length(); i++) dg[i] = 2 * i + 3.14;
cout << "dg(10)"; dg.print();
dg[13] = 13.31;
cout << "dg(26)"; dg.print();
system("pause");
return 0;
}*/
///////////////////////////////////////
#ifndef __ARRAY__
#define __ARRAY__
#include <iostream>
#include <cstdlib>
using namespace std;
template <typename T>
class Array{
protected:
T *data;
int len;
public:
Array() {};
Array(int size);
~Array();
int length() const;
virtual T& operator[](int i);
virtual T operator[](int i) const;
void print();
};
// 생성자
template <typename T>
Array<T>::Array (int size) {
// size가 0 이하의 값이면 에러메시지를 출력하고 종료
if(size <= 0) {
cerr << "Negative size error!\n";
exit(-1);
}
// size가 양수이면 new를 사용하여 배열 data를 할당, len 값 초기화
data = new T[size];
if(data == NULL) {
cerr << "Memory allocation error!\n";
exit(-1);
}
len = size;
}
// 소멸자; 할당된 메모리 해제
template <typename T>
Array<T>::~Array (void) {
delete[] data;
}
// 배열의 크기 리턴
template <typename T>
int Array<T>::length (void) const {
return len;
}
// 배열에 원소를 대입하거나 값을 반환하는 부분으로 []연산자의 다중정의이다.
template <typename T>
T & Array<T>::operator[] (int i) { // left value : 배열에 원소를 삽입
static T tmp;
// 배열의 인덱스가 범위 내에 있으면 해당 원소를 리턴
if(0 <= i && i < len) {
return data[i];
}
// 그렇지 않으면 에러 메시지 출력하고 tmp를 리턴
else {
cerr << "Array bound error!\n";
return tmp;
}
}
template <typename T>
T Array<T>::operator[] (int i) const { // right value : 배열의 원소의 값을 반환
// 배열의 인덱스가 범위 내에 있으면 값을 리턴
if(0 <= i && i < len) {
return data[i];
}
// 그렇지 않으면 에러 메시지를 출력하고 0을 리턴
else {
cerr << "invalid size parameter (0 <= i < len)\n";
return 0;
}
}
// 배열의 모든 내용을 출력해주는 함수
template <typename T>
void Array<T>::print (void) {
cout << '[';
for(int i = 0; i < len; i++) {
cout << ' ' << data[i];
}
cout << "]\n";
}
#endif // __ARRAY__