Cómo imprimir el contenido de un vector?

Una forma mucho más fácil de hacer esto es con el algoritmo de copia estándar :

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

El ostream_iterator es lo que se llama un adaptador iterador . Se templatiza sobre el tipo para imprimir en la secuencia (en este caso, char). cout (también conocido como salida de consola) es la secuencia en la que queremos escribir, y el carácter de espacio (" ") es lo que queremos imprimir entre cada elemento almacenado en el vector.

Este algoritmo estándar es poderoso y también lo son muchos otros. Energía y la flexibilidad que la biblioteca estándar le da es lo que la hace tan grande. Imagínese: puede imprimir un vector en la consola con solo una línea de código. No tiene que tratar con casos especiales con el carácter separador. No tienes que preocuparte por los bucles. La biblioteca estándar lo hace todo por usted.

En C++11 ahora puede usar un bucle for basado en rango :

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

Creo que la mejor manera de hacer esto es simplemente sobrecargar operator<< agregando esta función a su 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;
}

Entonces puede usar el operador << en cualquier vector posible, asumiendo que sus elementos también tienen 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;

Salidas:

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

¿Qué tal for_each + expresión lambda :

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

Por supuesto, un rango para es la solución más elegante para esta tarea concreta, pero esto da muchas más posibilidades.

Explicación

El algoritmo for_each toma un rango de entrada y un objeto llamable , llamando a este objeto en cada elemento del rango. Un rango de entrada está definido por dos iteradores . Un objeto invocable puede ser un function, un puntero a function, un objeto de una clase que sobrecarga () operator o como en este caso, una expresión lambda. El parámetro para esta expresión coincide con el tipo de los elementos de vector.

La belleza de esta implementación es el poder que obtiene de las expresiones lambda: puede usar este enfoque para muchas más cosas que solo imprimir el vector.

El problema está probablemente en el bucle anterior: (x = 17; isalpha(firstsquare); x++). Este bucle no se ejecutará en absoluto (si firstsquare no es alfa) o se ejecutará para siempre (si es alfa). La razón es que firstsquare no cambia a medida que x se incrementa.

Simplemente copie el contenedor a la consola.

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

Debería generar:

1 2 3 4

En C++11, un bucle for basado en rango podría ser una buena solución:

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

Salida:

a b c 

, veo dos problemas. Como se señala en for (x = 17; isalpha(firstsquare); x++) hay un bucle infinito o nunca ejecutado, y también en if (entrance == 'S') si el carácter de entrada es diferente de 'S', entonces nada se empuja al vector de ruta, lo que lo vacía y por lo tanto no imprime nada en la pantalla. Puede probar este último comprobando path.empty() o imprimiendo path.size().

De cualquier manera, ¿no sería mejor usar una cadena en lugar de un vector? También puede acceder al contenido de la cadena como una matriz, buscar caracteres, extraer subcadenas e imprimir la cadena fácilmente (sin un bucle).

Hacerlo todo con cadenas podría ser la manera de tenerlo escrito de una manera menos complicada y más fácil de detectar el problema.

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

Uso:

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

Esta respuesta se basa en la respuesta de Zorawar, pero no podía dejar un comentario allí.

Puede hacer que la versión auto (C++11)/typedef const usando cbegin y cend en su lugar

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

Usando std::copy pero sin separador final adicional

Un enfoque alternativo / modificado utilizando std::copy (como se usó originalmente en @ JoshuaKravtiz answer ) pero sin incluir un separador final adicional después del ú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;
}

Ejemplo de uso aplicado al contenedor de un 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;
}

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