L'impression d'un tableau en C++?

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

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

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

(voyez-vous?)

en plus des solutions for-loop, vous pouvez également utiliser un ostream_iterator<>. Voici un exemple qui utilise le code échantillon dans la référence SGI STL:

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

c'est Ce qui génère le code suivant:

 ./a.out 
1
3
5
7

cependant, cela peut être exagéré pour vos besoins. Une quinte de boucle est probablement tout ce que vous avez besoin, mais litb du modèle de sucre est très belle, elle aussi.

Modifier: Oublié le "impression en inverse" de l'exigence. 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

Il y a a déclaré tableaux et les tableaux qui sont déclaré, mais autrement créé, en particulier en utilisant new:

int *p = new int[3];

ce tableau avec 3 éléments est créé dynamiquement (et que 3 aurait pu être calculé à l'exécution, aussi), et un pointeur vers lui qui a la taille effacée de son type est assigné à p. Vous ne pouvez plus obtenir la taille pour imprimer ce tableau. Une fonction qui reçoit uniquement le pointeur peut donc pas imprimer ce tableau.

L'impression des tableaux déclarés est facile. Vous pouvez utiliser sizeof pour obtenir leur taille et passer cette taille le long de la fonction, y compris un pointeur vers les éléments de ce tableau. Mais vous pouvez aussi créer un template 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, c'est qu'il n'accepte pas les pointeurs (évidemment). La solution la plus simple, je pense, est d'utiliser std::vector. C'est un "tableau" dynamique, redimensionnable (avec sémantique que vous attendez d'un vrai), qui a un size fonction de membre:

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

Vous pouvez, bien sûr, également faire de ce modèle pour accepter les vecteurs d'autres types.

la plupart des bibliothèques couramment utilisées en C++ ne peuvent pas imprimer des tableaux, en soi. Vous devrez le passer en boucle manuellement et imprimer chaque valeur.

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

ça l'est certainement! Vous aurez à parcourir le tableau et imprimer chaque élément individuellement.

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

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

Ou vous pouvez utiliser ceci: https://github.com/gileli121/VectorEx

Vous pouvez facilement afficher le tableau avec DisplayVector_1d(). Il s'est développé sous visual studio 2015. t ne fonctionne que sous windows (testé sur windows 7 64 bits).

ce que vous recherchez dans cette bibliothèque est DisplayVector_1d. I

il affichera le tableau dans l'interface graphique de listview. C'est comme la fonction _ArrayDisplay dans Autoit.

voici un exemple d'utilisation ceci:

// includes.functions
#include <windows.h>

#include "VectorEx\VectorEx.h"
#include "VectorEx\VectorDisplay.h"
using namespace vectorex;
using namespace vectordisplay;


/*
    This example shows how to use display std::vector array datatype
    with vectordisplay::DisplayVector_1d
*/


int main()
{
    std::vector<std::string> stringVector;

    stringVector.push_back("Bob");
    stringVector.push_back("Fob");
    stringVector.push_back("Rob");
    stringVector.push_back("Nob");

    DisplayVector_1d(&stringVector);

    return 0;
}

notez que je viens de commencer à travailler sur ce projet. Vous êtes invités à améliorer le code et corriger les bogues

Pour un tableau à deux dimensions:

int main (){
    // My  array:
    string myarray[5][2] = { {"a","b" }, {"b","c"}, {"a","c"}, {"c","d"}, {"b","d"} };

    for (int i=0; i< sizeof(myarray)/sizeof(myarray[0]); i++)
        for (int j=0; j< sizeof(myarray[i])/sizeof(myarray[i][0]); j++)
        cout << myarray[i][j];

    return 0;
}

Pour un tableau simple:

int main (){
    // My array:
    int myarray[5] = {1,2,3,4,5};

    for (int i=0; i< sizeof(myarray)/sizeof(myarray[0]); i++)
        cout << myarray[i];

    return 0;
}