C++ 函数使用多种类型的结构

I功能原型：

void writeToFile（流&，向量，向量，向量）

以及职能机构：

void writeToFile(ofstream& fileToBeWrittenTo, vector<SoftwareDeveloper> firstArray, vector<Manager> secondArray, vector<Tester> thirdArray, vector<TeamLeader> fourthArray)
{
for (int i = 0; i < firstArray.size(); i++)
{
    fileToBeWrittenTo << firstArray[i].identificationCode << "|" << firstArray[i].firstName << "|" << firstArray[i].lastName << "|" << firstArray[i].typeOfEmployee << "|";
    for (int j = 0; j < firstArray[i].knownLanguages.size(); j++)
        fileToBeWrittenTo << firstArray[i].knownLanguages[j] << ':';
    fileToBeWrittenTo << endl;
}

for (int i = 0; i < secondArray.size(); i++)
{
    fileToBeWrittenTo << secondArray[i].identificationCode << "|" << secondArray[i].firstName << "|" << secondArray[i].lastName << "|" << secondArray[i].typeOfEmployee;
    fileToBeWrittenTo << endl;
}

for (int i = 0; i < thirdArray.size(); i++)
{
    fileToBeWrittenTo << thirdArray[i].identificationCode << "|" << thirdArray[i].firstName << "|" << thirdArray[i].lastName << "|" << thirdArray[i].typeOfEmployee << "|" << thirdArray[i].isAutomated;
    fileToBeWrittenTo << endl;
}

for (int i = 0; i < fourthArray.size(); i++)
{
    fileToBeWrittenTo << fourthArray[i].identificationCode << "|" << fourthArray[i].firstName << "|" << fourthArray[i].lastName << "|" << fourthArray[i].typeOfEmployee;
    fileToBeWrittenTo << endl;
}

};

一种可能的解决方案是，不使用
模板
，我们可以使用
#定义H向量
等等，并在函数声明中使用它
void writeToFile（ofstream&filetobewritento，H firstArray，K secondArray，J thirdArray，L fourthArray）
根据有用的注释：此答案假设所有类型都具有相同的数据成员，尽管某些类型可能还具有不应导出的其他属性。这不是一个非常现实的用例，但我能看到模板解决方案在这里真正有意义的唯一用例。当然，如果所有类型都是相同的，那么不应该有多个类

通常的方法是让您的
软件开发人员
，
经理
。。。类继承自同一基类，然后将它们存储在数组
向量中

如果这在这里没有意义，您确实可以使用一个模板：

template<typename H>
void writeToFile(ostream& fileToBeWrittenTo, const H& arr)
{
    for (int i = 0; i < arr.size(); i++)
    {
        fileToBeWrittenTo << arr[i].identificationCode << "|" << arr[i].firstName << "|" << arr[i].lastName << "|" << arr[i].typeOfEmployee << "|";
        for (int j = 0; j < arr[i].knownLanguages.size(); j++)
            fileToBeWrittenTo << arr[i].knownLanguages[j] << ':';

        fileToBeWrittenTo << std::endl;
    }
}

这样，您就不用将所有内容多次放入一个函数中，而是可以多次调用一个较小的函数。当然，这些多个调用可以放入另一个函数中。无论如何，这将为您节省代码（如果您以后想更改某些内容，可能会感到紧张和时间）

这里还需要注意一些其他事项：


您应该使用ostream而不是ofstream，因为这更为复杂
一般；您还可以使用文件流，但也可以使用其他输出
像库特一样的溪流

您应该在此处将H作为引用传递，以便它是通过引用而不是通过值传递的，因为整个数组都是复制的，所以传递速度要慢得多，这甚至可能是不可能的，也可能是不合理的，具体取决于您的员工类型

此函数不会热更改向量，因此应该传递
向量as const=>与我之前的点一起使用
const H&

这并不重要，但通常需要命名模板
参数T
向量
，
向量
，
向量
，
向量
是不同的类型，因此需要区分它们。你可以这样做

template<typename H, K, J, L>
void writeToFile(ofstream& fileToBeWrittenTo, H firstArray, K secondArray, J thirdArray, L fourthArray)
{
...
}

模板
空写文件（流和文件的空写文件，H第一个数组，K第二个数组，J第三个数组，L第四个数组）
{
...
}
“一个可能的解决方案是”你拼错了被解雇的方式。HTH。这离OOP尽可能远。避免裸指针的向量，使用智能指针的向量。不同类型的人实际上有不同的数据成员，所以模板解决方案不会工作得那么好。如果他们都有相同的成员，你应该问“为什么他们是不同类型的？”你是对的，这可能没有意义。从OPs解决方案判断，我假设大多数类型都有相同的数据成员。当然，这本身是没有意义的。您可能还应该提到，不同人员类型的格式设置应该由基中定义的虚拟函数处理，并根据需要在子类中重写。
writeToFile(stream, softwareDeveloperVector);
writeToFile(stream, managerVector);
// and so on

template<typename H, K, J, L>
void writeToFile(ofstream& fileToBeWrittenTo, H firstArray, K secondArray, J thirdArray, L fourthArray)
{
...
}