Question

我有一个对象，这个对象中的每个成员变量都有一个名称，我可以通过调用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();

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

Answer 1

在普通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，但我似乎无法找到其他方法。

Answer 2

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

实施例

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对不起我的写作错误。英语不是我的母语。

Answer 3

一种方法是拥有一个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;
  ...
};

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

Answer 4

这看起来像一个“观察模式”，你只需要在对象中保留一个副本作为成员变量“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;
}

一个函数而不是复制和粘贴编程

4 个答案: