获取控制台程序输入信息

文件ProgramExec.h

//---------------------------------------------------------------------------

#ifndef ProgramExecH
#define ProgramExecH

#include "MyUnicodeString.h"
//---------------------------------------------------------------------------
DWORD WINAPI ReadFromPipe(LPVOID args);

/* globals */

#define CHUNK 25
#define STATICBUFFERSIZE    1000
typedef struct {
 HANDLE pipe;
 char buffer[STATICBUFFERSIZE];
} pipeinfo;

pipeinfo Out = { INVALID_HANDLE_VALUE, '/0' };
pipeinfo Err = { INVALID_HANDLE_VALUE, '/0' };
MyUnicodeString* myUnicodeString;

void execProgram(UnicodeString& cmd,MyUnicodeString& _myUnicodeString,int& returnCode)
{
 STARTUPINFOW si;
 PROCESS_INFORMATION pi;
 SECURITY_ATTRIBUTES sa;
 DWORD threadID;
 char msg[300];
 BOOL ok;
 HANDLE hProcess, h, pipeThreads[2];
 char cmdline[100];
 myUnicodeString = &_myUnicodeString;

 hProcess = GetCurrentProcess();

 ZeroMemory(&pi, sizeof(PROCESS_INFORMATION));
 ZeroMemory(&si, sizeof(STARTUPINFOW));
 si.cb = sizeof(STARTUPINFOW);
 si.dwFlags = STARTF_USESTDHANDLES;
 si.hStdInput = INVALID_HANDLE_VALUE;

 ZeroMemory(&sa, sizeof(SECURITY_ATTRIBUTES));
 sa.nLength = sizeof(SECURITY_ATTRIBUTES);
 sa.lpSecurityDescriptor = NULL;
 sa.bInheritHandle = TRUE;

 /*
  * Create a non-inheritible pipe.
  */
 CreatePipe(&Out.pipe, &h, &sa, 0);

 /*
  * Dupe the write side, make it inheritible, and close the original.
  */
 DuplicateHandle(hProcess, h, hProcess, &si.hStdOutput, 0, TRUE,
   DUPLICATE_SAME_ACCESS | DUPLICATE_CLOSE_SOURCE);

 /*
  * Same as above, but for the error side.
  */
 CreatePipe(&Err.pipe, &h, &sa, 0);
 DuplicateHandle(hProcess, h, hProcess, &si.hStdError, 0, TRUE,
   DUPLICATE_SAME_ACCESS | DUPLICATE_CLOSE_SOURCE);

 ok = CreateProcessW(NULL, /* Module name. */
 cmd.w_str(), /* Command line. */
 NULL, /* Process handle not inheritable. */
 NULL, /* Thread handle not inher 调用一个控制台程序并取得其输出(PIPE)
  www.firnow.com    时间 ： 2007-10-19  作者：佚名   编辑：本站 点击：   [ 评论 ]
  itable. */
 TRUE, /* yes, inherit handles. */
 DETACHED_PROCESS, /* No console for you. */
 NULL, /* Use parent's environment block. */
 NULL, /* Use parent's starting directory. */
 &si, /* Pointer to STARTUPINFOW structure. */
 &pi); /* Pointer to PROCESS_INFORMATION structure. */

 if (!ok) {
  DWORD err = GetLastError();
  int chars = _snprintf(msg, sizeof(msg) - 1,
    "Tried to launch: /"%s/", but got error [%u]: ", cmdline, err);

  FormatMessage(
    FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS
      | FORMAT_MESSAGE_MAX_WIDTH_MASK, 0L, err, 0,
    &msg[chars], (300 - chars), 0);
  WriteFile(GetStdHandle(STD_ERROR_HANDLE), msg, lstrlen(msg), &err, NULL);
  returnCode = 2;
  return;
 }

 /*
  * Close our references to the write handles that have now been inherited.
  */
 CloseHandle(si.hStdOutput);
 CloseHandle(si.hStdError);

 WaitForInputIdle(pi.hProcess, 5000);
 CloseHandle(pi.hThread);

 /*
  * Start the pipe reader threads.
  */
 pipeThreads[0] = CreateThread(NULL, 0, ReadFromPipe, &Out, 0, &threadID);
 pipeThreads[1] = CreateThread(NULL, 0, ReadFromPipe, &Err, 0, &threadID);

 /*
  * Block waiting for the process to end.
  */
 WaitForSingleObject(pi.hProcess, INFINITE);
 CloseHandle(pi.hProcess);

 /*
  * Wait for our pipe to get done reading, should it be a little slow.
  */
 WaitForMultipleObjects(2, pipeThreads, TRUE, INFINITE);
 CloseHandle(pipeThreads[0]);
 CloseHandle(pipeThreads[1]);
 returnCode = 0;
 return;
}
DWORD WINAPI ReadFromPipe(LPVOID args)
{
 pipeinfo *pi = (pipeinfo *) args;
 DWORD dwRead;
 BOOL ok;
 char buf[2000];

 while(true)
 {
  ok = ReadFile(pi->pipe, buf, 2000, &dwRead, 0L);
  if (!ok || dwRead == 0)
  {
   CloseHandle(pi->pipe);
   return 0;
  }
  else
  {
   buf[dwRead] = 0;
//   printf("%s", buf);
         myUnicodeString->append(buf);
  }
 }
}

 

