Como imprimir o conteúdo de um vetor?

Uma maneira muito mais fácil de fazer isto é com o algoritmo de cópia padrão :

#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;
}

O ostream_iterador é o que se chama um adaptador iterador . É templatizado sobre o tipo a imprimir para o fluxo (neste caso, char). cout (também conhecido como saída de consola) é o fluxo para o qual queremos escrever, e o carácter do espaço (" ") é o que queremos imprimir entre cada elemento armazenado no vector.

Este algoritmo padrão é poderoso, assim como muitos outros. O poder e flexibilidade que a biblioteca padrão lhe dá são o que a torna tão grande. Basta imaginar: você pode imprimir um vetor para a consola com apenas uma linha de código. Não tens de lidar com casos especiais com o Carácter separador. Não precisas de te preocupar com isso. A biblioteca normal faz tudo por ti.

Em C++11 pode agora usar um intervalo para o loop:

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

Acho que a melhor maneira de fazer isto é sobrecarregar {[3] } adicionando esta função ao seu programa:

#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;
}

Depois pode usar o operador << em qualquer vector possível, assumindo que os seus elementos também têm ostream& operator<< definido:

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;

Saídas:

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

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

Claro, uma gama debaseada em é a solução mais elegante para esta tarefa concreta, mas esta também dá muitas outras possibilidades.

Anotações

O algoritmo for_each toma um intervalo de entrada e um objecto chamável , chamando este objecto para cada elemento do intervalo. Um intervalo de entrada é definido por dois iteradores . Umobjecto chamável pode ser uma função, um ponteiro para função, um objeto de uma classe que sobrecarrega () operator ou como neste caso, uma expressão lambda. O parâmetro para esta expressão corresponde ao tipo dos elementos do vetor.

A beleza desta implementação é o poder que você obtém das expressões lambda-você pode usar esta abordagem para muito mais coisas do que apenas imprimir o vetor.

O problema está provavelmente no loop anterior: (x = 17; isalpha(firstsquare); x++). Este ciclo não irá correr de todo (se firstsquare não for alfa) ou irá correr para sempre (se for Alfa). A razão é que firstsquare não muda porque {[3] } é aumentado.

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

Deve sair:

1 2 3 4

Em C++11, uma gama de loop pode ser uma boa solução:

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

Resultado:

a b c 

Operador de sobrecarga

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

Utilização:

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

Você poderá fazer o auto (C++11)/typedef version const, usando o cbegin e o cend em alternativa

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

Usando std::copy mas sem separador de saída extra

Uma abordagem alternativa / modificada utilizando std::copy (Como foi usado originalmente em @JoshuaKravtiz answer ), mas sem incluir um separador adicional após o último elemento:

#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;
}

Uso de exemplo aplicado ao Contentor de um tipo de POD personalizado:

// 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;
}

Em 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] << ' ';