Comment imprimer le contenu d'un vecteur?

Purement pour répondre à votre question, vous pouvez utiliser un itérateur:

std::vector<char> path;
//...
for (std::vector<char>::const_iterator i = path.begin(); i != path.end(); ++i)
    std::cout << *i << ' ';

Si vous souhaitez modifier le vecteur contenu dans la boucle, puis utilisez iterator plutôt que const_iterator.

Mais il y a beaucoup plus qui peut être dit au sujet de cette. Si vous voulez juste une réponse, vous pouvez utiliser, alors vous pouvez arrêter ici; sinon, lisez la suite.

auto (C++11)/typedef

Ce n'est pas une autre solution, mais un complément à ce qui précède iterator solution. Si vous êtes en utilisant le C++11 (ou version ultérieure), vous pouvez utiliser le auto mot-clé pour aider à la lisibilité:

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

Mais le type de i sera non-const (c, le compilateur utilisera std::vector<char>::iterator que le type de i).

Dans ce cas, vous pourriez tout aussi bien utiliser un typedef (pas de restriction de C++11, et très utile de l'utiliser de toute façon):

typedef std::vector<char> Path;
Path path;
//...
for (Path::const_iterator i = path.begin(); i != path.end(); ++i)
    std::cout << *i << ' ';

contre

Vous pouvez, bien sûr, utiliser un type entier pour enregistrer votre position dans le for boucle:

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

Si vous allez pour ce faire, il est préférable d'utiliser le conteneur types de membres, si elles sont disponibles et appropriées. std::vector a un type de membre appelé size_type pour ce travail: c'est le type retourné par le size méthode.

//Path typedef'd to std::vector<char>
for( Path::size_type i=0; i<path.size(); ++i)
  std::cout << path[i] << ' ';

Pourquoi ne pas utiliser cette sur la iterator solution? Pour les cas simples, vous pourriez aussi bien, mais le point est que le iterator classe est un objet conçu pour faire ce travail pour plus des objets compliqués où cette solution n'est pas idéale.

gamme à base de boucle (C++11)

Voir Jefffrey de la solution. En C++11 (et plus tard), vous pouvez utiliser la nouvelle gamme à base de for boucle, qui ressemble à ceci:

for (auto i: path)
  std::cout << i << ' ';

Depuis path est un vecteur d'éléments (explicitement std::vector<char>), l'objet i est de type de l'élément du vecteur (c'est à dire, explicitement, il est de type char). L'objet i a une valeur qui est une copie de l'élément dans la path objet. Ainsi, toutes les modifications apportées à i dans la boucle ne sont pas conservées dans path lui-même. En outre, si vous souhaitez faire respecter le fait que vous ne voulez pas être en mesure de modifier la valeur copiée de i dans la boucle, vous pouvez forcer le type de i être const char comme ceci:

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

Si vous souhaitez modifier les éléments dans path, vous pouvez utiliser une référence:

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

et même si vous ne voulez pas modifier les path, si la copie d'objets est cher vous devez utiliser const référence au lieu de la copie par valeur:

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

std::copy

