Drukowanie tablicy w C++?

Użyj 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";
}

Czy Mogę zasugerować użycie operatora kości ryb?

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

(możesz to zauważyć?)

Oprócz rozwiązań opartych na pętli for, można również użyć ostream_iterator . Oto przykład, który wykorzystuje przykładowy kod W referencji 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"));
}

Generuje to:

 ./a.out 
1
3
5
7

Jednak może to być przesada dla Twoich potrzeb. Prosta pętla for to prawdopodobnie wszystko, czego potrzebujesz, chociaż szablon LITB sugar jest również całkiem ładny.

Edit : zapomniałem wymogu "drukowanie w odwrotnej kolejności". Jest jeden sposób, aby to zrobić it:

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

I wyjście:

$ ./a.out 
7
5
3
1

Istnieją zadeklarowane tablice i tablice, które nie są zadeklarowane, ale w inny sposób utworzone, szczególnie przy użyciu new:

int *p = new int[3];

Tablica z 3 elementami jest tworzona dynamicznie (i że 3 można było również obliczyć w czasie wykonywania), a wskaźnik do niej, który ma rozmiar wymazany ze swojego typu, jest przypisany do p. Nie można już uzyskać rozmiaru, aby wydrukować tę tablicę. Funkcja, która odbiera tylko wskaźnik do niej, nie może więc wydrukować tej tablicy.

Drukowanie zadeklarowanych tablic jest łatwe. Możesz użyć sizeof, aby uzyskać ich rozmiar i przekazać go do funkcji zawierającej wskaźnik do elementów tablicy. Ale można również utworzyć szablon, który akceptuje tablicę i wywnioskuje jej rozmiar z zadeklarowanego typu:

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

Problem polega na tym, że nie akceptuje wskaźników (oczywiście). Najprostszym rozwiązaniem jest użycie std::vector. Jest to dynamiczna, skalowalna "tablica" (z semantyką, jakiej można oczekiwać od prawdziwej), który posiada size funkcję członka:

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

Można oczywiście uczynić z tego szablon akceptujący wektory innych typów.

Większość bibliotek powszechnie używanych w C++ nie może drukować tablic, per se. Będziesz musiał przebić się przez nią ręcznie i wydrukować każdą wartość.

Drukowanie tablic i zrzucanie wielu różnego rodzaju obiektów jest cechą języków wyższego poziomu.

Z pewnością jest! Będziesz musiał zapętlić tablicę i wydrukować każdy element indywidualnie.

C++ może drukować co tylko chcesz, jeśli go do tego zaprogramujesz. Będziesz musiał przejść przez tablicę samodzielnie drukując każdy element.

Moja prosta odpowiedź brzmi:

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

Lub możesz użyć tego: https://github.com/gileli121/VectorEx

Możesz łatwo wyświetlić tablicę za pomocą DisplayVector_1d(). Powstał w ramach programu visual studio 2015. t działa tylko pod windows (testowane na windows 7 64 bit).

To, czego szukasz w tej bibliotece, to DisplayVector_1d. I

Wyświetli tablicę w GUI listview. to jest jak funkcja _arraydisplay w Autoit.

Oto przykład użycia to:

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

Zauważ, że właśnie zacząłem pracować nad tym projektem. Zapraszamy do ulepszania kodu i naprawiania błędów

Dla tablicy dwuwymiarowej:

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

Dla prostej tablicy:

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