Как создать массив не зная его размер с

Как сделать массив если не знаешь его размера с++?

Стоит задача посчитать все значения функции игрек при иксах от n до n2, чтобы потом собрать это все в массив и узнать какой из элементов максимальный. Так вот, вопрос:
1. Как создать массив если не знаешь его длины?
2. Как высчитать из этого максимальный элемент?
первый вопрос меня волнует больше, в гугле искал, не нашел ответов там

• Вопрос задан более трёх лет назад
• 482 просмотра

Комментировать

Решения вопроса 2

Вектор в C++
— это замена стандартному динамическому массиву, память для которого выделяется вручную, с помощью оператора new.
Разработчики языка рекомендуют в использовать именно vector вместо ручного выделения памяти для массива. Это позволяет избежать утечек памяти и облегчает работу программисту.

Ответ написан более трёх лет назад

Комментировать

Нравится 2 Комментировать

Как создать массив в java без длины

Привет. А как получить все элементы этого массива? System.out.println(Arrays.toString(dynamicArray)); Такой вывод не работает.

08 апреля 2023

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

Однако, если вы не знаете заранее размер массива, можно создать массив с нулевой длиной и затем добавлять элементы в него по мере необходимости, используя методы класса ArrayList

Пример создания динамического массива с помощью ArrayList :

import java.util.ArrayList; public class Example  public static void main(String[] args)  ArrayListInteger> dynamicArray = new ArrayListInteger>(); // Добавляем элементы в массив dynamicArray.add(10); dynamicArray.add(20); dynamicArray.add(30); // Получаем элементы массива System.out.println(dynamicArray.get(0)); // => 10 System.out.println(dynamicArray.get(1)); // => 20 System.out.println(dynamicArray.get(2)); // => 30 > > 

Как создать массив не зная его размер с

Кроме отдельных динамических объектов в языке C++ мы можем использовать динамические массивы. Для выделения памяти под динамический массив также используется оператор new , после которого в квадратных скобках указывается, сколько массив будет содержать объектов:

int *numbers ; // динамический массив из 4 чисел // или так // int *numbers = new int[4];

Причем в этом случае оператор new также возвращает указатель на объект типа int — первый элемент в созданном массиве.

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

int *numbers1 >; // массив состоит из чисел 0, 0, 0, 0 int *numbers2 >; // массив состоит из чисел 1, 2, 3, 4 int *numbers3 >; // массив состоит из чисел 1, 2, 0, 0 // аналогичные определения массивов // int *numbers1 = new int[4]<>; // массив состоит из чисел 0, 0, 0, 0 // int *numbers1 = new int[4](); // массив состоит из чисел 0, 0, 0, 0 // int *numbers2 = new int[4]< 1, 2, 3, 4 >; // массив состоит из чисел 1, 2, 3, 4 // int *numbers3 = new int[4]< 1, 2 >; // массив состоит из чисел 1, 2, 0, 0

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

Стоит отметить, что в стандарт С++20 добавлена возможность выведения размера массива, поэтому, если применяется стандарт С++20, то можно не указывать длину массива:

int *numbers >; // массив состоит из чисел 1, 2, 3, 4

После создания динамического массива мы сможем с ним работать по полученному указателю, получать и изменять его элементы:

int *numbers >; // получение элементов через синтаксис массивов std::cout 
Причем для доступа к элементам динамического массива можно использовать как синтаксис массивов ( numbers[0] ), так и операцию разыменования ( *numbers )
Соответственно для перебора такого массива можно использовать различные способы:
unsigned n< 5 >; // размер массива int* p < new int[n] < 1, 2, 3, 4, 5 >>; // используем индексы for (unsigned i<>; i < n; i++) < std::cout std::cout ; i < n; i++) < std::cout std::cout ; q != p + n; q++) < std::cout std::cout 
Обратите внимание, что для задания размера динамического массива мы можем применять обычную переменную, а не константу, как в случае со стандартными массивами.
Для удаления динамического массива и освобождения его памяти применяется специальная форма оператора delete :
delete [] указатель_на_динамический_массив;
#include int main() < unsigned n< 5 >; // размер массива int* p < new int[n] < 1, 2, 3, 4, 5 >>; // используем индексы for (unsigned i<>; i < n; i++) < std::cout std::cout


