迭代 c++ 中的向量向量

Question

我剛開始在 C++ 中編碼，所以我是 STL 的新手。在這里，我試圖迭代存儲為向量向量的圖形。

#include <iostream>
#include <vector>
#include <iostream>

using namespace std;

int reach(vector<vector<int> > &adj, int x, int y) {
    vector<vector<int> >::iterator it;
    vector<int>::iterator i;

    for (it = adj.begin(); it != adj.end(); it++)
    {
        cout << (*it) << endl;
        if ((*it) == x)
            for (i = (*it).begin(); i != (*it).end(); i++)
            {
                cout << (*i) << endl;
                if ((*i) == y)
                    return 1;

            }
    }
    return 0;
}

int main()
{

}

我收到錯誤std::vector<int> is not derived from const gnu cxx。 有人能指出我正確的方向嗎？

Answer 1

*它指向向量not int，這就是為什么您會出錯

以下代碼可能適合您

    #include <vector>
    #include <iostream>

   using namespace std;

  int reach(vector<vector<int> > &adj, int x, int y) {
  vector<vector<int> >::iterator it;
  vector<int>::iterator i;

  for (it = adj.begin(); it != adj.end(); it++)
  {
     cout << (*(*it).begin()) << endl;
    if (( (*(*it).begin())) == x)
        for (i = (*it).begin(); i != (*it).end(); i++)
        {
            cout << (*i) << endl;
            if ((*i) == y)
                return 1;

        }
   }
  return 0;
   }

  int main()
  {

  }

用於訪問使用向​​量的第一個元素

   (*(*it).begin()) in place of (*it)

如果您正在研究圖形，則使用向量數組。 有關更多詳細信息，請通過以下URL C ++深度優先搜索（DFS）實現

Answer 2

 cout << (*it) << endl;

在這里，您將it聲明為：

 vector<vector<int> >::iterator it;

因此， *it是：

 vector<int>

因此，您嘗試使用operator<<將其發送到std::cout 。 顯然，這將行不通。 這等效於：

 vector<int> v;

 cout << v;

沒有為cout定義的operator<<重載，也沒有vector<int> 。 如您所知，為了打印向量的內容，您必須迭代其單個值，並打印其單個值。

因此，無論您的意圖是什么，當您寫時：

cout << (*it) << endl;

您需要做其他事情，請記住*it這里是整個vector<int> 。 也許您的意圖是遍歷vector並打印vector中的每個int ，但是您稍后已經在做。

類似地：

 if ((*it) == x)

這也不行。 如前所述， *it是vector<int> ，不能與普通int進行比較。

目前尚不清楚您的意圖是什么。 “將圖形存儲為一個或多個矢量”太含糊。

Answer 3

以下代碼使用選項std = c ++ 11進行編譯。 但是x在vector<vector<int>>丟失。 如果adj類型為vector<pair<int, vector<int>>>則最好匹配。

以下代碼針對vector<vector<int>>編譯，但不使用x 。

using std::vector;
using std::pair;
using std::cout;
using std::endl;

int reach(vector<vector<int> > &adj, int x, int y) {
  vector<vector<int> >::iterator it;
    vector<int>::iterator i;
    for(it=adj.begin();it!=adj.end();it++)
        {
            // cout << (*it) << endl;
            for (const auto& nexts: *it)
               cout << nexts << ' ';
            cout << endl;

            for(i=(*it).begin();i!=(*it).end();i++)
            {
                cout << (*i) << endl;
                if((*i)==y)
                    return 1;
                }
            }
   return 0;
}

該代碼使用<vector<pair<int, vector<int>>>編譯，並使用x 。

using std::vector;
using std::pair;
using std::cout;
using std::endl;

int reach(vector<pair<int, vector<int> > > &adj, int x, int y) {
  vector<pair<int, vector<int> > >::iterator it;
    vector<int>::iterator i;
    for(it=adj.begin();it!=adj.end();it++)
        {
            cout << it->first << endl;

            if (it->first == x)
                for(i=it->second.begin();i!=it->second.end();i++)
                {
                    cout << (*i) << endl;
                    if((*i)==y)
                        return 1;

                    }
                }
   return 0;
}

Answer 4

將其包裝在迭代器中。 這可以被模板化以供重用。

這是std::vector<T>容器的最小工作示例：

#include <iostream>
#include <utility>
#include <vector>

/// Iterable vector of vectors
/// (This just provides `begin` and `end for `Vector2Iterable<T>::Iterator`).
template<typename T>
class VovIterable
{
public:
    static const std::vector<T> EMPTY_VECTOR;

    /// Actual iterator
    class Iterator
    {
        typename std::vector<std::vector<T>>::const_iterator _a1;
        typename std::vector<T>::const_iterator _a2;
        typename std::vector<std::vector<T>>::const_iterator _end;

    public:
        /// \param a1      Outer iterator
        /// \param a2      Inner iterator
        /// \param end     End of outer iterator
        explicit Iterator(typename std::vector<std::vector<T>>::const_iterator a1, typename std::vector<T>::const_iterator a2, typename std::vector<std::vector<T>>::const_iterator end)
                : _a1(a1)
                  , _a2(a2)
                  , _end(end)
        {
            Check();
        }

        bool operator!=(const Iterator &b) const
        {
            return _a1 != b._a1 || _a2 != b._a2;
        }

        Iterator &operator++()
        {
            ++_a2; // Increment secondary
            Check();
            return *this;
        }

        const T &operator*() const
        {
            return *_a2;
        }

    private:
        void Check()
        {
            while (true)
            {
                if (_a2 != _a1->end()) // Is secondary live?
                {
                    break;
                }

                // Increment primary
                _a1++;

                if (_a1 == _end) // Is primary dead?
                {
                    _a2 = EMPTY_VECTOR.end();
                    break;
                }

                _a2 = _a1->begin(); // Reset secondary
            }
        }
    };

private:
    std::vector<std::vector<T>> _source;

public:
    explicit VovIterable(std::vector<std::vector<T>> source)
            : _source(std::move(source))
    {

    }

    /// Start of vector of vectors
    [[nodiscard]] Iterator begin() const
    {
        if (this->_source.empty())
        {
            return end();
        }

        return Iterator(this->_source.cbegin(), this->_source.cbegin()->cbegin(), this->_source.cend());
    }

    /// End of vector of vectors
    [[nodiscard]] Iterator end() const
    {
        return Iterator(this->_source.cend(), EMPTY_VECTOR.end(), this->_source.cend());
    }

};

template<typename T>
const std::vector<T> VovIterable<T>::EMPTY_VECTOR = {0};

/// Sample usage
int main()
{
    std::vector<std::vector<int>> myVov{{1, 2, 3},
                                        {4, 5, 6},
                                        {7, 8, 9}};

    for (int i: VovIterable(myVov))
    {
        std::cout << i << std::endl;
    }

    return 0;
}