javascript style arrays in c++, C++ (gcc)

Language: Layout:

#include <iostream>
#include <sstream>
#include <string>
#include <functional>
#include <exception>
using namespace std;

namespace SYArrayExceptions {
    class indexOutOfBoundException:public exception {
        public:
        virtual const char* what() const throw() {
            return "Error:index out of bound exception has been caught";
        }
    };
    
    class stackUnderFlowException:public exception {
        public:
        virtual const char* what() const throw() {
            return "Error:stack underflow exception has been caught";
        }
    };
}

namespace SYArrayInfo {
    static int NOI=0;
    
}

template<class T>
class SYArray {
private:
	T *arr=(T*)malloc(0);
    SYArray(bool isPrivate) {
        length=0;
    }
    
    SYArray(T _arr[],int _length,bool isPrivate) {
        length=_length;
        arr=(T*)realloc(arr,sizeof(T)*length);
        for (int i=0;i<length;i++) {
            arr[i]=_arr[i];
        }
    }
    
public:
    int length;
	SYArray() {
        SYArrayInfo::NOI++;
		length = 0;
		arr = (T*)realloc(arr,0);
	}

SYArray(T _arr[], int _length) {
        SYArrayInfo::NOI++;
		length = _length;
        arr = (T*)realloc(arr,length);
        for (int i=0;i<length;i++) {
            arr[i]=_arr[i];
        }
	}
    
    SYArray(const SYArray &copy) : arr(copy.arr) , length(copy.length) {
        SYArrayInfo::NOI++;
    }
    
    SYArray(int _length) {
        SYArrayInfo::NOI++;
        arr=(T*)realloc(arr,sizeof(T)*length);
        length=_length;
    }

SYArray<T> concat(SYArray<T> arr2) {
		SYArray<T> temp(true);
		for (int i = 0; i < length; i++) {
			temp.push(arr[i]);
		}
		for (int i = 0; i < arr2.length; i++) {
			temp.push(arr2[i]);
		}
		return temp;
	}
    
    SYArray<T> copyWithin(int t) {
        SYArray<T> temp(arr,length,true);
        for (int i=0;i<length;i++) {
            temp[i+t]=temp[i];
        }
        return temp;
    }
    
    SYArray<T> copyWithin(int t,int s) {
        SYArray<T> temp(arr,length,true);
        for (int i=s;i<length;i++) {
            temp[i+t]=temp[i];
        }
        return temp;
    }
    
    SYArray<T> copyWithin(int t,int s,int e) {
        SYArray<T> temp(arr,length,true);
        for (int i=s;i<e;i++) {
            temp[i+t]=temp[i];
        }
        return temp;
    }
    
    bool every(function<bool(T)> f) {
        for (int i=0;i<length;i++) {
            if (!f(arr[i])) {
                return false;
            }
        }
        return true;
    }
    
    bool every(function<bool(T,int)> f) {
        int c_index=0;
        for (int i=0;i<length;i++) {
            if (!f(arr[i],c_index)) {
                return false;
            }
            c_index++;
        }
        return true;
    }
    
    SYArray<T> fill(T value) {    
        for (int i=0;i<length;i++) {
            arr[i]=value;
        }
        return SYArray<T>(arr,length,true);
    }
    
    SYArray<T> fill(T value,int s) {
        for (int i=s;i<length;i++) {
            arr[i]=value;    
        }
        return SYArray<T>(arr,length,true);
    }
    
    SYArray<T> fill(T value,int s,int e) {
        for (int i=s;i<e;i++) {
            arr[i]=value;
        }
        return SYArray<T>(arr,length);
    }
    
    SYArray<T> filter(function<bool(T)> f) {
        SYArray<T> temp(true);
        for (int i=0;i<length;i++) {
            if (f(arr[i])) {
                temp.push(arr[i]);
            }
        }
        return temp;
    }

SYArray<T> filter(function<bool(T,int)> f) {
        SYArray<T> temp(true);
        int c_index=0;
        for (int i=0;i<length;i++) {
            if (f(arr[i],c_index)) {
                temp.push(arr[i]);
            }
            c_index++;
        }
        return temp;
    }

T find(function<bool(T)> f) {
        for (int i=0;i<length;i++) {
            if (f(arr[i])) {
                return arr[i];
            }
        }
    }

T find(function<bool(T,int)> f) {
        int c_index=0;
        for (int i=0;i<length;i++) {
            if (f(arr[i],c_index)) {
                return arr[i];
            }
            c_index++;
        }
    }
    
    int findIndex(function<bool(T)> f) {
        for (int i=0;i<length;i++) {
            if (f(arr[i])) {
                return i;
            }
        }
        return -1;
    }
    
