c ++类成员函数

Question

使用以下代码，在类中声明成员函数，它会提示用户输入各种输入，如小时和付费。

cout << endl << "Now please input info #1" << endl;
Info p1;
cout << endl << "Now please input info #2" << endl;
Info p2;
p2.combineinfo(p1);  /**< combines the info, like hours, pay, ect.  */
printinfo(pnew);  /**< prints out the combined paycheck information  */

准确地将信息放入p1和p2因为我可以用cout确认。 但是， p2.combineinfo(p1)再次提示输入一组信息。 我不想要这个，我只需要传递给这个函数来组合然后用printinfo();打印出来printinfo(); 。

Info Info::combineInfo(Info p1)
{
Info p2;
Info pnew;
pnew.name = p1.name;
pnew.hours = p1.hours + p2.hours;
pnew.total = p1.total + p2.total;
return pnew;
}

更新信息：

Info::Info()
{
string dummy;
cout << "question here"<<endl;
getline(cin, a);
cout <<"question here"<<endl;
cin >> b;
getline(cin, dummy);
cout <<"question here"<<endl;
cin >> c;
getline(cin, dummy);
cout << "quesiton here"<< endl;
initializeDate(start);
cout << "question here "<< endl;
initializeDate(finish);
}

Answer 1

您没有显示它，但您可能要求Info构造函数中的输入。 就像是：

Info::Info()
{
   cout << "Enter name: ";
   cin >> name;
   cout << "Enter hours: ";
   cin >> hours;
   cout << "Enter total: ";
   cin >> total;
}

因此，在combineInfo中，您可以创建两个Info类对象，因此构造函数会运行并请求每个对象的输入。 只是不要求构造函数中的值。 添加另一个方法AskForInput来询问值，不要从构造函数中调用它。

Answer 2

我猜你正在读取你的构造函数中的stdin输入信息（你可以发布这段代码吗？）。 因此，当你再次创建p2和pnew时，它会调用相同的代码。

我建议你有单独的代码用于使用stdin而不是你的构造函数初始化变量。 否则，你在这里打电话的时间并不多！

Answer 3

由于我最后输入了很多评论，我将它组合成一个答案：

根据其他答案，您的问题是您在combineInfo函数中调用Info的构造函数，并且您在combineInfo函数中提示用户。 在构造函数中使用std::cin通常是一个坏主意 - 如果你（或你的代码的用户）决定在std::cin不合适的情况下使用代码怎么办（例如，当你后来决定升级到GUI时）？ 如果要使用预定数据构造对象，该怎么办？ 或者在单元测试中？

实际上，您自己的代码提供了这样一个示例：您已经定义了Info ，其唯一的方法是通过向用户请求信息来构建Info。 但是，您实际上有两种方法可以构建对象 - （1）通过提示来自用户的信息，以及（2）通过组合已存在于其他两个Info对象（ p1和p2 ）中的信息。

更好的解决方案是让构造函数通过参数接收数据Info::Info(string name, int hours, int total) ，从类外部的用户（适当时）获取信息，并将其传递给构造函数。

或者，如果您决定将cin代码保留在构造函数中，那么不要使用compareInfo()函数 - 创建第二个构造函数，它将两个Info对象作为参数，并将代码放在那里：

Info::Info(Info p1, Info p2)
{
    name = p1.name;
    hours = p1.hours + p2.hours;
    total = p1.total + p2.total;
}

然后像这样组合：

Info pnew(p1, p2);

编辑：你已经评论说你必须遵守一个标准，即组合必须在Info Info::combineInfo(Info)函数中发生。 这很麻烦，因为构造函数会提示输入信息，您必须在成员函数中构造一个临时Info对象：

Info Info::combineInfo(Info p1)
{
Info pnew; // Temporary Info object
pnew.name = p1.name;
pnew.hours = p1.hours + hours;
pnew.total = p1.total + total;
return pnew;
}

你有三个我能想到的解决方案，其中没有一个特别有吸引力（我很惊讶老师会对你强加这个要求）：

