Печать массива в C++?
Есть ли способ печати массивов в C++?
Я пытаюсь сделать функцию, которая переворачивает массив пользовательского ввода и затем распечатывает его. Я попытался найти эту проблему в Google, и казалось, что C++ не может печатать массивы. Это не может быть правдой, не так ли?
18 ответов
Ты не можешь просто перебрать элементы? как это:
for (int i = numElements - 1; i >= 0; i--)
cout << array[i];
Примечание: как отметил Максим Егорушкин, это может переполниться. Смотрите его комментарий ниже для лучшего решения.
Используйте 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";
}
Могу ли я предложить использовать оператор рыбьей кости?
for (auto x = std::end(a); x != std::begin(a); )
{
std::cout <<*--x<< ' ';
}
(Вы можете это заметить?)
Помимо решений на основе цикла, вы также можете использовать 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
Однако это может быть излишним для ваших нужд. Скорее всего, все, что вам нужно, это просто цикл, хотя шаблонный пакет litb тоже неплох.
Изменить: Забыл требование "печать в обратном порядке". Вот один из способов сделать это:
#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
Редактирование: обновление C++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"));
}
Есть объявленные массивы и массивы, которые не объявлены, но созданы иным образом, особенно с использованием 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;
}
Конечно, вы также можете сделать этот шаблон для принятия векторов других типов.
Большинство библиотек, обычно используемых в C++, не могут печатать массивы как таковые. Вы должны будете пройти через это вручную и распечатать каждое значение.
Печать массивов и сброс множества различных типов объектов - это особенность языков более высокого уровня.
Это определенно! Вам придется перебрать массив и распечатать каждый элемент по отдельности.
C++ может печатать все что угодно, если вы запрограммируете это делать это. Вам придется самостоятельно просматривать массив, печатая каждый элемент.
Это может помочь // Печать массива
for (int i = 0; i < n; i++)
{cout << numbers[i];}
n - размер массива
Мой простой ответ:
#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;
}
std::string ss[] = { "qwerty", "asdfg", "zxcvb" };
for ( auto el : ss ) std::cout << el << '\n';
Работает в основном как foreach.
Довольно просто скопировать элементы массива в подходящий выходной итератор. Например (используя С++20 для версии Ranges):
#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;
}
Быстрая демонстрация:
int main()
{
std::array example{ "zero", "one", "two", "three", };
print_array(std::cout, example) << '\n';
}
Конечно, будет полезнее, если мы сможем вывести любую коллекцию, а не только массивы:
#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;
}
В вопросе упоминается обращение массива для печати. Это легко достигается с помощью адаптера вида :
print_array(std::cout, example | std::views::reverse) << '\n';
Вы можете использовать обратные итераторы для печати массива в обратном порядке:
#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;
}
54321
Если вы уже перевернули массив, вы можете заменитьstd::rbeginиstd::rendсstd::begin/std::end, соответственно, для итерации массива в прямом направлении.
Вы не можете распечатать массив, просто передав его функции. Потому что в C ++ такой функции нет. Сделай это так:
for (auto x = std::end(a); x != std::begin(a); ) { std::cout <<*--x<< ' '; }
// 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;
}
}
Или вы можете использовать это: https://github.com/gileli121/VectorEx
Вы можете легко отобразить массив с помощью DisplayVector_1d(). Разработано под visual studio 2015. Работает только под windows (проверено на windows 7 64 bit).
В этой библиотеке вы просматриваете DisplayVector_1d. я
Он отобразит массив в графическом интерфейсе списка. это похоже на функцию _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;
}
Обратите внимание, что я только начал работать над этим проектом. Вы можете улучшить код и исправить ошибки
Для двумерного массива:
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;
}
Если вы хотите создать функцию, которая печатает каждый элемент массива;
#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));
}
Приведенная выше функция печатает только каждый элемент массива , а не запятые и т. д.
Вы можете задаться вопросом: «Почему sizeoff(arr) делится на 4?». Это потому, что cpp печатает 4, если в массиве есть только один элемент.