1

我正在尝试创建一个程序，该程序接受文件的输入，然后将单词存储到向量中，到目前为止，我已经让它与 std::vector 类一起使用，尽管我想尝试自己制作，以利用。但是我遇到了很多错误，不知道如何解决它们。

错误信息：

main.cpp:43: error: expected constructor, destructor, or type conversion before "Vector"
main.cpp:43: error: expected `;' before "Vector"
main.cpp:47: error: expected constructor, destructor, or type conversion before "Vector"
main.cpp:47: error: expected `;' before "Vector"
main.cpp:55: error: expected constructor, destructor, or type conversion before "Vector"
main.cpp:55: error: expected `;' before "Vector"
main.cpp: In function `int main(int, char**)':
main.cpp:115: error: expected primary-expression before "auto"
main.cpp:115: error: expected `;' before "auto"
main.cpp:116: error: expected primary-expression before "auto"
main.cpp:118: error: no matching function for call to `std::vector<WordInfo, std::allocator<WordInfo> >::push_back(std::string&, int)'

我的代码：

#include <cstdlib>
#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

struct WordInfo {
    string text;
    int count;
};

template <class T> class Vector {
public:
    typedef T* iterator;
    Vector();
    iterator begin();
    iterator end();
    int size();
    iterator insert(iterator position, const T& item);
    void alloc_new();

private:
    T items[1000];
    int used;
};

template <class T> Vector<T>::Vector() {

    used = 0;
}

template <class T> Vector<T>::iterator Vector<T>::begin() {
    return items;
}

template <class T> Vector<T>::iterator Vector<T>::end() {
    return items + used;
}

template <class T> int Vector<T>::size() {
    return used;
}

template <class T> Vector<T>::iterator Vector<T>::insert(iterator position, const T& item) {

    if (used + 1 > items) {
        alloc_new();
    }

    items[position] = item;
    used = +1;

}

template <class T> void Vector<T>::alloc_new() {
    items = used * 2;
    T tmp[] = items;

    for (int i = 0; i < used; i++) {
        tmp[i] = items[i];
    }
    delete items;
    items = tmp;
}

/*
 * 
 */
int main(int argc, char** argv) {

    enum {
        total, unique, individual
    } mode = total;
    for (int c; (c = getopt(argc, argv, "tu")) != -1;) {
        switch (c) {
            case 't': mode = total;
                break;
            case 'u': mode = unique;
                break;
            case 'i': mode = individual;
                break;

        }
    }
    argc -= optind;
    argv += optind;
    string word;
    vector<string> list;
    int count = 0;
    int count2 = 0;
    while (cin >> word) {
        count += 1;

        if (find(list.begin(), list.end(), word) != list.end()) {
            list.push_back(word);

        }

    }


    switch (mode) {
        case total: cout << "Total " << count << endl;
            break;
        case unique: cout << "Unique " << count2 << endl;
            break;
        case individual:
            vector<WordInfo> list;
            while (cin >> word) {
                if (find(list.begin(), list.end(), word) != list.end()) {
                    auto = find(list.begin(), list.end(), word);
                    list.at(auto).count++;
                } else {
                    list.push_back(word, 1);
                }
            }
            break;
    }

    return 0;
}

任何帮助将不胜感激，在此先感谢您！

4

1 回答 1

3

您需要将返回类型限定为类型名：

template <class T> typename /* <---- THIS */
    Vector<T>::iterator Vector<T>::begin() 
{
    return items;
}

因为迭代器是一个依赖名。不过，在类中实现这些方法可能更惯用（无论如何，模板方法都要求定义在头文件中）。

还：

                auto = find(list.begin(), list.end(), word);
                list.at(auto).count++;

应该是这样的

                auto match = find(list.begin(), list.end(), word);
                list.at(match - list.begin()).count++;

使用标准库

根据我上面的评论，我建议使用标准库容器（至少在尝试实现容器之前）。看起来是这样的：

在Coliru现场观看

#include <iostream>
#include <map>
#include <algorithm>
#include <numeric>
#include <iterator>
#include <getopt.h>

using namespace std;

int main(int argc, char** argv) {

    enum {
        total, unique, individual
    } mode = total;

    for (int c; (c = getopt(argc, argv, "tui")) != -1;) {
        switch (c) {
            case 't': mode = total;
                break;
            case 'u': mode = unique;
                break;
            case 'i': mode = individual;
                break;
        }
    }

    argc -= optind;
    argv += optind;

    map<string, unsigned> tally;

    unsigned long total_count = 0;
    for_each(
            istream_iterator<string>(cin), {}, 
            [&] (std::string const& word) mutable 
            { 
                tally[word]++; 
                total_count++; 
            }
        );

    switch (mode) {
        case total: 
            cout << "Total " << total_count << endl;
            break;
        case unique: 
            cout << "Unique " << tally.size() << endl;
            break;
        case individual:
            for (auto const& entry: tally)
                cout << entry.first << "\t" << entry.second << "\n";
            break;
    }
}

带 input.txt

apple pear jumped over the apple moon 
blob the cow blob jumped over the apple moan grumpy dog apple

这是输出：

  • test -t < input.txt

    Total 19

  • test -u < input.txt

    Unique 11

  • test -i < input.txt

    apple   4
blob    2
cow 1
dog 1
grumpy  1
jumped  2
moan    1
moon    1
over    2
pear    1
the 3
于 2013-10-18T00:57:48.617 回答