Een array afdrukken in C++?

Is er een manier om arrays af te drukken in C++?

Ik probeer een functie te maken die een gebruikersinvoerarray omkeert en deze vervolgens afdrukt. Ik heb geprobeerd dit probleem te Googlen en het leek alsof C++ geen arrays kan afdrukken. Dat kan toch niet waar zijn?


Antwoord 1, autoriteit 100%

Herhaal gewoon de elementen. Zoals dit:

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

Opmerking: zoals Maxim Egorushkin opmerkte, kan dit overlopen. Zie zijn opmerking hieronder voor een betere oplossing.


Antwoord 2, autoriteit 81%

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

Antwoord 3, autoriteit 59%

Mag ik voorstellen om de visgraatoperator te gebruiken?

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

(Kun je het zien?)


Antwoord 4, autoriteit 22%

Naast de op for-loop gebaseerde oplossingen, kunt u ook een ostream_iterator<> . Hier is een voorbeeld dat gebruikmaakt van de voorbeeldcode in de (nu gepensioneerde) SGI STL-referentie:

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

Dit genereert het volgende:

./a.out 
1
3
5
7

Dit kan echter overdreven zijn voor uw behoeften. Een straight for-loop is waarschijnlijk alles wat je nodig hebt, hoewel litb’s template sugarook best aardig is.

Bewerken: de vereiste “omgekeerd afdrukken” vergeten. Hier is een manier om het te doen:

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

en de uitvoer:

$ ./a.out 
7
5
3
1

Bewerken: C++14-update die de bovenstaande codefragmenten vereenvoudigt met behulp van array-iteratorfuncties zoals std::begin()en 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"));
}

Antwoord 5, autoriteit 11%

Er zijn gedeclareerde arraysen arrays die nietzijn gedeclareerd, maar anderszins zijn gemaakt, met name met behulp van new:

int *p = new int[3];

Die array met 3 elementen wordt dynamisch gemaakt (en dat 3kan zijn berekend op runtime, ook) en een aanwijzer daarop die de grootte heeft gewist uit het type is toegewezen aan p. U kunt de grootte niet meer krijgen om die array af te drukken. Een functie die de aanwijzer alleen ontvangt, kan deze array dus niet afdrukken.

Afdrukken gedeclareerde arrays is eenvoudig. U kunt sizeofgebruiken om hun formaat te krijgen en die maat door te geven aan de functie, inclusief een aanwijzer op de elementen van die array. Maar u kunt ook een sjabloon maken die de array accepteert, en de grootte van het gedeclareerde type levert:

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

Het probleem hiermee is dat het geen aanwijzingen (uiteraard) zal accepteren. De gemakkelijkste oplossing, denk ik, is te gebruiken std::vector. Het is een dynamische, resizable “array” (met de semantiek die u van een echte verwachten), met een sizeMember Functie:

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

U kunt natuurlijk ook een sjabloon maken om vectoren van andere typen te accepteren.


Antwoord 6, Autoriteit 5%

De meeste bibliotheken die vaak worden gebruikt in C++ kunnen arrays per se niet afdrukken. Je moet het handmatig doorlopen en elke waarde afdrukken.

Arrays afdrukken en vele verschillende soorten objecten dumpen is een kenmerk van talen op hogere niveau.


Antwoord 7, Autoriteit 5%

Dat is het zeker! U moet de array doorlopen en elk item afzonderlijk afdrukken.


Antwoord 8, autoriteit 3%

Dit kan helpen
//De array afdrukken

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

n is de grootte van de array


Antwoord 9, autoriteit 2%

Mijn simpele antwoord 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;
}

Antwoord 10

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

Antwoord 11

U kunt een array niet afdrukken door deze aan een functie door te geven. Omdat er geen dergelijke functie is in c++.
Doe het als volgt:

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

Other episodes