0

例如：

class apple
{
public:
    string name;

    apple::apple(string name) : name(name)
    {
    }
};

如果我想制作一堆列表，每个列表都有苹果的类型，我想我可以做类似std::list<apple> empire("empire"), macintosh("macintosh"). 基本上，我想为list<T>创建列表时声明的类 T 的构造函数传递参数。抱歉，如果我没有正确解释这一点，如果您有这种能力，请随时编辑我的问题。

谢谢

编辑这个问题似乎令人困惑，这可能是因为我举了一个不好的例子。我需要重新设计我的班级。在这个例子之后，虽然我想要的是一个包含所有帝国苹果的列表，并且该列表中的每个苹果都有一个指定的帝国类型，以及一个包含所有 macintosh 苹果的列表，并且该列表中的每个苹果都有一个指定的 macintosh 类型。

因此，为了澄清一些或混淆一些，我们开始吧。

class apple
{
public:
    string variety_name;
    string description;
    apple::apple(string variety_name, string description)
        : variety_name(variety_name), description(description)
    {
    }
};
int _tmain(int argc, _TCHAR* argv[])
{
    // Vlad from Moscow's answer
    std::list<apple> empire(1, apple("empire", "picked yesterday")),
        macintosh(1, apple( "macintosh", "picked yesterday")); 

    // Vaughn Cato's answer
    empire.push_back(apple("empire", "picked today"));
    macintosh.push_back(apple("macintosh", "picked today"));

    for(list<apple>::iterator it=empire.begin(); it != empire.end(); ++it)
    {
        cout << it->variety_name << " " << it->description << endl;
    }

    for(list<apple>::iterator it=macintosh.begin(); it != macintosh.end(); ++it)
    {
        cout << it->variety_name << " " << it->description << endl;
    }

    return 0;
}

因此，如您所见，存储品种比每次存储更容易；我的班级显然需要重新设计，但这并没有降低答案的有效性。每个人都感谢您的帮助

4

4 回答 4

6

当然，您可以使用emplace(),emplace_front()并emplace_back()使用适当的构造函数就地构造对象：

std::list<apple> list;
list.emplace(list.end(), "one");
list.emplace_front("two");
list.emplace_back("three");
于 2014-01-12T20:49:50.583 回答
4

你可以做

std::list<apple> a;
a.push_back(apple("delicious"));
于 2014-01-12T20:49:54.493 回答
2

在 C++11 中，您可以使用初始化列表：

#include <list>
#include <string>

int main() {
    // C++11 initializer-list
    std::list<std::string> species = { "empire", "macintosh" };


    // Without C++11: You may initialize with an array:
    const char* species_array[] = { "empire", "macintosh" };
    std::list<std::string> species_list(
        species_array,
        species_array + sizeof(species_array)/sizeof(species_array[0]));
    return 0;
}

苹果是：

int main() {
    // C++11 initializer-list
    std::list<apple> species = { apple("empire"), apple("macintosh") };


    // Without C++11: Initialize with an array:
    const apple species_arry[] = { apple("empire"), apple("macintosh") };
    std::list<apple> species_list(
        species_arry,
        species_arry + sizeof(species_arry)/sizeof(species_arry[0]));
    return 0;
}
于 2014-01-12T20:58:34.490 回答
0

This

apple(string name);

is a so-called conversion constructor. It converts an object of type std::string to an object of type apple. It can be called implicitly by the compiler when it is awaiting an object of type aoole but gets an object of type std::string.

You could not do so if you would declare the constructor as explicit. For example

explicit apple(string name);

In this case your would need explicitly to specify the constructor. For example

std::list<apple> empire( 1, apple( "empire" ) );
于 2014-01-12T20:53:43.840 回答