Чтобы после освобождения памяти указатель не хранил старый адрес, также рекомендуется обнулить его:
delete [] p; p = nullptr; // обнуляем указатель
Многомерные массивы
Также мы можем создавать многомерные динамические массивы. Рассмотрим на примере двухмерных массивов. Что такое по сути двухмерный массив? Это набор массив массивов. Соответственно, чтобы создать динамический двухмерный массив, нам надо создать общий динамический массив указателей, а затем его элементы - вложенные динамические массивы. В общем случае это выглядит так:
#include int main() < unsigned rows = 3; // количество строк unsigned columns = 2; // количество столбцов int** numbers>; // выделяем память под двухмерный массив // выделяем память для вложенных массивов for (unsigned i<>; i < rows; i++) < numbers[i] = new int[columns]<>; > // удаление массивов for (unsigned i<>; i < rows; i++) < delete[] numbers[i]; >delete[] numbers; >
Вначале выделяем память для массива указателей (условно таблицы):
int** numbers>;
Затем в цикле выделяем память для каждого отдельного массива (условно строки таблицы):
numbers[i] = new int[columns]<>;
Освобождение памяти идет в обратном порядке - сначала освобождаем память для каждого отдельного вложенного массива, а затем для всего массива указателей.
Пример с вводом и выводом данных двухмерного динамического массива:
#include int main() < unsigned rows = 3; // количество строк unsigned columns = 2; // количество столбцов int** numbers>; // выделяем память под двухмерный массив for (unsigned i<>; i < rows; i++) < numbers[i] = new int[columns]<>; > // вводим данные для таблицы rows x columns for (unsigned i<>; i < rows; i++) < std::cout ; j < columns; j++) < std::cout > numbers[i][j]; > > // вывод данных for (unsigned i<>; i < rows; i++) < // выводим данные столбцов i-й строки for (unsigned j<>; j < columns; j++) < std::cout std::cout for (unsigned i<>; i < rows; i++) < delete[] numbers[i]; >delete[] numbers; >
Пример работы программы:
Enter data for 1 row 1 column: 2 2 column: 3 Enter data for 2 row 1 column: 4 2 column: 5 Enter data for 3 row 1 column: 6 2 column: 7 2 3 4 5 6 7
Указатель на массив
От типа int** , который представляет указатель на указатель (pointer-to-pointer) следует отличать ситуацию "указатель на массив" (pointer to array). Например:
#include int main() < unsigned n; // количество строк int (*a)[2] = new int[n][2]; int k<>; // устанавливаем значения for (unsigned i<>; i < n; i++) < // устанавливаем данные для столбцов i-й строки for (unsigned j<>; j < 2; j++) < a[i][j] = ++k; >> // вывод данных for (unsigned i<>; i < n; i++) < // выводим данные столбцов i-й строки for (unsigned j<>; j < 2; j++) < std::cout std::cout // удаляем данные delete[] a; a = nullptr; >
Здесь запись int (*a)[2] представляет указатель на массив из двух элементов типа int. Фактически мы можем работать с этим объектом как с двухмерным массивом (таблицей), только количество столбцов в данном случае фиксировано - 2. И память для такого массива выделяется один раз:
int (*a)[2] = new int[n][2];
То есть в данном случае мы имеем дело с таблице из n строк и 2 столцов. Используя два индекса (для строки и столца), можно обращаться к определенному элементу, установить или получить его значение. Консольный вывод данной программы:
1 2 3 4 5 6
Массивы (C++)
Массив представляет собой последовательность объектов того же типа, которые занимают непрерывную область памяти. Традиционные массивы стилей C являются источником многих ошибок, но по-прежнему распространены, особенно в старых базах кода. В современном C++настоятельно рекомендуется использовать std::vector или std::array вместо массивов стилей C, описанных в этом разделе. Оба этих стандартных типов библиотек хранят их элементы в виде непрерывного блока памяти. Однако они обеспечивают большую безопасность типов и поддерживают итераторы, которые гарантированно указывают на допустимое расположение в последовательности. Дополнительные сведения см. в разделе "Контейнеры".
Объявления стека
В объявлении массива C++ размер массива указывается после имени переменной, а не после имени типа, как в других языках. В следующем примере объявляется массив из 1000 двойных размеров, выделенных в стеке. Число элементов должно быть предоставлено в виде целочисленного литерала или в качестве константного выражения. Это связано с тем, что компилятор должен знать, сколько пространства стека следует выделить; он не может использовать значение, вычисляемое во время выполнения. Каждому элементу в массиве присваивается значение по умолчанию 0. Если вы не назначаете значение по умолчанию, каждый элемент изначально содержит все случайные значения в этом расположении памяти.
 constexpr size_t size = 1000; // Declare an array of doubles to be allocated on the stack double numbers[size] ; // Assign a new value to the first element numbers[0] = 1; // Assign a value to each subsequent element // (numbers[1] is the second element in the array.) for (size_t i = 1; i < size; i++) < numbers[i] = numbers[i-1] * 1.1; >// Access each element for (size_t i = 0; i
