SRL Archive - C/C++ Help and Tutorials

        int size() {return DataHolder.size();}                    //This is to grab the size of our underlying vector.
        
        ArrayOfAnything& operator [](int I)                        //We overload the subscript operator
        {
            assert(I >= 0 && !DataHolder.empty());
                return DataHolder[I];                            //return the value in our vector at index I.
        }
        
        const ArrayOfAnything& operator [](int I) const            //Same thing as above except this is the const overload.
        {
            assert(I >= 0 && !DataHolder.empty());
                return DataHolder[I];                            //return the value in our vector at index I.
        }        

        ArrayOfAnything& operator << (const T& t)                 //So we want to just insert one value at a time.. Thus we  overload the insertion operator.
        {
            DataHolder.push_back(t);
            return *this;
        }
        
        void SetLength(size_t NewLength)                //Ahh the  magical SetLength function. If for any reason we want to resize our  vector/array, we use this.
        {
            DataHolder.resize(NewLength);
        }

        template<typename A, typename... Args>
        ArrayOfAnything& operator ()(A FirstArg, const Args...  RemainingArgs)        //We are overloading the parameters operator. This  allows us to recursively add infinite parameters
        {                                                                            //Without calling the constructor again.
            this->DataHolder.push_back(FirstArg);
            Insert(RemainingArgs...);
            return *this;
        }

        friend ostream& operator << (ostream& Str, const  ArrayOfAnything &AOA)    //Aha! Now this is where the real stuff  come in. We overload the output operator!
        {                                                                         //We want our array to print nicely and naturally without  having to print each value one by one with a for-loop
            if (!AOA.DataHolder.empty())                                         //First we check if we are empty.. if we are, there is nothing  to print so forget it.
            {
                Str<<"[";                                                 //We want our array to print like:  [a, b, c, d]    So we put a  bracket outside the loop.
                for (size_t I = 0; I < AOA.DataHolder.size() - 1;  I++)    //We loop through our array until the second last element. Why?  Because we don't want an extra comma.
                {                                                         //If we do until the last one, it will print like:  [a, b, c, d,]  <-- extra comma
                    Str<<AOA.DataHolder[I];                                 //Our array's Data will be added to our Output string..
                    Str<<", ";                                             //Let us add a comma and a space after each value added to our  string/output.
                }
                Str<<AOA.DataHolder[AOA.DataHolder.size() - 1];             //Finally we get the last element we had in our array but we  don't add a comma.
                Str<<"]";                                                //Outside our for-loop, we add the final bracket.
            }
            else
            {
                Str<<"[]";                                                 //If our array was empty, we just print some nice brackets to  let the user know it's blank.
            }
            return Str;                                                     //Finally we return the output/data/string we just created which  holds all our data.
        }

#include "ArrayOfAnything.h"    //This header file holds our class for us =]


int main()
{
    cout.flags(ios::boolalpha);        //So it prints true and false instead of 1 & 0.
    
    ArrayOfAnything<int> IA(1, 2, 3, 4, 5, 6, 7, 8, 9);             //notice we can have any amount of parameters.. Don't stop at 9 :D
    ArrayOfAnything<int> IA2(1, 5, 9, 7);                    //Like I said.. Any amount.
    ArrayOfAnything<int> IA3;                    //Yeah I know it's empty.
    ArrayOfAnything<int> IA4;                    //Also empty.

     IA3<<1 << 5 << 9 << 7;                    //Just add any amount u want.
    IA4(1, 2, 3, 4, 5, 6, 7, 8, 9);            //Can also add values to it like that.

     cout<< IA <<endl;            //This should print [1, 2, 3, 4, 5, 6, 7, 8, 9];

     cout<<(IA2 == IA3) <<endl;    //This should print true because IA2 and IA3 have the same values.

     cout<<(IA != IA4)  <<endl;    //This should print false  because IA1 and IA4 are the exact same! They have the same values.


      ArrayOfAnything<ArrayOfAnything<int> > I2DA;                //This is a 2dimension array of integers.

     I2DA<<IA;                                                //We just inserted an array of ints into the 2D array.
    I2DA(IA2, IA3);                        //Inserted two more.
    I2DA<<IA4;                            //Added another one!

     cout<<I2DA    <<endl;                    //This should  print [[1, 2, 3, 4, 5, 6, 7, 8, 9], [1, 5, 9, 7], [1, 5, 9, 7], [1, 2,  3, 4, 5, 6, 7, 8, 9]];

     ArrayOfAnything<ArrayOfAnything<ArrayOfAnything<string> > > S3DA;        //This is a 3D Array of Strings.
    ArrayOfAnything<ArrayOfAnything<double> > D2DA;                        //This is a 2D array of Doubles.

     //The dimensions can go on and on forever with an infinite amount of  values if your comp has enough memory which it most certainly does.
}