    int findIndex(function<bool(T,int)> f) {
        int c_index=0;
        for (int i=0;i<length;i++) {
            if (f(arr[i],c_index)) {
                return i;
            }
            c_index++;
        }
        return -1;
    }
    
    void forEach(function<void(T)> f) {
        for (int i=0;i<length;i++) {
            f(arr[i]);
        }
    }
    
    void forEach(function<void(T,int)> f) {
        int c_index=0;
        for (int i=0;i<length;i++) {
            f(arr[i],c_index);
            c_index++;
        }
    }
    
    int lastIndexOf(T key) {
        for (int i=length-1;i>=0;i--) {
            if (arr[i]==key) {
                return i;
            }
        }
        return -1;
    }

int lastIndexOf(T key,int s) {
        for (int i=length-1;i>=s;i--) {
            if (arr[i]==key) {
                return length-1-s;
            }
        }
        return -1;
    }
    
    int indexOf(T key) {
        for (int i=0;i<length;i++) {
            if (arr[i]==key) {
                return i;
            }
        }
        return -1;
    }
    
    int indexOf(T key,int s) {
        for (int i=s;i<length;i++) {
            if (arr[i]==key) {
                return i;
            }
        }
        return -1;
    }
    
    string join(string separator=",") {
        stringstream result;
        for (int i=0;i<length;i++) {
            result << arr[i];
            if (i!=length-1) {
                result << separator;
            }
        }
        return result.str();
    }

SYArray<T> map(function<T(T)> f) {
		SYArray<T> temp(true);
		for (int i = 0; i < length; i++) {
			temp.push(f(arr[i]));
		}
		return temp;
	}
    
    SYArray<T> map(function<T(T,int)> f) {
        SYArray<T> temp(true);
        int c_index=0;
        for (int i=0;i<length;i++) {
            temp.push(f(arr[i],c_index));
            c_index++;
        }
        return temp;
    }

T pop() {
        if (length==0) {
            throw SYArrayExceptions::stackUnderFlowException();
        }
		T temp = arr[length - 1];
		arr[length] = arr[length + 1];
		length--;
        this->arr=(T*)realloc(this->arr,length);
		return temp;
	}

int push(T value) {
		length++;
        arr=(T*)realloc(arr,sizeof(T)*length);
        arr[length-1]=value;
		return length;
	}
    
    T reduce(function<T(T,T)> f) {
        T total=arr[0];
        for (int i=1;i<length;i++) {
            total=f(total,arr[i]);
        }
        return total;
    }

T reduce(function<T(T,T,int)> f) {
        T total=arr[0];
        int c_index=0;
        for (int i=1;i<length;i++) {
            total=f(total,arr[i],c_index);
            c_index++;
        }
        return total;
    }

T reduce(function<T(T,T)> f,T initial) {
        T total=initial;
        for (int i=1;i<length;i++) {
            total=f(total,arr[i]);
        }
        return total;
    }

T reduce(function<T(T,T,int)> f,T initial) {
        T total=initial;
        int c_index=0;
        for (int i=0;i<length;i++) {
            total=f(total,arr[i],c_index);
            c_index++;
        }
        return total;
    }
    
    T reduceRight(function<T(T,T)> f) {
        T total=arr[length-1];
        for (int i=length-2;i>=0;i--) {
            total=f(total,arr[i]);
        }
        return total;
    }

T reduceRight(function<T(T,T)> f,T initial) {
        T total=initial;
        for (int i=length-2;i>=0;i--) {
            total=f(total,arr[i]);
        }
        return total;
    }

T reduceRight(function<T(T,T,int)> f) {
        T total=arr[length-1];
        int c_index=0;
        for (int i=length-2;i>=0;i--) {
            total=f(total,arr[i]);
            c_index++;
        }
        return total;
    }
    
    T reduceRight(function<T(T,T,int)> f,T initial) {
        T total=initial;
        int c_index=0;
        for (int i=0;i<length;i++) {
            total=f(total,arr[i]);
            c_index++;
        }
        return total;
    }
    
    SYArray<T> reverse() {
        SYArray<T> copy(true);
        if (length%2==0) {
            for (int i=length-1;i>=0;i--) {
                copy.push(arr[i]);
            }
        }
        return copy;
    }
    
    T shift() {
        if (length==0) {
            throw SYArrayExceptions::stackUnderFlowException();
        }
        T temp=arr[0];
        for (int i=0;i<length;i++) {
            arr[i]=arr[i+1];
        }
        length--;
        return temp;
    }
    
    SYArray<T> slice() {
        return SYArray<T>(arr,length,true);
    }
    
