7

我有一个对象，这个对象中的每个成员变量都有一个名称，我可以通过调用 get_name() 来获取它，我想要做的是按字母顺序连接所有成员变量的名称，然后做一些事情。例如：

class CXMLWrapper<class T>
{
public:
    CXMLWrapper(const char* p_name) : m_local_name(p_name)
    {
    }
    //skip the get_name(), set_name() and others    
private:
    string m_local_name;
    T m_type_var;
}
class object
{
public:
    object() : m_team("team"), m_base("base")
    {
    }
public:
    CXMLWrapper<string> m_team;
    CXMLWrapper<string> m_base;
...
}

我必须像这样硬编码：

object o;
string sign = o.m_base.get_name();
sign += o.m_team.get_name();

我需要一个函数来执行此操作，而不是在对象变化时进行复制和粘贴。有人有想法吗？

4

4 回答 4

2

如果所有成员都属于同一个类或从某个基类派生，那么在普通 C++ 中执行此操作的一种方法是对函数使用可变数量的参数。下面是一个例子。

#include <stdarg.h>
string concatenateNames(int numMembers, ...)
{
    string output;
    va_list args;
    va_start(args, numMembers);
    for(int i = 0; i < numMembers; i++)
    {
        MemberClass *pMember = va_arg(args, MemberClass*);
        output += pMember->get_name();
    }
    va_end(args);
    return output;
}

class Object
{
    public:
        MemberClass x;
        MemberClass y;
        MemberClass z;
};

int main()
{
    Object o;
    string sign = concatenateNames(3, &o.x, &o.y, &o.z);
}

如果所有成员的类型不同，您可以查看 C++11x 的可变参数模板：http ://en.wikipedia.org/wiki/Variadic_Templates ，但我似乎找不到其他方法。

于 2013-08-09T05:07:23.480 回答
0

如果具有名称的变量具有相同的类型（或这些类型属于一个层次结构），您可以使用这些变量的映射。不是好方法，但也许它可以帮助你

例子

class object
{
public:
    object() //: m_team("team"), m_base("base")
    {
       this->vars["m_team"] = CXMLWrapper<string>("team");
       //.....
    }
public:
    map<string, CXMLWrapper<string> > vars;
    /*CXMLWrapper<string> m_team;
    CXMLWrapper<string> m_base;*/
...
}

object o;
string sign;
for(auto& x : o.vars)//i cannot remember syntax of for of map
    sign += x.get_name;

PS对不起我的写作错误。英语不是我的母语。

于 2013-08-06T09:13:23.927 回答
0

一种方法是拥有一个 CXMLWrapper 类更新的外部成员名称库：-

class BaseXMLWrapper
{
public:
  void ListMembers (const char *parent)
  {
    // find "parent" in m_types
    // if found, output members of vector 
    // else output "type not found"
  }
protected:
  void RegisterInstance (const char *parent, const char *member)
  {
    // find 'parent' in m_types
    // if not found, create a new vector and add it to m_types
    // find 'member' in parent vector
    // if not found, add it
  }
private:
  static std::map <const std::string, std::vector <const std::string> >
    m_types;
};

class CXMLWrapper <class T, const char *parent> : BaseXMLWrapper
{
public:
  CXMLWrapper(const char* p_name) : m_local_name(p_name)
  {
    RegisterInstance (parent, p_name);
  }
  // you could override assignments, copy and move constructors to not call RegisterInstance
  //skip the get_name() set_name()    
private:
  m_local_name;
}

class object
{
public:
  object() : m_team("team"), m_base("base")
  {
  }
public:
  CXMLWrapper<string, "object"> m_team;
  CXMLWrapper<string, "object"> m_base;
  ...
};

这确实增加了对象构造的开销，但由于它只是一个构造函数开销，它可能不会对整体系统性能产生太大影响。

于 2013-08-06T09:39:34.367 回答
-2

这看起来像一个“观察模式”，您只需在对象中保留一个副本作为成员变量“string name_;”，并将 name_s 的引用传递给 CXMLWrapper，如下所示：

class CXMLWrapper<class T>
{
public:
    CXMLWrapper(const string &name)
        : local_name_(name)
        {
        }
    //skip the get_name() set_name()    
    private:
        const string &local_name_;
}

class object
{
public:
    object()
        : team_("team"), 
          base_("base"),
          m_team(team_)
        , m_base(base_)
        {
        }
public:
    string team_;
    string base_;
    CXMLWrapper<string> m_team;
    CXMLWrapper<string> m_base;
}
于 2013-08-06T08:59:51.843 回答