For all of your programming needs and wants.


    Lets make our own string header :D

    Share

    inegames
    Stranger
    Stranger

    Posts : 24
    Join date : 2009-05-05
    Age : 24
    Location : Im not sure

    Lets make our own string header :D

    Post by inegames on 5/19/2009, 11:39 pm

    I had a strange Idea while posting that last topic, why don't we make our own string header, that is easy to use, for the sake of it?

    Ideas:
    + String class
    + String set/get
    + String copy
    + String get length

    Code:
    Code:
    // strings2.h Header
    class string {
    public:
     char* contents;
     int length;
     void set(char* t_char,int t_num)
     {
      length = t_num;
      for(int i=0;i<t_num;i++)
      {
      contents[i] = t_char[i];
      }
     }
     char* get()
     {
      return contents;
     }
     char* get(int t_num)
     {
      // Get certain amount (from start)
      char* t_char;
      for(int i=0;i<t_num;i++)
      {
      t_char[i] = contents[i];
      }
      return t_char;
     }
     char* get(int t_start,int t_end)
     {
      // Get from t_start till t_end
      char* t_char;
      for(int i=t_start;i<t_end;i++)
      {
      t_char[i-t_start] = contents[i];
      }
      return t_char;
     }
    }

    Can someone correct all of that Very Happy Im on a mac thats not mine, so i can't check it and correct it Razz

    GZ
    Stranger
    Stranger

    Posts : 4
    Join date : 2009-10-28

    Re: Lets make our own string header :D

    Post by GZ on 10/28/2009, 8:26 pm

    Code:
    #ifndef __AST_STRING_H__
    #   define __AST_STRING_H__

    #include <string>

    #define WIN32_LEAN_AND_MEAN
    #include <windows.h>

    typedef unsigned int Uint32;

    #ifdef UNICODE
    #   define String StringW
    #else
    #   define String StringA
    #endif

    #define BSTRING(T, StrVer) public BString<T, StrVer>

    //   String base class ( T: string/wstring, StrVer: StringA/W )
    template < typename T > class BString {

       public:
          //   type definitions

          //   type of string (char or wchar_t)
          typedef typename T::_Alloc::value_type _Ty_Ty;
          typedef const _Ty_Ty _Ty_CTy;

          //   create the template parameter as a type
          typedef typename T _Ty;

          typedef BString<T> _Sv;

       protected:
          //   InStr is internal std::(w)string
          _Ty InStr;

          //   handle concatenation
          _Sv _OpPlus ( void* _Data, bool _Wide, Uint32 _Len  ) {
             _Sv Ret;
             Ret.InStr = InStr;
             if ( _Wide ) {
                for ( Uint32 i = 0; i < _Len; i++ ) {
                   Ret.InStr += (_Ty_Ty)((wchar_t*)_Data)[i];
                }
             } else {
                for ( Uint32 i = 0; i < _Len; i++ ) {
                   Ret.InStr += (_Ty_Ty)((char*)_Data)[i];
                }
             }

             return Ret;
          }
          

       public:

          void Clear ( ) {
             if ( !InStr.empty ( ) )
                InStr.clear ( );
          }

          //   return internal string
          _Ty& GetStdStr ( ) {
             return InStr;
          }

          _Ty& GSS ( void ) {
             return InStr;
          }

          /* CONSTRUCTORS */
          BString<_Ty> ( ) { }

          BString<_Ty> ( LPSTR _Str ) {
             operator= ( _Str );
          }

          BString<_Ty> ( LPCSTR _Str ) {
             operator=(_Str);
          }

          BString<_Ty> ( LPWSTR _Str ) {
             operator=(_Str);
          }

          BString<_Ty> ( LPCWSTR _Str ) {
             operator=(_Str);
          }

          /* OVERLOADED OPERATORS */
          _Sv operator * ( Uint32 _Cnt ) {
             _Ty Str = InStr;
             for ( Uint32 i = 0; i < _Cnt; i++ ) {
                Str += InStr;
             }
             _Sv Ret;
             Ret.InStr = Str;
             return Ret;
          }

          void operator *= ( Uint32 _Cnt ) {
             InStr = operator*(_Cnt).InStr;
          }

          _Ty_Ty& operator[] ( Uint32 _Cnt ) {
             return InStr[_Cnt];
          }

          _Sv operator + ( char _Chr ) {
             return _OpPlus ( (void*)&_Chr, false, 1 );
          }

          _Sv operator + ( LPSTR _Str ) {
             return _OpPlus ( (void*)_Str, false, strlen ( const_cast<char*> ( _Str ) ) );
          }

          _Sv operator + ( LPCSTR _Str ) {
             return _OpPlus ( (void*)_Str, false, strlen ( _Str ) );
          }

          _Sv operator + ( wchar_t _Chr ) {
             return _OpPlus ( (void*)&_Chr, true, 1 );
          }

          _Sv operator + ( LPWSTR _Str ) {
             return _OpPlus ( (void*)_Str, true, wcslen ( const_cast<char*> ( _Str ) ) );
          }

          _Sv operator + ( LPCWSTR _Str ) {
             return _OpPlus ( (void*)_Str, true, wcslen ( _Str ) );
          }

          _Sv operator + ( BString <std::string> _Str ) {
             return _OpPlus ( (void*)_Str.c_str ( ), false, _Str.GSS().size ( ) );
          }

          _Sv operator + ( BString <std::wstring> _Str ) {
             return _OpPlus ( (void*)_Str.c_str ( ), true, _Str.GSS().size ( ) );
          }

          void operator += ( char _Chr ) {
             InStr += operator+(_Chr).InStr;
          }

          void operator += ( LPSTR _Str ) {
             InStr += operator+(_Str).InStr;
          }

          void operator += ( LPCSTR _Str ) {
             InStr += operator+(_Str).InStr;
          }

          void operator += ( wchar_t _Chr ) {
             InStr += operator+(_Chr).InStr;
          }

          void operator += ( LPWSTR _Str ) {
             InStr += operator+(_Str).InStr;
          }

          void operator += ( LPCWSTR _Str ) {
             InStr += operator+(_Str).InStr;
          }

          void operator += ( BString<std::string> _Str ) {
             InStr += operator+(_Str).InStr;
          }

          void operator += ( BString<std::wstring> _Str ) {
             InStr += operator+(_Str).InStr;
          }

          void operator = ( LPSTR _Str ) {
             Clear ( );
             InStr = operator+( _Str ).InStr;
          }

          void operator = ( LPCSTR _Str ) {
             Clear ( );
             InStr = operator+( _Str ).InStr;
          }

          void operator = ( LPWSTR _Str ) {
             Clear ( );
             InStr = operator+( _Str ).InStr;
          }

          void operator = ( LPCWSTR _Str ) {
             Clear ( );
             InStr = operator+( _Str ).InStr;
          }

          void operator = ( BString<std::string> _Str ) {
             Clear ( );
             for ( Uint32 i = 0; i < _Str.GSS ( ).size ( ); i++ ) {
                InStr += (_Ty_Ty)_Str[i];
             }
          }

          void operator = ( BString<std::wstring> _Str ) {
             Clear ( );
             for ( Uint32 i = 0; i < _Str.GSS ( ).size ( ); i++ ) {
                InStr += (_Ty_Ty)_Str[i];
             }
          }

          BString<std::string> ASCII ( ) {
             return BString<std::string> ( InStr.c_str ( ) );
          }

          BString<std::wstring> Unicode ( ) {
             return BString<std::wstring> ( InStr.c_str ( ) );
          }

    };

    typedef BString<std::string> StringA;
    typedef BString<std::wstring> StringW;

    #endif /* __AST_STRING_H__ */

    That string class is to be a part of the AST-GDK, and is mostly to be used for containing and using Unicode and ASCII values at once. It doesn't serve much functionality other than that, though.

    Example:
    Code:
    // On Unicode-enabled systems, String will be replaced with
    // StringW, which is a string class that holds text as wide-characters
    // (Unicode) internally.
    String MyString = "Hi! This is an ASCII string!";
    MessageBoxW ( NULL, MyString.Unicode ( ).GSS ( ).c_str ( ), L"Hello!", 0 );
    (Note, the 'L' before the "Hello!" string is supposed to be there.)

      Current date/time is 12/16/2017, 11:59 pm