    SYArray<T> slice(int s) {
        SYArray<T> temp(true);
        for (int i=s;i<length;i++) {
            temp.push(arr[i]);
        }
        return temp;
    }
    
    SYArray<T> slice(int s,int e) {
        SYArray<T> temp(true);
        for (int i=s;i<e;i++) {
            temp.push(arr[i]);
        }
        return temp;
    }
    
    bool some(function<bool(T)> f) {
        for (int i=0;i<length;i++) {
            if (f(arr[i])) {
                return true;
            }
        }
        return false;
    }
    
    SYArray<T> sort() {
        T temp;
        for (int i=0;i<length;i++) {
            for (int j=i;j<length;j++) {
                if (i==j) {
                    continue;
                }
                else if (arr[i]>arr[j]) {
                    temp=arr[i];
                    arr[i]=arr[j];
                    arr[j]=temp;
                }
            }
        }
        return SYArray<T>(arr,length,true);
    }
    
    SYArray<T> sort(function<bool(T,T)> f) {
        T temp;
        for (int i=0;i<length;i++) {
            for (int j=i;j<length;j++) {
                if (i==j) {
                    continue;
                }
                else if (f(arr[i],arr[j])>0) {
                    temp=arr[i];
                    arr[i]=arr[j];
                    arr[j]=temp;
                }
            }
        }
        return SYArray<T>(arr,length,true);
    }
    
    SYArray<T> splice(int index) {
        SYArray<T> temp(true);
        for (int i=length-1;i>=index;i--) {
            temp.push(arr[i]);
            length--;
        }
        temp=temp.reverse();
        return temp;
    }
    
    /*
    SYArray<T> splice(int d,SYArray<T> arr2) {
        SYArray<T> temp(arr,d);
        temp=temp.concat(arr2);
        for (int i=d;i<length;i++) {
            temp.push(arr[i]);
        }
        T *copy=new T[temp.length];
        for (int i=0;i<d;i++) {
            copy[i]=arr[i];
        }
        for (int i=1;i<arr2.length;i++) {
            c
        }
        return temp;
    }
    */
    
    string toString() {
        stringstream result;
        for (int i=0;i<length;i++) {
            result << arr[i];
            if (i!=length-1) {
                result << ",";
            }
        }
        return result.str();
    }
    
    int unshift(T value) {
        T temp;
        for (int i=length-1;i>=0;i--) {
            arr[i+1]=arr[i];
        }
        arr[0]=value;
        length++;
        return length;
    }
    
    SYArray<T> valueOf() {
        return SYArray<T>(arr,length,true);
    }

T &operator [](int index) {
        if (index<0 || index>=length) {
            throw SYArrayExceptions::indexOutOfBoundException();
        }
		return arr[index];
	}
    
    friend ostream& operator<<(ostream &os,const SYArray<T> &arr2) {
        for (int i=0;i<arr2.length;i++) {
            os << arr2.arr[i];
            if (i!=arr2.length-1) {
                os << " , ";
            }
        }
        return os;
    }
    
    friend istream& operator>>(istream &is,SYArray<T> &arr2) {
        for (int i=0;i<arr2.length;i++) {
            is >> arr2[i];
        }
        return is;
    }
    
    //non-standard methods in javascript
    
    T sumArray() {
        T s=0;
        for (int i=0;i<length;i++) {
            s += arr[i];
        }
        return s;
    }
    
    T productArray() {
        int s=1;
        for (int i=0;i<length;i++) {
            s *= arr[i];
        }
        return s;
    }
    
    //destructor
    ~SYArray() {
        length=0;
        SYArrayInfo::NOI--;
        free(arr);
    }
};

int main() {
    int x=4;
    
    int a[x]={2,4,2,6};//{2,6,8,6,9,3,5,2};
	SYArray<int> arr(a,x);
    SYArray<char*> arr2;
    arr2.push("hhhhhhh");
    
    /*
    cout << arr.reduce([](int n,int m) {
        cout << m << "    " << n << endl;
        return n+m;
    },0);
    */
    //cout << arr.splice(2) << endl;
    //arr.length=8;
    /*
    for (int i=0;i<5000;i++)
        arr.push(i+1);
        */
    //arr.~SYArray();
    //b.~SYArray();
    arr.unshift(98);
    cout << arr << endl << arr2 << endl;
    cout << SYArrayInfo::NOI << endl;
    /*
    arr.pop();
    arr.pop();
    arr.pop();
    arr.pop();
    */
    return 0;
}

Show compiler warnings [ + ] Compiler args [ + ] Show input
Compilation time: 0.67 sec, absolute running time: 0.23 sec, cpu time: 0.05 sec, memory peak: 3 Mb, absolute service time: 0,97 sec