82

Is there a way of printing arrays in C++?

I'm trying to make a function that reverses a user-input array and then prints it out. I tried Googling this problem and it seemed like C++ can't print arrays. That can't be true can it?

Improve this question
1
  • 8
    The question itself is a bit flawed, tbh. Have you thought of what it even means to "print an array"? What is the data type on the array (number, string, user-defined, etc.)? How should the data be displayed? Do you need commas in the number? Do you want scientific notation? Should each element be on a separate line or do you want to distribute them in columns? Should columns be fixed width or dynamic? Commented Oct 28, 2009 at 15:52

15 Answers 15

Reset to default
76

Just iterate over the elements. Like this:

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

Note: As Maxim Egorushkin pointed out, this could overflow. See his comment below for a better solution.

Improve this answer
Sign up to request clarification or add additional context in comments.

7 Comments

I'd also like to note, that in C++ world you mostly don't create a new, reversed array and then print it. Instead, you usually iterate the array in the other way: for (i = numElements-1; i>=0; i--) cout << array[i] << ",";
You forgot to declare the i as an integer didn' you? That's what I did (well not really since I was supposed to reverse it).. so doing something like "for (int i = staerd-1; i >= 0; i--)" is the best way?
This version might overflow int, since the number of elements is size_t. Robust version is even more elegant: for(size_t i = numElements; i--;)
@MaximEgorushkin I see your point, your solution seems to be the best way to do it.
for(auto x: someArray){cout<<x<<endl;};
|
50

Use the STL

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

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

    // ITs 2021 now move this up as probably the best way to do it.
    // Range based for is now "probably" the best alternative C++20
    // As we have all the range based extension being added to the language
    for(auto const& value: userInput)
    {
        std::cout << value << ",";
    }
    std::cout << "\n";

    // Print the array in reverse using the range based stuff
    for(auto const& value: userInput | std::views::reverse)
    {
        std::cout << value << ",";
    }
    std::cout << "\n";


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

}
Improve this answer

3 Comments

this I just ran this on gcc 4.6.1 using g++..it does not work
Just wondering whether there is any speed advantage with this approach?
@SamStoelinga: In speed terms. Always measure. I would use this for readability (thus maintainability). But iterators on vectors have always been considered very efficient so its not a worry I would really consider in most situations (unless speed was critical).
38

May I suggest using the fish bone operator?

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

(Can you spot it?)

Improve this answer

Comments

15

Besides the for-loop based solutions, you can also use an ostream_iterator<>. Here's an example that leverages the sample code in the (now retired) SGI STL reference:

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

This generates the following:

 ./a.out 
1
3
5
7

However, this may be overkill for your needs. A straight for-loop is probably all that you need, although litb's template sugar is quite nice, too.

Edit: Forgot the "printing in reverse" requirement. Here's one way to do 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"));
}

and the output:

$ ./a.out 
7
5
3
1

Edit: C++14 update that simplifies the above code snippets using array iterator functions like std::begin() and 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"));
}
Improve this answer

Comments

8

There are declared arrays and arrays that are not declared, but otherwise created, particularly using new:

int *p = new int[3];

That array with 3 elements is created dynamically (and that 3 could have been calculated at runtime, too), and a pointer to it which has the size erased from its type is assigned to p. You cannot get the size anymore to print that array. A function that only receives the pointer to it can thus not print that array.

Printing declared arrays is easy. You can use sizeof to get their size and pass that size along to the function including a pointer to that array's elements. But you can also create a template that accepts the array, and deduces its size from its declared type:

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

The problem with this is that it won't accept pointers (obviously). The easiest solution, I think, is to use std::vector. It is a dynamic, resizable "array" (with the semantics you would expect from a real one), which has a size member function:

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

You can, of course, also make this a template to accept vectors of other types.

Improve this answer

1 Comment

What, no std::copy_n to an ostream_iterator? ;-)
4

Most of the libraries commonly used in C++ can't print arrays, per se. You'll have to loop through it manually and print out each value.

Printing arrays and dumping many different kinds of objects is a feature of higher level languages.

Improve this answer

1 Comment

You can do it one statement in C++. I don't see this as a missing feature as using iterators makes it so much more powerful. Now I can abstract away where I am printing: it does not matter if the destination is console, pipe, file, another container, a function, a DB. It all looks and behaves the same.
3

It certainly is! You'll have to loop through the array and print out each item individually.

Improve this answer

4 Comments

