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

a function instead of copy-and-paste programming

本文关键字：复制 编程 一个 函数      更新时间：2023-10-16

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

我需要一个函数来做这件事，而不是在对象变化时复制和粘贴。有人有主意吗？

在普通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，但我似乎找不到别的办法。

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

示例

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很抱歉我写错了。英语不是我的母语。

一种方法是拥有一个外部成员名称库，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;
  ...
};

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

这看起来像是一个"观察模式"，您只需要在对象中保留一个副本作为成员变量"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;
}
相关文章：