#endif

文件MyUnicodeString.h

//---------------------------------------------------------------------------

#ifndef MyUnicodeStringH
#define MyUnicodeStringH
//---------------------------------------------------------------------------
#include <vcl.h>
#include <windows.h>
#include <list>
using namespace std;

class MyUnicodeString
{
public:
 MyUnicodeString();
 ~MyUnicodeString();
 MyUnicodeString(wchar_t * wchar_ts);
 MyUnicodeString(UnicodeString str);
 MyUnicodeString(const wchar_t * wchar_ts);
 MyUnicodeString(int number);
 int indexOf(wchar_t ch);
 int indexOf(wchar_t * wchar_ts);
 int lastIndexOf(wchar_t ch);
 int lastIndexOf(wchar_t * wchar_ts);
 int getOccurCount(wchar_t* wchar_ts);
 int getOccurCount(wchar_t ch);
 int getLength();
 int getLength(wchar_t * str);
 int getLength(const wchar_t * str);
 wchar_t* getReversed();
 void reverse();
 wchar_t* getReversed(wchar_t * str);
 int copy(const wchar_t* src,wchar_t* dest);
 int copy(wchar_t* src,wchar_t* dest);
 void copy(wchar_t* src,wchar_t* dest,int count);
 void copy(const wchar_t* src,wchar_t* dest,int count);
 list<UnicodeString>* split(wchar_t* splitter);
 list<UnicodeString>* split(UnicodeString splitter);
 wchar_t * getSubString(int startIndex,int count);
 wchar_t * getSubString(int startIndex);
 void rtrim();
 void ltrim();
 void trim();
 bool startsWith(wchar_t *wchar_ts);
 bool endsWith(wchar_t *wchar_ts);
 void replace(wchar_t* oldwchar_ts,wchar_t* newwchar_ts);
    void replace(UnicodeString oldStr,UnicodeString newStr);
 void toUpperCase();
 void toLowerCase();
 MyUnicodeString* operator + (wchar_t* wchar_ts);
 wchar_t* towchar_ts();
 UnicodeString getString();
 wchar_t* getCopy();
 bool isInt();//Contains only numbers
 int toInt();
 bool isLargerThan(wchar_t* wchar_ts);
 bool equals(wchar_t* dest);
 void append(const wchar_t * str);
 void append(UnicodeString str);
 void append(wchar_t * str);
 void append(wchar_t ch);
 void appendNum(int number);
 void append(wchar_t appendwchar_t,int toLength);
 void insertBefore(wchar_t insertwchar_t,int toLength);
 void release();
 wchar_t* getSpace(int count);
private:
 int indexOf(wchar_t ch,bool isReverse);
 int indexOf(wchar_t * wchar_ts,bool isReverse);
 int indexOf(wchar_t* src,wchar_t ch,bool isReverse);
 int indexOf(wchar_t* src,wchar_t * wchar_ts,bool isReverse);
 wchar_t * getLtrim(wchar_t* wchar_ts);
 wchar_t * getSubString(wchar_t* src,int startIndex,int count);
 wchar_t * getSubString(wchar_t* src,int startIndex);
 bool startsWith(wchar_t* src,wchar_t *wchar_ts);
 void copy(wchar_t* src);
 void copy(const wchar_t* src);
 bool isBufferNull;
 wchar_t * intTowchar_ts(int number);
 void setEndChar(wchar_t* chars,int index);
protected:
 void replaceBuffer(wchar_t* src);
 wchar_t* charBuffer;
};

