Я хочу добавить int в массив, но проблема в том, что я не знаю, что такое индекс.
int[] arr = new int[15];
arr[0] = 1;
arr[1] = 2;
arr[2] = 3;
arr[3] = 4;
arr[4] = 5;
Этот код работает, потому что я знаю, какой индекс я назначаю, но что, если я не знаю индекс...
В PHP я могу просто сделать arr[]=22;, который автоматически добавит 22 к следующему пустому индексу массива. Но в С++ я не могу этого сделать, это дает мне ошибку компилятора. Что вы предлагаете?
Невозможно делать то, что вы говорите на С++, с помощью простых массивов. Решение С++ для этого - с помощью библиотеки STL, которая дает вам std::vector.
Вы можете использовать vector следующим образом:
std::vector< int > arr;
arr.push_back(1);
arr.push_back(2);
arr.push_back(3);
Массивы в С++ не могут изменять размер во время выполнения. Для этого вам следует использовать vector<int>.
vector<int> arr;
arr.push_back(1);
arr.push_back(2);
// arr.size() will be the number of elements in the vector at the moment.
Как указано в комментариях, vector определяется в заголовке vector и пространстве имен std. Чтобы использовать его, вы должны:
#include <vector>
а также используйте std::vector в своем коде или добавьте
using std::vector;
или
using namespace std;
после строки #include <vector>.
Используйте вектор:
#include <vector>
void foo() {
std::vector <int> v;
v.push_back( 1 ); // equivalent to v[0] = 1
}
int arr[] = new int[15];
Переменная arr содержит адрес памяти. По адресу памяти в строке имеется 15 последовательных строк. На них можно ссылаться с индексом от 0 до 14 включительно.
В php я могу просто сделать это arr [] = 22; это автоматически добавит 22 к следующий пустой индекс массива.
Нет понятия "следующий" при работе с массивами.
Одна важная вещь, которая, как мне кажется, отсутствует, заключается в том, что как только массив создается, все элементы массива уже существуют. Они неинициализированы, но все они уже существуют. Таким образом, вы не "заполняете" элементы массива, когда идете, они уже заполнены, просто с неинициализированными значениями. Невозможно проверить неинициализированный элемент в массиве.
Похоже, вы хотите использовать структуру данных, такую как queue или stack или vector.
Вам не нужно использовать векторы. Если вы хотите придерживаться простых массивов, вы можете сделать что-то вроде этого:
int arr[] = new int[15];
unsigned int arr_length = 0;
Теперь, если вы хотите добавить элемент в конец массива, вы можете сделать это:
if (arr_length < 15) {
arr[arr_length++] = <number>;
} else {
// Handle a full array.
}
Он не такой короткий и изящный, как эквивалент PHP, но он выполняет то, что вы пытались сделать. Чтобы вы могли легко изменить размер массива в будущем, вы можете использовать #define.
#define ARRAY_MAX 15
int arr[] = new int[ARRAY_MAX];
unsigned int arr_length = 0;
if (arr_length < ARRAY_MAX) {
arr[arr_length++] = <number>;
} else {
// Handle a full array.
}
Это упрощает управление массивом в будущем. Изменяя 15 до 100, размер массива будет правильно изменен во всей программе. Обратите внимание, что вам нужно будет установить массив на максимальный ожидаемый размер, так как вы не сможете изменить его после компиляции программы. Например, если у вас есть массив размером 100, вы никогда не сможете вставить 101 элемент.
Если вы будете использовать элементы с конца массива, вы можете сделать это:
if (arr_length > 0) {
int value = arr[arr_length--];
} else {
// Handle empty array.
}
Если вы хотите удалить элементы с начала (например, FIFO), решение становится более сложным. Вам также нужен индекс начала и конца.
#define ARRAY_MAX 15
int arr[] = new int[ARRAY_MAX];
unsigned int arr_length = 0;
unsigned int arr_start = 0;
unsigned int arr_end = 0;
// Insert number at end.
if (arr_length < ARRAY_MAX) {
arr[arr_end] = <number>;
arr_end = (arr_end + 1) % ARRAY_MAX;
arr_length ++;
} else {
// Handle a full array.
}
// Read number from beginning.
if (arr_length > 0) {
int value = arr[arr_start];
arr_start = (arr_start + 1) % ARRAY_MAX;
arr_length --;
} else {
// Handle an empty array.
}
// Read number from end.
if (arr_length > 0) {
int value = arr[arr_end];
arr_end = (arr_end + ARRAY_MAX - 1) % ARRAY_MAX;
arr_length --;
} else {
// Handle an empty array.
}
Здесь мы используем оператор модуля (%), чтобы заставить индексы обернуться. Например, (99 + 1)% 100 равно 0 (приращение обертывания). И (99 + 99)% 100 равно 98 (декремент обертывания). Это позволяет вам избегать операторов и сделать код более эффективным.
Вы также можете быстро увидеть, насколько полезно #define, так как ваш код становится более сложным. К сожалению, даже с этим решением вы никогда не сможете вставить в массив более 100 элементов (или любого другого максимального значения). Вы также используете 100 байт памяти, даже если в массиве сохранено только 1 элемент.
Это основная причина, по которой другие рекомендовали векторы. Вектор управляется за кулисами, а новая память выделяется по мере расширения структуры. Он по-прежнему не так эффективен, как массив в ситуациях, когда размер данных уже известен, но для большинства целей различия производительности не будут иметь большого значения. Для каждого подхода есть компромиссы, и лучше всего знать оба.
Я полностью согласен с методом vector при реализации динамического массива. Однако имейте в виду, что STL предоставляет вам множество контейнеров, которые удовлетворяют различным требованиям времени выполнения. Вы должны выбрать один с осторожностью. Например: для быстрой установки на спине у вас есть выбор между vector и a deque.
И я почти забыл, с большой силой приходит большая ответственность:-) Так как vector являются гибкими по размеру, они часто перераспределяются автоматически, чтобы корректировать добавление элементов. Так что будьте осторожны с недействительностью итератора (да, это также относится к указателям). Однако, пока вы используете operator[] для доступа к отдельным элементам, вы в безопасности.
Возможно, я пропустил здесь свой вопрос, и если так, то я приношу свои извинения. Но если вы не собираетесь удалять какие-либо элементы, добавляя их, почему бы просто не назначить переменную для следующего пустого слота? Каждый раз, когда вы добавляете новое значение в массив, просто увеличивайте значение до следующего.
В С++ лучшим решением является использование стандартного типа библиотеки std::list< type >, который также позволяет динамическому росту массива, например:
#include <list>
std::list<int> arr;
for (int i = 0; i < 10; i++)
{
// add new value from 0 to 9 to next slot
arr.push_back(i);
}
// add arbitrary value to the next free slot
arr.push_back(22);
Сначала инициализируйте все элементы массива нулями, затем найдите нуль, чтобы найти пустой слот
Если вы пишете на С++ - лучше использовать структуры данных из стандартной библиотеки, например, для вектора.
Маски C-стиля очень подвержены ошибкам, и их следует избегать, когда это возможно.
Вы можете использовать переменную для подсчета мест в массиве, поэтому, когда вы добавляете новый элемент, вы помещаете его в нужное место. Например:
int a = 0;
int arr[5] = { };
arr[a] = 6;
a++;
Ну, если вы не инициализируете длину массива, вы можете добавить элемент в массив.
int arr[] = {1,2,3,4,5};
int last_index = sizeof(arr)/sizeof(arr[0]);
arr[last_index] = 6;
Новый массив будет содержать значение от 1 до 6