web-dev-qa-db-fra.com

Imprimer un tableau en C++?

Existe-t-il un moyen d’imprimer des tableaux en C++?

J'essaie de créer une fonction qui inverse un tableau d'entrées utilisateur, puis l'affiche. J'ai essayé googler ce problème et il semblait que C++ ne pouvait pas imprimer de tableaux. Cela ne peut pas être vrai peut-il?

c++arraysprintingreverse
40
JohnHemmars

ne pouvez-vous pas simplement parcourir les éléments? comme ça:

for (int i = numElements - 1; i >= 0; i--) 
    cout << array[i];

Remarque: comme l'a souligné Maxim Egorushkin, cela pourrait déborder. Voir son commentaire ci-dessous pour une meilleure solution.

42
Botz3000

Utilisez le STL

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

int main()
{
    std::vector<int>    userInput;

    // Read until end of input.
    // Hit control D  
    std::copy(std::istream_iterator<int>(std::cin),
              std::istream_iterator<int>(),
              std::back_inserter(userInput)
             );

    // Print in Normal order
    std::copy(userInput.begin(),
              userInput.end(),
              std::ostream_iterator<int>(std::cout,",")
             );
    std::cout << "\n";

    // Print in reverse order:
    std::copy(userInput.rbegin(),
              userInput.rend(),
              std::ostream_iterator<int>(std::cout,",")
             );
    std::cout << "\n";

    // Update for C++11
    // Range based for is now a good alternative.
    for(auto const& value: userInput)
    {
        std::cout << value << ",";
    }
    std::cout << "\n";
}
45
Martin York

Puis-je suggérer d'utiliser l'opérateur de l'os du poisson?

for (auto x = std::end(a); x != std::begin(a); )
{
    std::cout <<*--x<< ' ';
}

(Peux tu le repérer?)

25
fredoverflow

Outre les solutions basées sur une boucle for, vous pouvez également utiliser un ostream_iterator <> . Voici un exemple qui exploite l'exemple de code dans la référence SGI STL (maintenant retirée):

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

int main()
{
  short foo[] = { 1, 3, 5, 7 };

  using namespace std;
  copy(foo,
       foo + sizeof(foo) / sizeof(foo[0]),
       ostream_iterator<short>(cout, "\n"));
}

Cela génère les éléments suivants:

 ./a.out 
1
3
5
7

Cependant, cela peut être excessif pour vos besoins. Vous avez probablement besoin d'une ligne droite, bien que le template template de sucre } _ soit assez sympa aussi.

Edit: Oubli de l'exigence "Impression inversée". Voici une façon de le faire:

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

int main()
{
  short foo[] = { 1, 3, 5, 7 };

  using namespace std;

  reverse_iterator<short *> begin(foo + sizeof(foo) / sizeof(foo[0]));
  reverse_iterator<short *> end(foo);

  copy(begin,
       end,
       ostream_iterator<short>(cout, "\n"));
}

et la sortie:

$ ./a.out 
7
5
3
1

Edit: Mise à jour C++ 14 qui simplifie les extraits de code ci-dessus à l'aide de fonctions d'itérateur de tableau telles que std :: begin () et std :: rbegin () :

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

int main()
{
    short foo[] = { 1, 3, 5, 7 };

    // Generate array iterators using C++14 std::{r}begin()
    // and std::{r}end().

    // Forward
    std::copy(std::begin(foo),
              std::end(foo),
              std::ostream_iterator<short>(std::cout, "\n"));

    // Reverse
    std::copy(std::rbegin(foo),
              std::rend(foo),
              std::ostream_iterator<short>(std::cout, "\n"));
}
12
Void

Il y a des tableaux déclarés et des tableaux qui sont non déclarés, mais créés autrement, en utilisant notamment new:

int *p = new int[3];

Ce tableau avec 3 éléments est créé dynamiquement (et 3 aurait pu être calculé également à l'exécution), et un pointeur sur celui-ci dont la taille est effacée de son type est attribué à p. Vous ne pouvez plus obtenir la taille pour imprimer ce tableau. Une fonction qui ne reçoit que le pointeur sur elle ne peut donc pas imprimer ce tableau. 

L'impression de tableaux déclarés est facile. Vous pouvez utiliser sizeof pour obtenir leur taille et la transmettre à la fonction, y compris un pointeur sur les éléments de ce tableau. Mais vous pouvez également créer un modèle qui accepte le tableau et déduit sa taille de son type déclaré:

template<typename Type, int Size>
void print(Type const(& array)[Size]) {
  for(int i=0; i<Size; i++)
    std::cout << array[i] << std::endl;
}

Le problème avec ceci est qu'il n'acceptera pas les pointeurs (évidemment). Je pense que la solution la plus simple consiste à utiliser std::vector. C'est un "tableau" dynamique redimensionnable (avec la sémantique que vous attendriez d'un vrai), qui a une fonction membre size:

void print(std::vector<int> const &v) {
  std::vector<int>::size_type i;
  for(i = 0; i<v.size(); i++)
    std::cout << v[i] << std::endl;
}

Bien entendu, vous pouvez également en faire un modèle pour accepter des vecteurs d’autres types. 

6
Johannes Schaub - litb

La plupart des bibliothèques couramment utilisées en C++ ne peuvent pas imprimer de tableaux en tant que telles. Vous devrez le parcourir manuellement et imprimer chaque valeur.

L'impression de tableaux et le vidage de nombreux types d'objets sont une caractéristique des langages de niveau supérieur.

3
Faxwell Mingleton

C'est certainement! Vous devrez parcourir le tableau et imprimer chaque élément individuellement.

3
Andy Mikula

C++ peut imprimer ce que vous voulez si vous le programmez pour le faire. Vous devrez parcourir vous-même le tableau en imprimant chaque élément.

3
Cogwheel

Cela pourrait aider//Imprimer le tableau

for (int i = 0; i < n; i++)
{cout << numbers[i];}

n est la taille du tableau

0
Arinjoy Pramanik

Ma réponse simple est:

#include <iostream>
using namespace std;

int main()
{
    int data[]{ 1, 2, 7 };
    for (int i = sizeof(data) / sizeof(data[0])-1; i >= 0; i--) {
        cout << data[i];
    }

    return 0;
}
0
ej8000