Question

在主功能中有一行

vector<bookStatusEnum> booksStatus(numbooks, available);

你能解释一下这条线是如何执行的吗？我看到代码片段中没有booksStatus函数。那实际上是什么。

#include <string>
#include <iostream>
#include <vector>
#include <map>
#include <algorithm>

using namespace std;

struct book
{
    string title, author;

    inline bool operator<(const book& other) const
    {
        if (author != other.author)
            return author < other.author;

        return title < other.title;
    }
};

void ReadInBooks(vector<book> & allBooks)
{
    string temp;

    book currentBook;

    while (cin >> temp, temp != "END")
    {
        currentBook.title = "";

        bool first = true;

        while (*(temp.end() - 1) != '"')
        {
            if (!first)
                currentBook.title += ' ';

            first = false;
            currentBook.title += temp;

            cin >> temp;
        }

        if (!first)
            currentBook.title += ' ';

        currentBook.title += temp;

        // Ignore 'by'
        cin >> temp;
        // ignore the space after the by
        cin.ignore();

        getline(cin, currentBook.author);
        allBooks.push_back(currentBook);
    }
}

enum bookStatusEnum { available, borrowed, returned };

int main()
{
    vector<book> allBooks;
    ReadInBooks(allBooks);
    int numBooks = allBooks.size();
    std::sort(allBooks.begin(), allBooks.end());

    vector<bookStatusEnum> booksStatus(numBooks, available);

    map<string, int> positionInAllBooks;
    for (int i = 0; i < numBooks; ++i)
        positionInAllBooks[allBooks[i].title] = i;

    vector<bool> borrowed(allBooks.size(), false);
    vector<bool> returned(allBooks.size(), false);

    string command;
    string bookName;
    while (cin >> command, command != "END")
    {
        if (command == "BORROW")
        {
            cin.ignore();
            getline(cin, bookName);
            int pos = positionInAllBooks[bookName];
            borrowed[pos] = true;
            returned[pos] = false;
        }

        else if (command == "RETURN")
        {
            cin.ignore();
            getline(cin, bookName);
            returned[positionInAllBooks[bookName]] = true;
        }

        else // SHELVE
        {
            int previous = -1;
            for (int i = 0; i < numBooks; ++i)
            {
                if (!borrowed[i])
                    previous = i;
                else if (returned[i])
                {
                    if (previous == -1)
                        cout << "Put " << allBooks[i].title << " first\n";
                    else
                        cout << "Put " << allBooks[i].title << " after " << allBooks[previous].title << '\n';

                    returned[i] = false;
                    borrowed[i] = false;
                    previous = i;
                }
            }

            cout << "END\n";
        }
    }
}

P.S：我找不到合适的头衔。请随时提出建议。

Answer 1

bookStatus是一个vector，一个数组，它包含bookStatusEnum类型的元素。

如C ++文档中所述，该构造函数应为：

vector（size_type count，const T＆amp; value ，const Allocator＆amp; alloc = Allocator（））;

使用值为 value 的 count 元素副本构造容器。

因此，numbooks被定义为一个整数，并且是被调用构造函数的第一个参数，因此它是 count ，即向量的大小; available是bookStatusEnum的枚举器部分，值，（从技术上讲，在c ++中，枚举值默认为某种整数类型）。

因此，向量包含值numbooks的{{1}}个副本。

available

Answer 2

简短说明：它构建了一个名为std::vector<bookStatusEnum>的{{1}}个booksStatus元素，每个元素都初始化为numbooks。（假设available在numbooks可以表示的值范围内。如果不能这样做，程序将中止。

很长的解释如下.....

由于

前面有std:vector<bookStatusEnum>::size_type（没有其他using namespace std指令）
范围内有前面的变量 - using类型为numbooks，int类型为available

的影响

bookStatusEnum

是名为vector<bookStatusEnum> booksStatus(numbooks, available);的变量的定义，其类型为booksStatus，它使用可以接受两个参数的构造函数进行初始化，一个是整数类型，另一个是类型std::vector<bookStatusEnum>

阅读bookStatusEnum的文档，我们发现它是一个模板化的类，其构造函数被声明为类似的东西;

std::vector

，其中

vector(size_type count, const T& value, const Allocator& alloc = Allocator());（实际上名为size_type）是一个实现定义的std::vector<bookStatusEnum>::size_type整数类型;
unsigned是模板参数（例如，如果我们的向量是T），则类型为bookStatusEnum;
第三个参数是一个默认值，所以这个构造函数可以接受两个论点。

要调用此构造函数，变量std::vector<bookStatusEnum>将使用模运算（即numbooks与最大值a {{之间的转换值）从int转换为size_type 1}}可以代表），0由size_type引用传递。

分配器（默认提供）是向量将用于分配内存的对象。

该陈述的实际效果是available属于const类型。该向量中的元素数量为bookStatus（使用模运算转换为std::vector<bookStatusEnum>），每个元素的值为numbooks。

如果构造失败（例如，分配器无法分配内存来保存元素），则会抛出异常。由于没有size_type / available块，这将导致程序终止（通过调用try）。

如果构造成功，则对象将一直存在，直到其包含范围结束。在这种情况下，即catch返回时，因此在程序结束时调用向量的析构函数。析构函数的作用是释放向量使用的所有内存（即元素集不再存在）。

简单！

这行是如何在这个C ++代码片段中工作的？

2 个答案: