Lets make our own string header :D

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 Im on a mac thats not mine, so i can't check it and correct it

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.)