#ifndef TEMPLATES_H_INCLUDED
#define TEMPLATES_H_INCLUDED
using namespace System;
using namespace System::Collections::Generic;

template <typename T>
public ref class CustomType sealed
{
    private:
        List<T> TypeData;

    public:
        CustomType() {}
        CustomType(...array<T^> ^Types)            //Basically Variadic Templates.. As good as it gets for MS2010..
        {
            for each (T^ t in Types)
            {
                TypeData.Add(*t);
            }
        }
        ~CustomType() {}

        int size(){ return (TypeData.Count); }

        T^ operator [](int I)
        {
            if ((I < 0) || (this->size() == 0) || (I > this->size()))
                throw gcnew System::ArgumentException("Parameter cannot be null");

            return TypeData[I];
        }

        void operator()(...array<T^> ^Types)
        {
            for each (T^ t in Types)
            {
                TypeData.Add(*t);
            }
        }

        operator const List<T>^ ()
        {
            return TypeData;
        }

        bool operator == (CustomType %CT)
        {
            for (int I = 0; I < CT.size(); I++)
            {
                if (this->TypeData[I] != CT.TypeData[I])
                    return false;
            }
            return true;
        }

        bool operator != (CustomType %CT)
        {
            for (int I = 0; I < CT.size(); I++)
            {
                if (this->TypeData[I] == CT.TypeData[I])
                    return false;
            }
            return true;
        }

        CustomType% operator = (CustomType %CT)
        {
            if (this != %CT)
            {
                if (this->size() > 0)
                    TypeData.Clear();

                for (int I = 0; I < CT.size(); I++)
                    TypeData.Add(CT.TypeData[I]);
            }
            return *this;
        }

        CustomType% operator << (const T% t)
        {
            TypeData.Add(t);
            return *this;
        }

        CustomType% operator << (CustomType %CT)
        {
            for (int I = 0; I < CT.size(); I++)
            {
                TypeData.Add(*CT[I]);
            }
            return *this;
        }

        CustomType% Clear()
        {
            TypeData.Clear();
            return *this;
        }

        CustomType% Clear (const T% t)
        {
            TypeData.Remove(t);
            return *this;
        }

        CustomType% Clear (CustomType %CT)
        {
            for (int I = 0; I < CT.size(); I++)
            {
                TypeData.Remove(*CT[I]);
            }
            return *this;
        }

        CustomType% ClearAt (int I)
        {
            TypeData.RemoveAt(I);
            return *this;
        }

        CustomType% Insert (const T% Value, int Index)
        {
            TypeData.Insert(Index, Value);
            return *this;
        }

        CustomType% Insert (CustomType %CT, int Index)
        {
            for (int I = 0; I < CT.size(); I++)
            {
                TypeData.Insert(Index++, *CT[I]);
            }
            return *this;
        }

        virtual String^ ToString() override
        {
            String^ Str;
            if (this->size() != 0)
            {
                Str = "[";
                for (int I = 0; I < this->size() - 1; I++)
                {
                    Str += TypeData[I];
                    Str += ", ";
                }
                Str += TypeData[this->size() - 1];
                Str += "]";
            }
            else
            {
                Str += "[]";
            }
            return Str;
        }
};

#endif // TEMPLATES_H_INCLUDED