standard algorithms dont require a loop. (though thay may use one internally).
What if I don't have access to the STL?
Then you aren't using C++. Perhaps you're using Symbian/C++, or some subset of C++ provided by an embedded compiler. (Granted that technically, the STL is a precursor to the standard libraries in standard C++. But usually when people say "STL", they mean "the class and function templates in the C++ standard libraries", not the pre-standard STL. Hence STL is a subset of C++).
@Steve "Then you aren't using C++" Not necessarily so. A freestanding implementation is explicitly permitted to omit all but a small collection of standard headers, and none of those mandated contains functionality inherited from the STL. Further reading
1

This might help //Printing The Array

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

n is the size of the array

Improve this answer

Comments

1 
std::string ss[] = { "qwerty", "asdfg", "zxcvb" };
for ( auto el : ss ) std::cout << el << '\n';

Works basically like foreach.

Improve this answer

Comments

0

My simple answer is:

#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;
}
Improve this answer

3 Comments

Explaining your code, and how it responds to the question, would greatly increase the quality of this answer.
The code is self-explanatory it reverses an array and print it as elements
the output is 721
0

You can use reverse iterators to print an array in reverse:

#include <iostream>

int main() {
    int x[] = {1,2,3,4,5};
    for (auto it = std::rbegin(x); it != std::rend(x); ++it) 
        std::cout << *it;
}

output

54321

If you already reversed the array, you can replace std::rbegin and std::rend with std::begin/std::end, respectively, to iterate the array in forward direction.

Improve this answer

Comments

0

It's quite straightforward to copy the array's elements to a suitable output iterator. For example (using C++20 for the Ranges version):

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

template<typename T, std::size_t N>
std::ostream& print_array(std::ostream& os, std::array<T,N> const& arr)
{
    std::ranges::copy(arr, std::ostream_iterator<T>(os, ", "));
    return os;
}

Quick demo:

int main()
{
    std::array example{ "zero", "one", "two", "three", };
    print_array(std::cout, example) << '\n';
}

Of course it's more useful if we can output any kind of collection, not only arrays:

#include <algorithm>
#include <iterator>
#include <iosfwd>
#include <ranges>

template<std::ranges::input_range R>
std::ostream& print_array(std::ostream& os, R const& arr)
{
    using T = std::ranges::range_value_t<R>;
    std::ranges::copy(arr, std::ostream_iterator<T>(os, ", "));
    return os;
}

The question mentions reversing the array for printing. That's easily achieved by using a view adapter:

    print_array(std::cout, example | std::views::reverse) << '\n';
Improve this answer

Comments

0

This code prints an array (a) with newlines inserted after each element:

#include <iostream>
#include <iterator>

int main()
{
    int a[]{ 1, 2, 3, 4, 5 };
    std::copy(
        std::begin(a),
        std::end(a),
        std::ostream_iterator<int>(std::cout, "\n"));
    return 0;
}

Output:

1
2
3
4
5
Improve this answer

Comments

-2 
// Just do this, use a vector with this code and you're good lol -Daniel

#include <Windows.h>
#include <iostream>
#include <vector>

using namespace std;


int main()
{

    std::vector<const char*> arry = { "Item 0","Item 1","Item 2","Item 3" ,"Item 4","Yay we at the end of the array"};
    
    if (arry.size() != arry.size() || arry.empty()) {
        printf("what happened to the array lol\n ");
        system("PAUSE");
    }
    for (int i = 0; i < arry.size(); i++)
    {   
        if (arry.max_size() == true) {
            cout << "Max size of array reached!";
        }
        cout << "Array Value " << i << " = " << arry.at(i) << endl;
            
    }
}
Improve this answer

2 Comments

Could tou give more details with your code, some explanation will be welcome ;)
I'm pretty sure <Windows.h> is not a standard C++ header.
-4

If you want to make a function that prints every single element in an array;

#include <iostream>
using namespace std;

int myArray[] = {1,2,3,4, 77, 88};

void coutArr(int *arr, int size){
   for(int i=0; i<size/4; i++){
      cout << arr[i] << endl;
   }
}

int main(){
   coutArr(myArray, sizeof(myArray));
}

The function above prints every single element in an array only, not commas etc.

You may be wondering "Why sizeoff(arr) divided by 4?". It's because cpp prints 4 if there's only a single element in an array.

Improve this answer

6 Comments

This doesn't compile.
Sorry! I was too careless. I should've put an asterisk before the "arr" argument. It worked now.
Now it always prints 3 elements, regardless of the array size: gcc.godbolt.org/z/qWfcYr5sx
This is better, but you should divide by sizeof(int), not 4.
you should use std::size not sizeof.
|

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.