Pure OOP Sepples

Basically, trying to define a set of types to replace the standard int, char, float, etc... to make C++ more like Ruby. This is what I have so far... not sure what to name a namespace other than perhaps POOP (Pure Object Oriented Programming... obviously very unprofessional), so I haven't tossed them in a namespace yet.

#include <stdint.h>
#include <string>
#include <sstream>

class Int_Obj {
        int32_t Data;
        Int_Obj(int32_t argument) { Data = argument; }
public:

        Int_Obj() {}
   
        Int_Obj operator + (int32_t arg) { return Int_Obj(arg + Data); }
        Int_Obj operator + (Int_Obj arg) { return Int_Obj(arg.Data + Data); }
        Int_Obj operator - (int32_t arg) { return Int_Obj(Data - arg); }
        Int_Obj operator - (Int_Obj arg) { return Int_Obj(Data - arg.Data); }
   
        void operator =  (int32_t arg) { Data = arg; }
        void operator =  (Int_Obj arg) { Data = arg.Data; }
        void operator += (int32_t arg) { Data += arg; }
        void operator += (Int_Obj arg) { Data += arg.Data; }
        void operator -= (int32_t arg) { Data -= arg; }
        void operator -= (Int_Obj arg) { Data -= arg.Data; }
        void operator ++ () { Data++; }
        void operator -- () { Data--; }

        std::string to_s() {
                std::ostringstream out;
                out << Data;
                return out.str();
        }
};

Anyways, any suggestions on what else I might need to add, or how to implement things like Ruby's arrays (can store any number of any types of objects, and are safe from memory leaks)... obviously void pointers aren't exactly an option.

Well, this is what I've got so far...

#include <stdint.h>
#include <sstream>
#include <string>

// Pure Object Types
namespace P_OBJ {

    // For standard integer data types.
    template <class T> class p_obj_type {
                T Data;
    public:
                p_obj_type() {}
                p_obj_type(T argument) { Data = argument; }

                p_obj_type operator + (T arg) { return p_obj_type(arg + Data); }
                p_obj_type operator + (p_obj_type arg) { return p_obj_type(arg.Data + Data); }
                p_obj_type operator - (T arg) { return p_obj_type(Data - arg); }
                p_obj_type operator - (p_obj_type arg) { return p_obj_type(Data - arg.Data); }
       
                bool operator <  (T arg) { return Data < arg; }
                bool operator <  (p_obj_type arg) { return Data < arg.Data; }
                bool operator >  (T arg) { return Data > arg; }
                bool operator >  (p_obj_type arg) { return Data > arg.Data; }
                bool operator == (T arg) { return Data == arg; }
                bool operator == (p_obj_type arg) { return Data == arg.Data; }

                void operator =  (T arg) { Data = arg; }
                void operator =  (p_obj_type arg) { Data = arg.Data; }
                void operator += (T arg) { Data += arg; }
                void operator += (p_obj_type arg) { Data += arg.Data; }
                void operator -= (T arg) { Data -= arg; }
                void operator -= (p_obj_type arg) { Data -= arg.Data; }
                void operator ++ ()    { Data++; }
                void operator ++ (int) { Data++; }
                void operator -- ()    { Data--; }
                void operator -- (int) { Data--; }   

                std::string to_s() {
                        std::ostringstream out;
                        out << Data;
                        return out.str();
                }
        };

}; // P_OBJ
   
typedef P_OBJ::p_obj_type<uint64_t> o_uint64;
typedef P_OBJ::p_obj_type<uint32_t> o_uint;
typedef P_OBJ::p_obj_type<uint16_t> o_ushort;
typedef P_OBJ::p_obj_type<int64_t > o_int64;   
typedef P_OBJ::p_obj_type<int32_t > o_int;
typedef P_OBJ::p_obj_type<int16_t > o_short;
typedef P_OBJ::p_obj_type< double > o_double;
typedef P_OBJ::p_obj_type< float  > o_float;

namespace P_OBJ {
        template <class C> class p_char_obj  {
                char Data;
        public:
                p_char_obj() {}
                p_char_obj(C argument) { Data = argument; }

                p_char_obj operator + (C arg) { return p_char_obj(arg + Data); }
                p_char_obj operator + (p_char_obj arg) { return p_char_obj(arg.Data + Data); }
                p_char_obj operator - (C arg) { return p_char_obj(Data - arg); }
                p_char_obj operator - (p_char_obj arg) { return p_char_obj(Data - arg.Data); }
       
                bool operator <  (C arg) { return Data < arg; }
                bool operator <  (p_char_obj arg) { return Data < arg.Data; }
                bool operator >  (C arg) { return Data > arg; }
                bool operator >  (p_char_obj arg) { return Data > arg.Data; }
                bool operator == (C arg) { return Data == arg; }
                bool operator == (p_char_obj arg) { return Data == arg.Data; }

                void operator =  (C arg) { Data = arg; }
                void operator =  (p_char_obj arg) { Data = arg.Data; }
                void operator += (C arg) { Data += arg; }
                void operator += (p_char_obj arg) { Data += arg.Data; }
                void operator -= (C arg) { Data -= arg; }
                void operator -= (p_char_obj arg) { Data -= arg.Data; }
                void operator ++ ()    { Data++; }
                void operator ++ (int) { Data++; }
                void operator -- ()    { Data--; }
                void operator -- (int) { Data--; }   

                o_int to_i() { o_int result = static_cast<int>(Data); return result; }
                std::string to_s() {
                        std::ostringstream out;
                        out << Data;
                        return out.str();
                }
        };
};

typedef P_OBJ::p_char_obj<char> o_char;
typedef P_OBJ::p_char_obj<unsigned char> o_uchar;

Tried doing template specialization for the p_char_obj to make it just a p_obj_type, didn't work out too well. But I guess I like the idea of a char more like an Ada Character than just an 8 bit number