#endif

文件MyUnicodeString.cpp

//---------------------------------------------------------------------------

#pragma hdrstop

#include "MyUnicodeString.h"

//---------------------------------------------------------------------------

#pragma package(smart_init)
const wchar_t END_CHAR('/0');

MyUnicodeString::MyUnicodeString()
{
 isBufferNull = true;
 charBuffer = NULL;
}
MyUnicodeString::MyUnicodeString(UnicodeString str)
{
 isBufferNull = true;
 charBuffer = NULL;
 if(str.Length()!=0)
 {
  copy(str.w_str());
 }
}
MyUnicodeString::MyUnicodeString(wchar_t * wchar_ts)
{
 isBufferNull = true;
 charBuffer = NULL;
 copy(wchar_ts);
}
MyUnicodeString::MyUnicodeString(const wchar_t * wchar_ts)
{
 isBufferNull = true;
 copy(wchar_ts);
}
MyUnicodeString::MyUnicodeString(int number)
{
 isBufferNull = true;
 wchar_t* wchar_ts = intTowchar_ts(number);
 copy(wchar_ts);
 free(wchar_ts);
}
wchar_t * MyUnicodeString::intTowchar_ts(int number)
{
 const int maxLenForNumber = 10;
 wchar_t * str = getSpace(maxLenForNumber);
 wchar_t temp;
 int i = 0;
 if(number==0)
 {
  str[i]='0';
  i++;
 }
 else
 {
  while(number!=0)
  {
   int remains = number%10;
   number /= 10;
   str[i] = remains+'0';
   i++;
  }
 }
 setEndChar(str,i);
 i--;
 for(int j=0;j<(i+1)/2;j++)
 {
  temp = str[j];
  str[j] = str[i-j];
  str[i-j] = temp;
 }
 return str;
}
wchar_t* MyUnicodeString::getSpace(int count)
{
 return (wchar_t*)malloc(sizeof(wchar_t)*(count+1));
}
int MyUnicodeString::indexOf(wchar_t ch)
{
 return indexOf(ch,true);
}
int MyUnicodeString::indexOf(wchar_t * wchar_ts)
{
 return indexOf(wchar_ts,false);
}
int MyUnicodeString::lastIndexOf(wchar_t ch)
{
    return indexOf(ch,true);
}
int MyUnicodeString::lastIndexOf(wchar_t * wchar_ts)
{
 return indexOf(wchar_ts,true);
}
int MyUnicodeString::indexOf(wchar_t ch,bool isReverse)
{
 return indexOf(charBuffer,ch,isReverse);
}
int MyUnicodeString::indexOf(wchar_t * wchar_ts,bool isReverse)
{
    return indexOf(charBuffer,wchar_ts,isReverse);
}