（1）提供不提示信息的构造函数。 但是它必须与请求信息的签名具有不同的签名，因为您无法定义两次默认构造函数：

Info::Info()
{
   // Prompt user.
}

Info::Info(int dummyValue)
{
   // Do nothing.
}

然后在创建pnew对象时，调用第二个构造函数： Info pnew(0); 。

（2）根本不提供默认构造函数，而是创建一个通知是否提示：

Info::Info(bool prompt)
{
    if (prompt)
    {
        // Construct object by prompting user.
    }
    // No need to do an else, simply do nothing if !prompt
}

这样做的缺点是您始终必须提供参数来构造Info对象：

Info p1; // Error, no default constructor
Info p1(true); // Construct by prompting
Info pnew(false); // Construct without prompting

（3）根本不要创建临时的pnew ，只需修改p1并返回即可。 这是一种糟糕的风格，只有你通过p1传递值才有效（因此你没有修改原来的p1 ）：

Info Info::combineInfo(Info p1)
{
// No need to do anything with name since it's p1's name you want anyway
p1.hours += hours;
p1.total += total;
return p1;
}

---

其他的建议：

您的代码中还有一些错误：

cout << endl << "Now please input info #1" << endl;
Info p1;
cout << endl << "Now please input info #2" << endl;
Info p2;
p2.combineinfo(p1); // You are not saving the return value.
printinfo(pnew);  // pnew does not exist, see above.

将代码更改为：

cout << endl << "Now please input info #1" << endl;
Info p1;
cout << endl << "Now please input info #2" << endl;
Info p2;
Info pnew = p2.combineinfo(p1); // Now you are saving the result.
printinfo(pnew);  // pnew now exists.

第二个错误如下：

Info Info::combineInfo(Info p1)
{
Info p2; // You're creating a new p2 object, this is
         // NOT the p2 you called the function on.
Info pnew;
pnew.name = p1.name;
pnew.hours = p1.hours + p2.hours; // Wrong p2
pnew.total = p1.total + p2.total; // Wrong p2
return pnew;
}

这似乎只适合你，因为构造函数问题 - 你被提示输入combineInfo的p2 ，所以它最终与你实际打算使用的p2相同（假设你进入了再次使用相同的数据），似乎正确地将它们组合在一起。 改为：

Info Info::combineInfo(Info p1)
{
// Info p2; // Delete this line
// your intended p2 is passed to the function as the implicit parameter.
Info pnew;
pnew.name = p1.name;
pnew.hours = p1.hours + hours; // hours refers to implicit parameter
pnew.total = p1.total + total; // total refers to implicit parameter
return pnew;
}

在这种情况下， hours和total是this.hours和this.total简写。

要考虑将来参考的另一件事是重载+运算符而不是编写组合函数：

Info Info::operator+(Info p1)
{
Info pnew;
pnew.name = p1.name;
pnew.hours = p1.hours + hours;
pnew.total = p1.total + total;
return pnew;
}

而不是：

Info pnew = p2.combineInfo(p1);

你可以写：

Info pnew = p1 + p2;

最后，考虑通过引用而不是按值传递 - 对于非平凡对象，函数通常更快地取消引用地址而不是创建它的新副本：

Info Info::combineInfo(const Info& p1); // p1 passed by reference
                                        // const replicates the behaviour
                                        // of pass by value whereby
                                        // you cannot accidentally modify
                                        // the original object.

编辑：但是如果您使用上面的解决方案3，请不要这样做，否则您将修改可能不希望您的原始p1 。

Answer 4

大概你已经决定在值中读取Info的默认构造函数。 然后在方法combineInfo你又有了几个必须做同样的构造函数。

您可以通过在构造之后使用提示输入数据的方法来避免此问题。 如果您显示可能有用的构造函数代码。

话虽如此，该方法很可能应该是：

void Info::combineInfo(const Info& p1)
{
    name = p1.name; // Why not keep p2.name?
    hours += p1.hours;
    total += p1.total;
}

然后打电话：

printInfo(p2);