Первый элемент в массиве — это нулевой элемент. Последний элемент — это элемент (n-1), где n — это количество элементов, которые может содержать массив. Число элементов в объявлении должно иметь целочисленный тип и должно быть больше 0. Вы несете ответственность за то, чтобы программа никогда не передает значение оператору подстрока, который больше (size - 1) .
Массив нулевого размера является законным только в том случае, если массив является последним полем в списке struct или union когда расширения Майкрософт включены ( /Za или /permissive- не заданы).
Массивы на основе стека быстрее выделяют и получают доступ, чем массивы на основе кучи. Однако пространство стека ограничено. Количество элементов массива не может быть таким большим, что использует слишком много памяти стека. Сколько слишком много зависит от вашей программы. Средства профилирования можно использовать для определения того, слишком ли большой массив.
Объявления кучи
Может потребоваться слишком большой массив для выделения в стеке или размер которого не известен во время компиляции. Этот массив можно выделить в куче с помощью new[] выражения. Оператор возвращает указатель на первый элемент. Оператор подстрока работает с переменной указателя так же, как и в массиве на основе стека. Вы также можете использовать арифметику указателя для перемещения указателя на любые произвольные элементы в массиве. Это ваша ответственность за обеспечение того, чтобы:

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

В следующем примере показано, как определить массив в куче во время выполнения. В нем показано, как получить доступ к элементам массива с помощью оператора подстрочного и с помощью арифметики указателя:
void do_something(size_t size) < // Declare an array of doubles to be allocated on the heap double* numbers = new double[size]< 0 >; // Assign a new value to the first element numbers[0] = 1; // Assign a value to each subsequent element // (numbers[1] is the second element in the array.) for (size_t i = 1; i < size; i++) < numbers[i] = numbers[i - 1] * 1.1; >// Access each element with subscript operator for (size_t i = 0; i < size; i++) < std::cout // Access each element with pointer arithmetic // Use a copy of the pointer for iterating double* p = numbers; for (size_t i = 0; i < size; i++) < // Dereference the pointer, then increment it std::cout // Alternate method: // Reset p to numbers[0]: p = numbers; // Use address of pointer to compute bounds. // The compiler computes size as the number // of elements * (bytes per element). while (p < (numbers + size)) < // Dereference the pointer, then increment it std::cout delete[] numbers; // don't forget to do this! > int main()
Инициализация массивов
Вы можете инициализировать массив в цикле, один элемент за раз или в одной инструкции. Содержимое следующих двух массивов идентичны:
 int a[10]; for (int i = 0; i < 10; ++i) < a[i] = i + 1; >int b[10]< 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 >; 
