Микроконтроллеры

Не, ну мне правда лень... Я в двух словах не смогу объяснить перегрузку операторов Но могу для затравки кинуть пример класса. Вот:

//файл Str.h
#ifndef _CPR_STR_H__
#define _CPR_STR_H__
//-------------------------
//V1.00         29 Apr 2003
//(c)Shkola I.
//-------------------------

class CStr {
public:
  CStr();
  ~CStr();

  WCHAR* operator = (WCHAR* sVal);
  operator WCHAR* ();
  CHAR* operator = (CHAR* sVal);
  operator CHAR* ();

private:
  void StoW();
  void WtoS();

  WCHAR *m_ws;
  CHAR  *m_s;
  static HANDLE m_hHeap;
  static int    m_iCnt;
  int    m_iLenWS, m_iLenS;
};

#endif


//Файл Str.cpp
#include 
#include 
#include "Str.h"

#define MAlloc(size)    HeapAlloc(m_hHeap,HEAP_ZERO_MEMORY,(size))
#define MFree(ptr)      HeapFree(m_hHeap,0,(ptr))
#define slenA           lstrlenA
#define slenW           lstrlenW
#define scpyA           lstrcpyA
#ifndef _UNICODE
#define scpyW(s1,s2)    CopyMemory((s1),(s2),(slenW(s2)+1)*2)
#endif

HANDLE CStr::m_hHeap=NULL;
int    CStr::m_iCnt=0;

CStr::CStr()
{
  m_ws=NULL;
  m_s=NULL;
  m_iLenWS=m_iLenS=0;
  if(!m_hHeap) m_hHeap=HeapCreate(0,0,0);
  m_iCnt++;
}

CStr::~CStr()
{
  if(m_s)  MFree(m_s);
  if(m_ws) MFree(m_ws);
  m_iCnt--;
  if(m_iCnt<1 && m_hHeap)
  {
    HeapDestroy(m_hHeap);
    m_hHeap=NULL;
  }
}

WCHAR* CStr::operator = (WCHAR* sVal)
{
  int len=((slenW(sVal)+1) & 0x0fffffc0) + 0x40;

  if(len>m_iLenWS)
  {
    if(m_ws) MFree(m_ws);
    m_ws=(WCHAR*)MAlloc(len*sizeof(WCHAR));
  }
  if(m_ws)
  {
    scpyW(m_ws,sVal);
    m_iLenWS=len;
  }
  else
  {
    m_iLenWS=0;
  }

  return m_ws;
}

CStr::operator WCHAR* ()
{
  if(m_ws) return m_ws;
  if(m_s) StoW();
  return m_ws;
}

CHAR* CStr::operator = (CHAR* sVal)
{
  int len=((slenA(sVal)+1) & 0x0fffffc0) + 0x40;

  if(len>m_iLenS)
  {
    if(m_s) MFree(m_s);
    m_s=(CHAR*)MAlloc(len);
  }
  if(m_s)
  {
    scpyA(m_s,sVal);
    m_iLenS=len;
  }
  else
  {
    m_iLenS=0;
  }

  return m_s;
}

CStr::operator CHAR* ()
{
  if(m_s) return m_s;
  if(m_ws) WtoS();
  return m_s;
}

void CStr::StoW()
{
  if(!m_s) return;
  if(m_ws && m_iLenWS WCHAR*
  if(MultiByteToWideChar(CP_ACP,0,m_s,-1,m_ws,m_iLenWS)==0)
    m_ws[0]=0;
}

void CStr::WtoS()
{
  if(!m_ws) return;
  if(m_s && m_iLenS CHAR*
  if(WideCharToMultiByte(CP_ACP,0,m_ws,-1,m_s,m_iLenS,NULL,NULL)==0)
    m_s[0]=0;
}

//А вот так этот класс может использоваться:
//Файл main.cpp
#include 
#include 
#include 
#include "Classlib\Include\Str.h"

void main()
{
  CStr s1;
  WCHAR *ws1;

  s1="Test";
  ws1=s1;

  printf("Hello, %s\n", (char*)s1);
}

Этот пример, конечно, далеко не для микроконтроллера, но он дает общее представление о том, как делается перегрузка оператора. Если разберешься в примере, свою задачу тебе будет решить легче.