Voir Joshua répondre. Vous pouvez utiliser la STL algorithme std::copy pour copier le vecteur de contenu sur le flux de sortie. C'est une solution élégante, si vous êtes à l'aise avec elle (et d'ailleurs, il est très utile, pas seulement dans ce cas de l'impression du contenu d'un vecteur).

std::for_each

Voir Max est la solution. À l'aide de std::for_each est overkill pour ce scénario simple, mais c'est une solution très pratique si vous voulais faire plus que juste l'impression à l'écran: à l'aide de std::for_each vous permet de faire des tout (sensible) de l'opération sur le vecteur contenu.

surcharge ostream::operator<<

Voir Chris répondre, c'est plus un complément à d'autres réponses car vous en aurez toujours besoin de mettre en œuvre l'une des solutions ci-dessus dans la surcharge. Dans son exemple, il a utilisé un compteur dans une for boucle. Par exemple, c'est comment vous pouvez rapidement utiliser Joshua solution:

template <typename T>
std::ostream& operator<< (std::ostream& out, const std::vector<T>& v) {
  if ( !v.empty() ) {
    out << '[';
    std::copy (v.begin(), v.end(), std::ostream_iterator<T>(out, ", "));
    out << "\b\b]";
  }
  return out;
}

L'utilisation de l'un quelconque des autres solutions doivent être simples.

conclusion

Aucune des solutions présentées ici fonctionne. C'est à vous et le code sur lequel est le "meilleur". Quelque chose de plus détaillé que ce soit probablement le meilleur à gauche pour une autre question à laquelle les avantages/inconvénients peuvent être correctement évalués; mais, comme toujours, de préférence de l'utilisateur seront toujours de la partie: aucune des solutions présentées sont faux, mais certains vont regarder de plus agréable pour chaque codeur.

additif

C'est une expansion de la solution d'un précédent que j'ai posté. Depuis que la poste a continué de faire attention, j'ai décidé d'élargir et d'en référer à l'autre d'excellentes solutions qui ont été posté ici. Mon post original a une remarque qui dit que si vous ont été l'intention de modifier votre vecteur à l'intérieur d'un for boucle puis il y a deux méthodes fournies par std::vector d'accéder à des éléments: std::vector::operator[] qui ne fait pas la vérification des limites, et std::vector::at qui effectue la vérification des limites. En d'autres termes, at va jeter si vous essayez d'accéder à un élément en dehors du vecteur et operator[] ne serait pas. J'ai seulement ajouté ce commentaire, à l'origine, pour le bien de parler de quelque chose qu'il pourrait être utile de savoir si les gens déjà n'ai pas. Et je vois pas de différence. D'où le présent avenant.

En C++11, vous pouvez désormais utiliser un gamme à base de boucle:

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

Comment sur for_each + lambda expression:

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

Bien sûr, un gamme à base de est la solution la plus élégante pour cette tâche concrète, mais celui-ci offre de nombreuses autres possibilités.

Explication

La for_each algorithme prend un d'entrée de gamme et un objet appelable, l'appel de cette objet sur chaque élément de la gamme. Un d'entrée de gamme est définie par deux itérateurs. Un objet appelable peut être une fonction, un pointeur de fonction, un objet d'une classe qui surcharge () operator ou comme dans ce cas, une expression lambda. Le paramètre de cette expression correspond au type des éléments du vecteur.

La beauté de cette application est la puissance que vous obtenez à partir d'expressions lambda - vous pouvez utiliser cette approche pour beaucoup plus de choses que juste l'impression de le vecteur.

Le problème est probablement dans le précédent boucle: (x = 17; isalpha(firstsquare); x++). Cette boucle sera exécuté pas à tous (si firstsquare est non-alpha) ou s'exécute indéfiniment (si c'est de l'alpha). La raison en est que firstsquare ne change pas comme x est incrémenté.

À l'aide de std::copy mais sans extra fin séparateur

Une alternative/approche modifiée à l'aide de std::copy (comme à l'origine utilisé dans @JoshuaKravtiz répondre), mais sans le fait d'ajouter un séparateur à droite après le dernier élément:

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

---

Exemple d'utilisation appliquée à conteneurs d'un type 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;
}

surcharge de l'opérateur<<:

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

Utilisation:

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

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

#include<bits/stdc++.h>
using namespace std;

int main()
{
    vector <pair<string,int> > v;
    int n;
    cin>>n;
int i;
    for( i=0;i<n;i++)
    {
        int  end;
        string str;
        cin>>str;
        cin>>end;
        v.push_back(make_pair(str,end));
    }



for (int j=0;j<n;j++)
{
    cout<<v[j].first<< " "<<v[j].second<<endl;
}``
}