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

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

#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 принимает входной диапазон и callable объект, вызывая этот объект на каждом элементе диапазона. Ан входной диапазон определяется на два итераторы. А callable объект может быть функция, указатель на функцию, объект класса, который перегружает () operator или как в данном случае, лямбда-выражение. Параметр для этого выражения соответствует типу элементов из вектора.

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

проблема, вероятно, в предыдущем цикле: (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] << ' ';