Печать массива на С++?

Ответ 1

Просто переберите элементы. Вот так:

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

Примечание: как отметил Максим Егорушкин, это может переполниться. Смотрите его комментарий ниже для лучшего решения.

Ответ 2

Используйте 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";
}

Ответ 3

Могу ли я предложить использовать оператора рыбой?

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

(Можете ли вы это заметить?)

Ответ 4

Помимо решений на основе циклы, вы также можете использовать ostream_iterator <>. Здесь пример, который использует примерный код в ссылке (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"));
}

Это генерирует следующее:

 ./a.out 
1
3
5
7

Однако это может быть излишним для ваших нужд. Прямо для циклы, вероятно, все, что вам нужно, хотя ламповый шаблонный сахар тоже неплох.

Изменить: Забыл "печать в обратном порядке". Вот один из способов сделать это:

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

и выход:

$ ./a.out 
7
5
3
1

Изменить: обновление С++ 14, упрощающее приведенные выше фрагменты кода с использованием функций итератора массива, таких как std :: begin() и 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"));
}

Ответ 5

Объявлены массивы и массивы, которые не объявлены, но созданы иным образом, в частности, используя new:

int *p = new int[3];

Этот массив с 3 элементами создается динамически (и что 3 может быть рассчитан и во время выполнения), а указатель на него, размер которого стирается от его типа, присваивается p. Вы больше не можете получить размер для печати этого массива. Таким образом, функция, которая получает только указатель, может не печатать этот массив.

Печатать объявленные массивы легко. Вы можете использовать sizeof, чтобы получить их размер и передать этот размер вместе с функцией, включая указатель на эти элементы массива. Но вы также можете создать шаблон, который принимает массив, и выводит его размер из объявленного типа:

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

Проблема заключается в том, что он не будет принимать указатели (очевидно). Самое легкое решение, я думаю, заключается в использовании std::vector. Это динамический, масштабируемый "массив" (с семантикой, которую вы ожидаете от реального), который имеет функцию члена 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;
}

Вы можете, конечно, также сделать этот шаблон для принятия векторов других типов.

Ответ 6

Большинство библиотек, обычно используемых на С++, не могут печатать массивы, как таковые. Вам нужно будет пропустить его вручную и распечатать каждое значение.

Печатные массивы и демпинг многих различных объектов - это функция языков более высокого уровня.

Ответ 7

Конечно! Вам нужно будет пройти через массив и распечатать каждый элемент по отдельности.

Ответ 8

С++ может печатать все, что вы хотите, если вы его запрограммируете. Вам придется пройти через массив, который печатает каждый элемент.

Ответ 9

Это может помочь//Печать массива

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

n - размер массива

Ответ 10

Мой простой ответ:

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

Ответ 11

Поезд ушел? Почему бы просто:

float data[16] = {};

// filling some array data...

for(float i : data) {
    std::cout << i << std::endl;
}

Ответ 12

Или вы можете использовать это: https://github.com/gileli121/VectorEx

Вы можете легко отобразить массив с помощью DisplayVector_1d(). Он разрабатывался под визуальной студией 2015. t работает только под окнами (протестирован на Windows 7 64 бит).

То, что вы просматриваете в этой библиотеке, - DisplayVector_1d. I

Он отобразит массив в графическом интерфейсе listview. это похоже на функцию _ArrayDisplay в Autoit.

Вот пример того, как это использовать:

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

Обратите внимание, что я только начал работать над этим проектом. Вы можете улучшить код и исправить ошибки.

Ответ 13

Для двухмерного массива:

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

Для простого массива:

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