ACE_TAO sequence<string> strList C++ 映射

.idl文件部分内容：

typedef string User;

typedef sequence<User> UserList;

=================================

部分C++映射代码：

  typedef char * User;
  typedef ::CORBA::String_var User_var;
  typedef ::CORBA::String_out User_out;

其中String_var 是对Char*封装的一个类：

http://blog.chinaunix.net/uid-12818620-id-2914335.html

大概封装内容如上：

所以如需实现类似以下函数：

int corba_client::get_user_by_num(char *name, int num)
{
char* value[] = {"hello"};
if (num < 0 || num > (int)usrlist->length())
return -1;
//Chat::UserList::value_type
if((Chat::ChatServer_ptr)chatserver != NULL)
{

/获取usrlist中第num-1个用户，这是一个User_var 类型，说明sequence<User> UserList;中的User映射为User_var而不是string对应的char*类型
Chat::User_var item = (*usrlist)[num];/
strncpy_s(name, strlen(name), item.in(), sizeof(item.in()));
}
    return 0;
}

则可以参照：

//Beging String_var.cpp

//在Corba中,String_var对char*进行了封装。本程序将对String_var模仿实现

#include "corba.h"
#include <cstring>
#define MAXLINE 100

namespace corba{

class String_var
{
private:
 char * strPtr_;
public:
 //构造函数
 String_var():strPtr_(0){}
 
 String_var(char* p)

 {

  this->strPtr_ = corba::string_dup(p);

 }
 
 String_var(const char* p)
 {
  this->strPtr_ = corba::string_dup(p);
 }
 
 //拷贝构造函数
 String_var(const String_var& p)
 {
  this->strPtr_ = corba::string_dup(p.strPtr_);
 }
 
 //析构函数
 ~String_var()
 {
  cout << "Destructing" << endl;
  corba::string_free(this->strPtr_);
  this->strPtr_ = 0;
 }

 //将strPtr_清空，然后将strPtr_以前所指向的内容返回。
 char* _retn(void)
 {
  char *temp = this->strPtr_;
  this->strPtr_ = 0;
  return temp;
 }

 const char* in(void)const
 {
  return this->strPtr_;
 }

 //返回类型为char* 
 char*& inout(void)
 {
  return this->strPtr_;
 }

 char*& out(void)
 {
  corba::string_free(this->strPtr_);
  this->strPtr_ = 0;
  return this->strPtr_;
 }
 //可读可写　，返回char*的引用
 CORBA_INLINE operator char*&(void);

 //只能读
 CORBA_INLINE operator const char*(void) const;

 //操作符重载
 String_var& operator=(char *p);

 String_var& operator=(const char* p);
 
 String_var& operator=(const String_var& p);
 
friend ostream& operator<<(ostream& oo,const String_var& p);

 //只允许访问
 CORBA_INLINE char operator[](unsigned long idx)const
 {
  return this->strPtr_[idx];
 }

 //允许访问和修改
 CORBA_INLINE char& operator[](unsigned long idx){
  return strPtr_[idx];
 }

};

CORBA_INLINE String_var::operator char*&(void)
{
 return this->strPtr_;
}

CORBA_INLINE String_var::operator const char*(void) const
{
 return this->strPtr_;
}

String_var& String_var::operator=(char *p)
{
 if(this->strPtr_ != p)
 {
  corba::string_free(this->strPtr_);
  this->strPtr_ = corba::string_dup(p);
 }
 return *this;
}

String_var& String_var::operator=(const char* p)
{
 corba::string_free(this->strPtr_);
 this->strPtr_ = corba::string_dup(p);
 return *this;
}

String_var& String_var::operator=(const String_var& p)
{ 
 if(this != &p)
 {
  corba::string_free(this->strPtr_);
  this->strPtr_ = corba::string_dup(p.strPtr_);
 }
 return *this;
}

ostream& operator<<(ostream& oo,const String_var& p)
{
 oo << p.strPtr_ ;
 return oo;
}
}
 
int main()
{
  corba::String_var toStr;
 toStr = corba::string_dup("Hello World!");
 corba::String_var formStr;
 formStr = toStr;
 cout << formStr << endl;
 formStr = corba::string_dup("jkdjflsadjfklsdjflksjdf");
 cout << formStr << endl;
 return 0;
}

//End String_var.cpp

实现sequence内容的获取