Как распечатать содержимое вектора?

гораздо проще сделать это со стандартным алгоритм копирования:

#include <iostream>
#include <algorithm> // for copy
#include <iterator> // for ostream_iterator
#include <vector>

int main() {
    /* Set up vector to hold chars a-z */
    std::vector<char> path;
    for (int ch = 'a'; ch <= 'z'; ++ch)
        path.push_back(ch);

    /* Print path vector to console */
    std::copy(path.begin(), path.end(), std::ostream_iterator<char>(std::cout, " "));

    return 0;
}

ostream_iterator-это то, что называется итератор адаптер. Он шаблонизирован по типу для печати в потоке (в этом случае char). cout (aka console output) - это поток, в который мы хотим писать, и символ пробела (" ") - это то, что мы хотим напечатать между каждым элементом, хранящимся в векторе.

этот стандартный алгоритм могущественны и многие другие. Сила и гибкость стандартная библиотека дает вам то, что делает его таким большим. Только представьте: вы можете напечатать вектор на консоль только с помощью один строка кода. Вам не нужно иметь дело с особыми случаями с символом разделителя. Вам не нужно беспокоиться о for-loops. Стандартная библиотека делает все за вас.

В C++11 Теперь вы можете использовать диапазон на основе цикла:

for (auto const& c : path)
    std::cout << c << ' ';

Я думаю, что лучший способ сделать это-просто перегрузка operator<< добавив эту функцию в свою программу:

#include <vector>
using std::vector;
#include <iostream>
using std::ostream;

template<typename T>
ostream& operator<< (ostream& out, const vector<T>& v) {
    out << "{";
    size_t last = v.size() - 1;
    for(size_t i = 0; i < v.size(); ++i) {
        out << v[i];
        if (i != last) 
            out << ", ";
    }
    out << "}";
    return out;
}

затем вы можете использовать << оператор на любом возможном векторе, предполагая, что его элементы также имеют ostream& operator<< определил:

vector<string>  s = {"first", "second", "third"};
vector<bool>    b = {true, false, true, false, false};
vector<int>     i = {1, 2, 3, 4};
cout << s << endl;
cout << b << endl;
cout << i << endl;

выходы:

{first, second, third}
{1, 0, 1, 0, 0}
{1, 2, 3, 4}

как о for_each + лямбда-выражение:

#include <vector>
#include <algorithm>
...
std::vector<char> vec;
...
std::for_each(
              vec.cbegin(),
              vec.cend(),
              [] (const char c) {std::cout << c << " ";} 
              );
...

конечно, a на основе диапазона для это самое простое решение для этой конкретной задачи, но это дает много других возможностей.

объяснение

на принимает входной диапазон и a callable объект, вызывая этот объект на каждом элементе диапазона. Ан входной диапазон определяется два итераторы. А callable объект может быть функцией, указателем на функцию, объектом класса, который перегружает () operator или как в данном случае, лямбда-выражение. Параметр для этого выражения соответствует типу элементов из vector.

красота этой реализации-это сила, которую вы получаете от лямбда-выражений - вы можете использовать этот подход для гораздо большего, чем просто печать вектора.

проблема, вероятно, в предыдущем цикле:(x = 17; isalpha(firstsquare); x++). Этот цикл не будет работать вообще (если firstsquare не-альфа) или будет работать вечно (если это альфа). Причина в том, что firstsquare не изменяется как x увеличивается.

просто скопируйте контейнер в консоль.

std::vector<int> v{1,2,3,4};
std::copy(v.begin(),v.end(),std::ostream_iterator<int>(std::cout, " " ));

следует вывод :

1 2 3 4

В C++11 цикл for на основе диапазона может быть хорошим решением:

vector<char> items = {'a','b','c'};
for (char n : items)
    cout << n << ' ';

выход:

a b c 

Я вижу две проблемы. Как указано в for (x = 17; isalpha(firstsquare); x++) тут либо бесконечный цикл, либо не выполняется вообще, а также в if (entrance == 'S') если символ входа отличается от "S", то ничего не нажимается на вектор пути, что делает его пустым и, таким образом, ничего не печатает на экране. Вы можете проверить последнюю проверку на path.empty() или печати path.size().

в любом случае, не лучше ли использовать строку вместо вектора? Вы также можете получить доступ к содержимому строки, как к массиву, искать символы, извлекать подстроки и печатать строку легко (без цикла).

выполнение всего этого со строками может быть способом, чтобы он был написан менее запутанным способом и легче определить проблему.

перегрузка оператора

template<typename OutStream, typename T>
OutStream& operator<< (OutStream& out, const vector<T>& v)
{
    for (auto const& tmp : v)
        out << tmp << " ";
    out << endl;
    return out;
}

использование:

vector <int> test {1,2,3};
wcout << test; // or any output stream

этот ответ базируется на ответ от Зоравар, но я не могу оставить там комментарий.

вы можете сделать auto (C++11)/typedef версии const, используя cbegin и cend вместо

for (auto i = path.cbegin(); i != path.cend(); ++i)
    std::cout << *i << ' ';

используя std::copy но без лишних конечный разделитель

альтернативный / модифицированный подход с использованием std::copy (как первоначально использовалось в @JoshuaKravtiz ответ), но без включения дополнительного трейлинг-сепаратора после последнего элемента:

#include <algorithm>
#include <iostream>
#include <iterator>
#include <vector>

template <typename T>
void print_contents(const std::vector<T>& v, const char * const separator = " ")
{
    if(!v.empty())
    {
        std::copy(v.begin(),
                  --v.end(),
                  std::ostream_iterator<T>(std::cout, separator));
        std::cout << v.back() << "\n";
    }
}

// example usage
int main() {
    std::vector<int> v{1, 2, 3, 4};
    print_contents(v);      // '1 2 3 4'
    print_contents(v, ":"); // '1:2:3:4'
    v = {};
    print_contents(v);      // ... no std::cout
    v = {1};
    print_contents(v);      // '1'
    return 0;
}

пример использования, примененный к контейнеру пользовательского типа POD:

// includes and 'print_contents(...)' as above ...

class Foo
{
    int i;
    friend std::ostream& operator<<(std::ostream& out, const Foo& obj);
public:
    Foo(const int i) : i(i) {}
};

std::ostream& operator<<(std::ostream& out, const Foo& obj)
{
    return out << "foo_" << obj.i; 
}

int main() {
    std::vector<Foo> v{1, 2, 3, 4};
    print_contents(v);      // 'foo_1 foo_2 foo_3 foo_4'
    print_contents(v, ":"); // 'foo_1:foo_2:foo_3:foo_4'
    v = {};
    print_contents(v);      // ... no std::cout
    v = {1};
    print_contents(v);      // 'foo_1'
    return 0;
}

В C++11`

for (auto i = path.begin(); i != path.end(); ++i)
std::cout << *i << ' ';

for(int i=0; i<path.size(); ++i)
std::cout << path[i] << ' ';