growable array

/*
#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 <iostream>
#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] = 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();


    return 0;
}

 

 

 

 

#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);

 

 

 

 

#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__
*/