C++ 将两个字符串中的相似性写入新的动态数组的最简单方法

我有一个函数，我想比较两个数组，找到匹配项，然后创建第三个数组。函数查找比较，但当我尝试返回一个对象时，程序中止。我最初的想法是，c1.nummbers和c2.nummbers的值不同可能会导致我的循环出现故障。感谢您的帮助。这是我的

Club mergeClubs(Club& c1, Club& c2)
{
    Club combined;
    combined.clubName = c1.clubName + "/" + c2.clubName;
    string* x = new string[combined.numMembers];
    for(int i = 0;i<c1.numMembers;i++)
    {
        for(int k =0;k<c2.numMembers;k++)
        {
            if(c1.members[i]==c2.members[k])
            {
                x[combined.numMembers] = c1.members[i];
                combined.numMembers++;
            }
        }
    }
    combined.members = x;


    return combined;
}

Club mergeClubs(Club& c1, Club& c2)
{
//I changed the arrays to vectors to sort them and find the duplicates, then wrote     it back into an array. inefficient yes, but using vectors
//in the first place would have made the project 1000000000000x easier.
    Club combined(c1.clubName + "/" + c2.clubName);
    vector<string> x1;
    vector<string> x2;
    vector<string> combine;
    for(int i = 0;i<c1.numMembers;i++)
    {
        x1.push_back(c1.members[i]);
    }
    for(int i = 0;i<c2.numMembers;i++)
    {
        x2.push_back(c2.members[i]);
    }
    for(int i = 0;i<x1.size();i++)
    {
        for(int j = 0;j<x2.size();j++)
        {
            if(x1[i]==x2[j])
            {
                combine.push_back(x1[i]);
            }
        }
    }
    for(vector<string>::const_iterator i = combine.begin(); i != combine.end();     ++i)
    combined.numMembers = combine.size();
    combined.members = &combine[0];


    return combined;
 }

俱乐部合并俱乐部（俱乐部和c1、俱乐部和c2）
{
俱乐部合并；
combined.clubName=c1.clubName+“/”+c2.clubName；
string*x=新字符串[combined.nummbers]；
对于（int i=0；i问题在于，在定义之前，当分配字符串
x
时，使用了
combined.nummbers
。与其分配字符串数组，不如使用可扩展的容器，例如
std:：vector
。使用
std:：vector:：append
添加每个字符串。然后在末尾，分配
combined。成员< /代码>数组，并从临时向量中复制每个字符串。
 您可能需要考虑使用一个容器用于<代码>成员< /代码>字符串。如果要使用<代码> STD:：SET<代码>，您可以执行以下操作：

std::set<std::string> a, b, c;
// assume a and b contain some strings
std::set_intersection(
  a.begin(), a.end(),
  b.begin(), b.end(),
  std::inserter(c, c.end())
);


相信我，我知道这是多么低效

这不仅仅是关于效率，即使使用标准容器比处理数组慢（通常不是，尤其是使用
vector
s），我仍然会选择答案顶部的代码，因为它更易于编写、读取和维护。
这看起来是错的：
string*x=newstring[combined.numbers]
。已经组合了
。nummbers
甚至已经初始化？为什么不使用向量而不是数组？@qlear-如果使用
std:：vector
和
std:：set\u intersection
（前提是名称已排序），您编写的大部分代码都是不必要的。我会将其作为答案发布，但需要查看什么是
俱乐部
和
会员
。为您的新代码编辑我的答案。
struct Club
{
  std::string clubName;
  std::string* members;
  int numMembers;
};

Club mergeClubs(Club& c1, Club& c2)
{
  Club combined{
    c1.clubName + "/" + c2.clubName,
    new std::string[c1.numMembers + c2.numMembers],
    0
  };

  std::sort(c1.members, c1.members + c1.numMembers);
  std::sort(c2.members, c2.members + c2.numMembers); 

  auto end = std::set_intersection(
    c1.members, c1.members + c1.numMembers,
    c2.members, c2.members + c2.numMembers,
    combined.members
  );

  combined.numMembers = end - combined.members;

  return combined;
}