int MyUnicodeString::indexOf(wchar_t* src,wchar_t ch,bool isReverse)
{
 wchar_t * wchar_ts = getSpace(1);
 wchar_ts[0] = ch;
 setEndChar(wchar_ts,1);
 int index = indexOf(src,wchar_ts,isReverse);
 free(wchar_ts);
    return index;
}
int MyUnicodeString::indexOf(wchar_t* src,wchar_t * toSearchwchar_ts,bool isReverse)
{
 const int NOT_FOUND = -1;
 if(src==NULL)
 {
  return NOT_FOUND;
    }
 if(toSearchwchar_ts[0]==END_CHAR)
  return NOT_FOUND;
 int i = 0;
 int j = 0;
 wchar_t * str,*searchStr;
 int strLen,searchStrLen;
 if(!isReverse)
 {
  str = src;
  searchStr = toSearchwchar_ts;
 }
 else
 {
  str = getReversed();
  searchStr = getReversed(toSearchwchar_ts);
 }
 strLen = getLength(str);
 searchStrLen = getLength(searchStr);
 while(str[i]!=END_CHAR)
 {
     j = 0;
  while(searchStr[j]!=END_CHAR)
  {
   if(str[i+j]==END_CHAR)
    return NOT_FOUND;
   if(str[i+j]!=searchStr[j])
    break;
   j++;
  }
  if(searchStr[j]==END_CHAR)//reach the end
  {
   if(!isReverse)
    return i;
   else
    return strLen-i-searchStrLen;
        }
  i++;
 }
 return NOT_FOUND;
}
int MyUnicodeString::getOccurCount(wchar_t* wchar_ts)
{
 int occurCount = 0;
 int index;
 wchar_t * src = charBuffer;
 while((index=indexOf(src,wchar_ts,false))!=-1)
 {
    src += index+getLength(wchar_ts);
    occurCount++;
 }
 return occurCount;
}
int MyUnicodeString::getOccurCount(wchar_t ch)
{
 wchar_t * wchar_ts = getSpace(1);
 wchar_ts[0] = ch;
 wchar_ts[1] = END_CHAR;
 int occurCount = getOccurCount(wchar_ts);
 free(wchar_ts);
 return occurCount;
}
int MyUnicodeString::getLength()
{
 return getLength(charBuffer);
}
int MyUnicodeString::getLength(wchar_t * str)
{
 const wchar_t* str1 = str;
 return getLength(str1);
}
int MyUnicodeString::getLength(const wchar_t * str)
{
 int i = 0;
 int length = 0;
 if(str!=NULL)
 {
       while(str[i]!=END_CHAR)
  {
   i++;
   length++;
  }
    }

 return length;
}
wchar_t* MyUnicodeString::getReversed(wchar_t * str)
{
 int len = getLength(str);
 wchar_t * wchar_ts = getSpace(len);
 for(int i=0;i<len;i++)
 {
  wchar_ts[len-i-1] = str[i];
 }
 wchar_ts[len] = END_CHAR;
 return wchar_ts;
}
wchar_t* MyUnicodeString::getReversed()
{
 return getReversed(charBuffer);
}
void MyUnicodeString::reverse()
{
 wchar_t* reversed = getReversed();
 replaceBuffer(reversed);
}
void MyUnicodeString::append(const wchar_t * str)
{
 int bufferLen = getLength();
 int strLen = getLength(str);
 if(strLen!=0)
 {
     isBufferNull = false;
       wchar_t * wchar_ts = getSpace(bufferLen+strLen);
  copy(charBuffer,wchar_ts);
  copy(str,wchar_ts+bufferLen);
  replaceBuffer(wchar_ts);
    }
}
void MyUnicodeString::append(wchar_t * str)
{
 const wchar_t* str1 = str;
 append(str1);
}
void MyUnicodeString::append(wchar_t ch)
{
 wchar_t * wchar_ts = getSpace(1);
 wchar_ts[0] = ch;
 wchar_ts[1] = END_CHAR;
 append(wchar_ts);
 free(wchar_ts);
}
void MyUnicodeString::append(UnicodeString str)
{
  append(str.w_str());
}
void MyUnicodeString::appendNum(int number)
{
 wchar_t* wchar_ts = intTowchar_ts(number);
 append(wchar_ts);
 free(wchar_ts);
}
int MyUnicodeString::copy(wchar_t* src,wchar_t* dest)
{
 int i = 0;
 if(src==NULL||dest==NULL)
  return 0;
 while(src[i]!=END_CHAR)
 {
  dest[i] = src[i];
  i++;
 }
 dest[i] = END_CHAR;

 return i;
}
int MyUnicodeString::copy(const wchar_t* src,wchar_t* dest)
{
 int i = 0;
 while(src[i]!=END_CHAR)
 {
  dest[i] = src[i];
  i++;
 }
 dest[i] = END_CHAR;
 return i;
}
void MyUnicodeString::copy(wchar_t* src,wchar_t* dest,int count)
{
 int i = 0;
 if(src==NULL||dest==NULL)
 {
  return;
    }
 while(src[i]!=END_CHAR&&i<=count-1)
 {
  dest[i] = src[i];
  i++;
 }
 dest[i] = END_CHAR;
}
void MyUnicodeString::copy(const wchar_t* src,wchar_t* dest,int count)
{
 int i = 0;
 while(src[i]!=END_CHAR&&i<=count-1)
 {
  dest[i] = src[i];
  i++;
 }
 dest[i] = END_CHAR;
}
void MyUnicodeString::copy(wchar_t* src)
{
 int strLen = getLength(src);
 if(strLen!=0)
 {
       release();
  charBuffer = getSpace(strLen);
  isBufferNull = false;
  copy(src,charBuffer);
    }
}
void MyUnicodeString::copy(const wchar_t* src)
{
 int i = 0;
 int strLen = 0;
 while(src[i]!=END_CHAR)
 {
  i++;
  strLen++;
 }
 if(strLen!=0)
 {
  release();
  charBuffer = getSpace(strLen);
  isBufferNull = false;
  copy(src,charBuffer);
 }
}
list<UnicodeString>* MyUnicodeString::split(wchar_t* splitter)
{
 if(charBuffer==NULL)
     return NULL;
 list<UnicodeString>* resultList = new list<UnicodeString>();

 int occurCount = getOccurCount(splitter);
 int splitterLen = getLength(splitter);
 wchar_t** arr = (wchar_t**)malloc(sizeof(wchar_t*)*(occurCount+2));
 wchar_t *src = charBuffer;
 int index;
 int start = 0;
 int arrIndex = 0;
 int length = 0;
 while((index=indexOf(src,splitter,false))!=-1)
 {
  length = index;
  arr[arrIndex] = getSubString(start,length);
  start += length + splitterLen;
  src += length + splitterLen;
  arrIndex++;
 }

 arr[arrIndex] = getSubString(start);

 for(int i=0;i<=arrIndex;i++)
 {
  resultList->push_back(UnicodeString(arr[i]));
  free(arr[i]);
 }
 free(arr);
 return resultList;
}
list<UnicodeString>* MyUnicodeString::split(UnicodeString splitter)
{
 if(splitter!=NULL)
 {
  return split(splitter.w_str());
 }
 else
 {
  return NULL;
    }
}
wchar_t * MyUnicodeString::getSubString(wchar_t* src,int startIndex,int count)
{
 wchar_t* dest = getSpace(count);
 copy(src+startIndex,dest,count);
 return dest;
}
wchar_t * MyUnicodeString::getSubString(int startIndex,int count)
{
 return getSubString(charBuffer,startIndex,count);
}
wchar_t * MyUnicodeString::getSubString(wchar_t* src,int startIndex)
{
 int length = getLength(src+startIndex);
 wchar_t* dest = getSpace(length);
 copy(src+startIndex,dest,length);
 return dest;
}
wchar_t * MyUnicodeString::getSubString(int startIndex)
{
 return getSubString(charBuffer,startIndex);
}
void MyUnicodeString::rtrim()
{
 if(getLength()!=0)
 {
  wchar_t* reversed = getReversed();
  release();
  wchar_t* ltrimed = getLtrim(reversed);
  free(reversed);
  if(getLength(ltrimed)!=0)
  {
   replaceBuffer(getReversed(ltrimed));
  }
  free(ltrimed);
 }
}
wchar_t * MyUnicodeString::getLtrim(wchar_t* wchar_ts)
{
 int i = 0;
 while(wchar_ts[i]!=END_CHAR)
 {
  if(wchar_ts[i]!=' ')
         break;
  i++;
 }
 return getSubString(wchar_ts,i);
}
void MyUnicodeString::ltrim()
{
 if(getLength()!=0)
 {
      wchar_t * ltrimed = getLtrim(charBuffer);
  release();
  copy(ltrimed);
  free(ltrimed);
    }
}
void MyUnicodeString::trim()
{
 rtrim();
 ltrim();
}
bool MyUnicodeString::startsWith(wchar_t* src,wchar_t *wchar_ts)
{
 int i = 0;
 bool result = true;
 while(src[i]!=END_CHAR&&wchar_ts[i]!=END_CHAR)
 {
  if(src[i]!=wchar_ts[i])
  {
    result = false;
    break;
  }
      i++;
 }
 if(src[i]==END_CHAR&&wchar_ts[i]!=END_CHAR)
  result = false;
 return result;
}
bool MyUnicodeString::startsWith(wchar_t *wchar_ts)
{
 return startsWith(charBuffer,wchar_ts);
}
bool MyUnicodeString::endsWith(wchar_t *wchar_ts)
{
 wchar_t* reversedSrc = getReversed();
 wchar_t* reversedwchar_ts = getReversed(wchar_ts);
 bool result =  startsWith(reversedSrc,reversedwchar_ts);
 free(reversedSrc);
 free(reversedwchar_ts);
 return result;
}
void MyUnicodeString::replace(wchar_t* oldwchar_ts,wchar_t* newwchar_ts)
{
 int occurCount = getOccurCount(oldwchar_ts);
 int oldwchar_tsLen = getLength(oldwchar_ts);
 int newwchar_tsLen = getLength(newwchar_ts);
 int newLength = getLength(charBuffer)+(newwchar_tsLen-oldwchar_tsLen)*occurCount;
 wchar_t * wchar_ts = getSpace(newLength);

 wchar_t *src = charBuffer;
 int index;
 int start = 0;
 int i = 0;
 int length = 0;
 wchar_t * temp;
 wchar_t * dest = wchar_ts;
 while((index=indexOf(src,oldwchar_ts,false))!=-1)
 {
  length = index;
  copy(src,dest,length);
  dest += length;
  start = length + oldwchar_tsLen;
  src += start;
  copy(newwchar_ts,dest,newwchar_tsLen);
  dest += newwchar_tsLen;
  i++;
 }

 copy(src,dest);
 wchar_ts[newLength] = END_CHAR;

 copy(wchar_ts);
 free(wchar_ts);
}
void MyUnicodeString::replace(UnicodeString oldStr,UnicodeString newStr)
{
 replace(oldStr.w_str(),newStr.w_str());
}
wchar_t* MyUnicodeString::getCopy()
{
 int length = getLength();
 wchar_t * wchar_ts = getSpace(length);
 copy(charBuffer,wchar_ts);
    return wchar_ts;
}
void MyUnicodeString::toUpperCase()
{
 int i = 0;
 wchar_t* dest = getCopy();
 while(dest[i]!=END_CHAR)
 {
  if(dest[i]>='a'&&dest[i]<='z')
   dest[i] -= 'a'-'A';
  i++;
 }
 copy(dest);
 free(dest);
}
void MyUnicodeString::toLowerCase()
{
 int i = 0;
    wchar_t* dest = getCopy();
 while(dest[i]!=END_CHAR)
 {
  if(dest[i]>='A'&&dest[i]<='Z')
   dest[i] += 'a'-'A';
  i++;
 }
 copy(dest);
 free(dest);
}
MyUnicodeString* MyUnicodeString::operator + (wchar_t* wchar_ts)
{
 append(wchar_ts);
 return this;
}
wchar_t* MyUnicodeString::towchar_ts()
{
    return charBuffer;
}
UnicodeString MyUnicodeString::getString()
{
 return UnicodeString(charBuffer);
}
bool MyUnicodeString::equals(wchar_t* dest)
{
 if(getLength()==getLength(dest)&&startsWith(dest))
  return true;
 else
     return false;
}
bool MyUnicodeString::isInt()
{
 if(charBuffer==NULL)
     return false;
    int i = 0;
 while(charBuffer[i]!=END_CHAR)
 {
  if(i==0)
  {
   if((charBuffer[i]<'0'||charBuffer[i]>'9')
    &&charBuffer[i]!='-')
    return false;
  }
  else
  {
            if(charBuffer[i]<'0'||charBuffer[i]>'9')
    return false;
        }
  i++;
 }
 return true;
}
int MyUnicodeString::toInt()
{
    int i = 0;
 int result = 0;
 int sub = 1;      //To identify positive or negative number
 if(isInt())
 {
  while(charBuffer[i]!=END_CHAR)
  {
   if(i==0&&charBuffer[i]=='-')
     sub = -1;
   else
    result = result*10+charBuffer[i]-48;

   i++;
  }
  result *= sub;
 }
 else
 {
        throw "Not Integer";
    }

 return result;
}
bool MyUnicodeString::isLargerThan(wchar_t* wchar_ts)
{
 int i = 0;
 while(charBuffer[i]!=END_CHAR&&wchar_ts[i]!=END_CHAR)
 {
  if(charBuffer[i]>wchar_ts[i])
   return true;
  else if (charBuffer[i]<wchar_ts[i])
   return false;

     i++;
 }
 if(charBuffer[i]==END_CHAR&&wchar_ts[i]!=END_CHAR)
  return false;
    if(charBuffer[i]!=END_CHAR&&wchar_ts[i]==END_CHAR)
  return true;
 return false;
}
void MyUnicodeString::replaceBuffer(wchar_t* src)
{
 release();
 isBufferNull = false;
 charBuffer = src;
}
void MyUnicodeString::append(wchar_t appendwchar_t,int toLength)
{
 int len = getLength();
 wchar_t* wchar_ts = getSpace(toLength);
 copy(charBuffer,wchar_ts);
 for(int i=0;i<toLength-len;i++)
 {
  wchar_ts[len+i]=appendwchar_t;
 }
 wchar_ts[toLength] = END_CHAR;
 replaceBuffer(wchar_ts);
}
void MyUnicodeString::insertBefore(wchar_t insertwchar_t,int toLength)
{
 int len = getLength();
 if(toLength>len)
 {
  wchar_t* wchar_ts = getSpace(toLength);
  int i;
  for(i=0;i<toLength-len;i++)
  {
   wchar_ts[i]=insertwchar_t;
  }
  copy(charBuffer,wchar_ts+i);
  replaceBuffer(wchar_ts);
    }
}
void MyUnicodeString::release()
{
 if(!isBufferNull)
 {
  free(charBuffer);
  charBuffer = NULL;
  isBufferNull = true;
 }
}
void MyUnicodeString::setEndChar(wchar_t* chars,int index)
{
 wcscpy(chars+index,L"/0");
}
MyUnicodeString::~MyUnicodeString()
{
    release();
}

 

测试代码：

 UnicodeString cmd("help");
 MyUnicodeString myUnicodeString;
 int returnCode;
 execProgram(cmd,myUnicodeString,returnCode);

 控制台程序输入信息：myUnicodeString.getString();