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 where caught";
        }
    };
}

template<class T>
class SYArray {
private:
	T *arr;

public:
	int length;
	SYArray() {
		length = 0;
		arr = new T[0];
	}

SYArray(T arr[], int length) {
		this->arr = arr;
		this->length = length;
	}
    
    SYArray(const SYArray &copy):arr(copy.arr) , length(copy.length) {}
    
    SYArray(int length) {
        arr=new T[length];
        this->length=length;
    }

SYArray<T> concat(SYArray<T> arr2) {
		SYArray<T> temp;
		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);
        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);
        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);
        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);
    }
    
    SYArray<T> fill(T value,int s) {
        for (int i=s;i<length;i++) {
            arr[i]=value;    
        }
        return SYArray<T>(arr,length);
    }
    
    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;
        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;
        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;
		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;
        int c_index=0;
        for (int i=0;i<length;i++) {
            temp.push(f(arr[i],c_index));
            c_index++;
        }
        return temp;
    }

T pop() {
		T temp = arr[length - 1];
		arr[length] = arr[length + 1];
		length--;
		return temp;
	}

int push(T value) {
		arr[length] = value;
		length++;
		return length;
	}
    
    T reduce(function<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,int)> f) {
        T total=arr[0];
        int c_index=0;
        for (int i=1;i<length;i++) {
            total=f(total,arr[i]);
            c_index++;
        }
        return total;
    }

T reduce(function<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,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;
    }
    
    T reduceRight(function<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)> 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,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,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;
        if (length%2==0) {
            for (int i=length-1;i>=0;i--) {
                copy.push(arr[i]);
            }
        }
        return copy;
    }
    
    T shift() {
        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);
    }
    
    SYArray<T> slice(int s) {
        SYArray<T> temp;
        for (int i=s;i<length;i++) {
            temp.push(arr[i]);
        }
        return temp;
    }
    
    SYArray<T> slice(int s,int e) {
        SYArray<T> temp;
        for (int i=s;i<e;i++) {
            temp.push(arr[i]);
        }
        return temp;
    }
    
    template<class S>
    bool some(S &&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);
    }
    
    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);
    }
    //SYArray<T> splice()
    
    /*
    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);
    }

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;
    }
};

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);
    
    /*
    cout << arr.reduce([](int n,int m) {
        cout << m << "    " << n << endl;
        return n+m;
    },0);
    */
    cout << arr.sort([](int n,int m) {
        return n<m;
    }) << endl;
    return 0;
}

Show compiler warnings [ + ] Compiler args [ + ] Show input
Compilation time: 0.42 sec, absolute running time: 0.08 sec, cpu time: 0.02 sec, memory peak: 3 Mb, absolute service time: 0,51 sec