Передача массивов в функции
Когда массив передается функции, он передается в качестве указателя на первый элемент, будь то массив на основе стека или кучи. Указатель не содержит других сведений о размере или типе. Это поведение называется разложением указателя. При передаче массива функции всегда необходимо указать количество элементов в отдельном параметре. Это также означает, что элементы массива не копируются при передаче массива функции. Чтобы предотвратить изменение элементов функции, укажите параметр в качестве указателя на const элементы.
В следующем примере показана функция, которая принимает массив и длину. Указатель указывает на исходный массив, а не копию. Так как параметр не const является, функция может изменять элементы массива.
void process(double *p, const size_t len) < std::cout > 
Объявите и определите параметр p массива, const чтобы сделать его доступным только для чтения в блоке функций:
void process(const double *p, const size_t len); 
Эта же функция также может быть объявлена таким образом без изменений в поведении. Массив по-прежнему передается в качестве указателя на первый элемент:
// Unsized array void process(const double p[], const size_t len); // Fixed-size array. Length must still be specified explicitly. void process(const double p[1000], const size_t len); 
Многомерные массивы
Массивы, созданные из других массивов, являются многомерными. Такие многомерные массивы определяются путем последовательного размещения нескольких константных выражений, заключенных в квадратные скобки. Рассмотрим, например, следующее объявление:
int i2[5][7]; 
Он задает массив типа int , концептуально упорядоченный в двухмерной матрице из пяти строк и семи столбцов, как показано на следующем рисунке:
Изображение представляет собой сетку 7 ячеек, широких и 5 ячеек. Каждая ячейка содержит индекс ячейки. Первый индекс ячейки помечен как 0,0. Следующая ячейка в этой строке составляет 0,1 и т. д. до последней ячейки в этой строке, которая составляет 0,6. Следующая строка начинается с индекса 1,0. После этого ячейка имеет индекс 1,1. Последняя ячейка в этой строке — 1,6. Этот шаблон повторяется до последней строки, которая начинается с индекса 4,0. Последняя ячейка в последней строке имеет индекс 4,6. . image-end
Можно объявить многомерные массивы с списком инициализаторов (как описано в инициализаторах). В этих объявлениях константное выражение, указывающее границы для первого измерения, может быть опущено. Например:
// arrays2.cpp // compile with: /c const int cMarkets = 4; // Declare a float that represents the transportation costs. double TransportCosts[][cMarkets] = < < 32.19, 47.29, 31.99, 19.11 >, < 11.29, 22.49, 33.47, 17.29 >, < 41.97, 22.09, 9.76, 22.55 >>; 
В показанном выше объявлении определяется массив, состоящий из трех строк и четырех столбцов. Строки представляют фабрики, а столбцы — рынки, на которые фабрики поставляют свою продукцию. Значения — это стоимости транспортировки с фабрик на рынки. Первое измерение массива опущено, но компилятор заполняет его, проверяя инициализатор.
Использование оператора непрямого выражения (*) в типе массива n-1 приводит к получению массива n-1. Если значение n равно 1, возвращается скалярный элемент (или элемент массива).
Массивы C++ размещаются в памяти по срокам. Построчный порядок означает, что быстрее всего изменяется последний индекс.
Пример
Вы также можете опустить спецификацию границ для первого измерения многомерного массива в объявлениях функций, как показано ниже:
// multidimensional_arrays.cpp // compile with: /EHsc // arguments: 3 #include // Includes DBL_MAX #include const int cMkts = 4, cFacts = 2; // Declare a float that represents the transportation costs double TransportCosts[][cMkts] = < < 32.19, 47.29, 31.99, 19.11 >, < 11.29, 22.49, 33.47, 17.29 >, < 41.97, 22.09, 9.76, 22.55 >>; // Calculate size of unspecified dimension const int cFactories = sizeof TransportCosts / sizeof( double[cMkts] ); double FindMinToMkt( int Mkt, double myTransportCosts[][cMkts], int mycFacts); using namespace std; int main( int argc, char *argv[] ) < double MinCost; if (argv[1] == 0) < cout MinCost = FindMinToMkt( *argv[1] - '0', TransportCosts, cFacts); cout double FindMinToMkt(int Mkt, double myTransportCosts[][cMkts], int mycFacts)
The minimum cost to Market 3 is: 17.29 
Функция FindMinToMkt записывается таким образом, что добавление новых фабрик не требует изменений кода, просто перекомпиляции.
Инициализация массивов
Массивы объектов с конструктором классов инициализированы конструктором. Если в списке инициализатора меньше элементов в массиве, конструктор по умолчанию используется для остальных элементов. Если конструктор по умолчанию не определен для класса, список инициализаторов должен быть завершен, то есть должен быть один инициализатор для каждого элемента в массиве.
Рассмотрим класс Point , определяющий два конструктора:
// initializing_arrays1.cpp class Point < public: Point() // Default constructor. < >Point( int, int ) // Construct from two ints < >>; // An array of Point objects can be declared as follows: Point aPoint[3] = < Point( 3, 3 ) // Use int, int constructor. >; int main()
Первый элемент aPoint создается с помощью конструктора Point( int, int ) , а оставшиеся два элемента — с помощью конструктора по умолчанию.
Массивы статических элементов (независимо от того, можно ли const ) инициализировать в их определениях (за пределами объявления класса). Например:
// initializing_arrays2.cpp class WindowColors < public: static const char *rgszWindowPartList[7]; >; const char *WindowColors::rgszWindowPartList[7] = < "Active Title Bar", "Inactive Title Bar", "Title Bar Text", "Menu Bar", "Menu Bar Text", "Window Background", "Frame" >; int main()
Доступ к элементам массива
К отдельным элементам массива можно обращаться при помощи оператора индекса массива ( [ ] ). Если вы используете имя одномерного массива без подстрока, он оценивается как указатель на первый элемент массива.
// using_arrays.cpp int main() < char chArray[10]; char *pch = chArray; // Evaluates to a pointer to the first element. char ch = chArray[0]; // Evaluates to the value of the first element. ch = chArray[3]; // Evaluates to the value of the fourth element. >
Если используются многомерные массивы, в выражениях можно использовать различные сочетания.
// using_arrays_2.cpp // compile with: /EHsc /W1 #include using namespace std; int main() < double multi[4][4][3]; // Declare the array. double (*p2multi)[3]; double (*p1multi); cout 
В приведенном выше коде multi представляет собой трехмерный массив типа double . Указатель p2multi указывает на массив типа double размера три. В этом примере массив используется с одним, двумя и тремя индексами. Хотя в инструкции чаще всего указываются все подстроки, как и в cout инструкции, иногда полезно выбрать определенное подмножество элементов массива, как показано в приведенных ниже cout инструкциях.
Оператор перегрузки подстрока
Как и другие операторы, оператор подстрочного ( [] ) может быть переопределен пользователем. Поведение оператора индекса по умолчанию, если он не перегружен, — совмещать имя массива и индекс с помощью следующего метода.
Как и во всех дополнениях, включающих типы указателей, масштабирование выполняется автоматически, чтобы настроить размер типа. Результирующий значение не является n байтами из источника array_name ; вместо этого это n-йэлемент массива. Дополнительные сведения об этом преобразовании см. в разделе "Адитивные операторы".
Аналогично, для многомерных массивов адрес извлекается с использованием следующего метода.
((array_name) + (subscript1 * max2 * max3 * . * maxn) + (subscript2 * max3 * . * maxn) + . + subscriptn))
Массивы в выражениях
Если идентификатор типа массива отображается в выражении, отличном от sizeof адреса ( & ) или инициализации ссылки, он преобразуется в указатель на первый элемент массива. Например:
char szError1[] = "Error: Disk drive not ready."; char *psz = szError1; 
Указатель psz указывает на первый элемент массива szError1 . Массивы, в отличие от указателей, не изменяются l-значения. Вот почему следующее назначение является незаконным:
szError1 = psz; 


Похожие публикации:

Dc in разъем для чего на мониторе
Как очистить буфер клавиатуры в c
Как преобразовать список в множество python
Проблема и трудность в чем разница