double **array;
...
*array = (double*)malloc(...);
...
array = (double*)malloc(...);
...
2d Массив произвольного размера
Как создать массив, в первой строке которого, допустим, 5 элементов, во второй - 6, в третьей - 4 и т.д.? Понятно, нужно завести что-типа
А затем как-то обращаться к элементам (если, конечно, все вышеперечисленное верно).
Вопрос: верно ли то, что я тут написал, и, самое главное, как правильно обращаться к энтим самым элементам? Т.е. какой индекс будет строкой, а какой - номером элемента в строке?
Код:
А затем как-то обращаться к элементам (если, конечно, все вышеперечисленное верно).
Вопрос: верно ли то, что я тут написал, и, самое главное, как правильно обращаться к энтим самым элементам? Т.е. какой индекс будет строкой, а какой - номером элемента в строке?
Трудно понять полет чужой мысли, но попробую подсказать.
Я делал, к примеру, так
Затем вводим значения дины строк и делаем так:
Ну а освобождаем память ессно:
Насчет доступа - то все рекомендуют делать динамический массив описанным выше способом (по крайней мере мне так рекомандовали). Доступ к элементам строк и столбцов осуществляется по принципу matrix[i*len+j] (элемент в строке или столбце, len - длина строки. Хотя в твоем случае (я брал пример квадратной матрицы) все будет гораздо труднее.
Я делал, к примеру, так
Код:
int *matrix, str1, str2, str3, tmp;
Затем вводим значения дины строк и делаем так:
Код:
tmp = str1+str2+str3;
matrix = new int[tmp];
matrix = new int[tmp];
Ну а освобождаем память ессно:
Код:
delete[] matrix;
Насчет доступа - то все рекомендуют делать динамический массив описанным выше способом (по крайней мере мне так рекомандовали). Доступ к элементам строк и столбцов осуществляется по принципу matrix[i*len+j] (элемент в строке или столбце, len - длина строки. Хотя в твоем случае (я брал пример квадратной матрицы) все будет гораздо труднее.
Если Вы пишете на C++, почитайте про STL. Это как раз то, что Вам нужно, к тому же — что-то вроде стандарта.
Если используете C (plain C), пишите
Если используете C (plain C), пишите
Код:
double** ppd;
ppd = (double**)malloc(2 * sizeof(double*));
ppd[0] = (double*)malloc(5 * sizeof(double));
// ... заполняем элементы ppd[0]
ppd[1] = (double*)malloc(6 * sizeof(double));
// ... заполняем элементы ppd[1]
double d = ppd[1][5]; // самый последний элемент
// ... и не забудьте потом много раз free()
ppd = (double**)malloc(2 * sizeof(double*));
ppd[0] = (double*)malloc(5 * sizeof(double));
// ... заполняем элементы ppd[0]
ppd[1] = (double*)malloc(6 * sizeof(double));
// ... заполняем элементы ppd[1]
double d = ppd[1][5]; // самый последний элемент
// ... и не забудьте потом много раз free()
Цитата:
Originally posted by sq_deep
Если Вы пишете на C++, почитайте про STL. Это как раз то, что Вам нужно, к тому же — что-то вроде стандарта.
Если Вы пишете на C++, почитайте про STL. Это как раз то, что Вам нужно, к тому же — что-то вроде стандарта.
Это и есть стандарт с 1999 года (если не ошибаюсь).
Цитата:
Если используете C (plain C), пишите
...
Если нужно немного сэкономить на выделении памяти, и массив не должен быть расширяемым, то можно выделить один большой блок памяти, и логически разбить его на куски.
Код:
double* array[size];
totalLen = len0 + len2 + ... + lenN;
array[0] = (double*)malloc(totalLen*sizeof(*array[0]));
array[1] = array[0] + len0;
array[2] = array[1] + len1;
...
free(array[0]);
totalLen = len0 + len2 + ... + lenN;
array[0] = (double*)malloc(totalLen*sizeof(*array[0]));
array[1] = array[0] + len0;
array[2] = array[1] + len1;
...
free(array[0]);
В отличие от варианта, приведенного sq_deep , изменить размеры такого массива очень проблематично.
Задача стоит следующая: решить уравнение теплопроводности, используя несколько процессоров. Соответственно юзать STL - медленно, логически разбивать массив - неэкономно (элементов может зашкалить за 10^10 - 10^12 на каждом процесоре). Перефразирую вопрос: как создать массив произвольной длины из указателей так, чтобы потом каждый указатель использовать как массив-строчку. Но на этот вопрос я уже, вроде как, получил ответ.
Цитата:
Originally posted by tarekon
Соответственно юзать STL - медленно
Соответственно юзать STL - медленно
это ошибочное мнение.
Цитата:
Originally posted by tarekon
Как создать массив, в первой строке которого, допустим, 5 элементов, во второй - 6, в третьей - 4 и т.д.? Понятно, нужно завести что-типа
Как создать массив, в первой строке которого, допустим, 5 элементов, во второй - 6, в третьей - 4 и т.д.? Понятно, нужно завести что-типа
Код:
double **array;
...
*array = (double*)malloc(...);
...
array = (double*)malloc(...);
...
...
*array = (double*)malloc(...);
...
array = (double*)malloc(...);
...
Можно попробовать вот такой код
int *Dim;//массив со значениями длины строк
Dim=new int[MaxColumn];
for(int i=0;i<MaxColumn;i++)
{
Dim=//тута мы массив инициализируем значениями длинны строк
}
double **array;
array=new double*[MaxColumn];
for(int i=0;i<MaxColumn;i++)
{
array=new double[Dim];
}
Цитата:
Originally posted by squirL
это ошибочное мнение.
это ошибочное мнение.
Вопрос: есть ли в STL контейнер, добавление элементов к которому требовало только выполнение выделения памяти, а обращение и изменение элементов происходило напрямую с памятью, а не посредством вызова функций (типа operator[])? Дело в том, что эффект не заметен на маленьких объемах данных. А когда массив измеряется в десятках, а то и сотнях мегабайт, и к нему постоянно идут обращения, то пара лишних ассемблерных инструкций могут сделать часовой расчет трехчасовым. Можно говорить, что компилятор все чудесно прооптимизирует, но мое мнение заключается в том, что лучший оптимизатор - собственные руки.
Цитата:
Originally posted by tarekon
Вопрос: есть ли в STL контейнер, добавление элементов к которому требовало только выполнение выделения памяти, а обращение и изменение элементов происходило напрямую с памятью, а не посредством вызова функций (типа operator[])? Дело в том, что эффект не заметен на маленьких объемах данных. А когда массив измеряется в десятках, а то и сотнях мегабайт, и к нему постоянно идут обращения, то пара лишних ассемблерных инструкций могут сделать часовой расчет трехчасовым. Можно говорить, что компилятор все чудесно прооптимизирует, но мое мнение заключается в том, что лучший оптимизатор - собственные руки.
Вопрос: есть ли в STL контейнер, добавление элементов к которому требовало только выполнение выделения памяти, а обращение и изменение элементов происходило напрямую с памятью, а не посредством вызова функций (типа operator[])? Дело в том, что эффект не заметен на маленьких объемах данных. А когда массив измеряется в десятках, а то и сотнях мегабайт, и к нему постоянно идут обращения, то пара лишних ассемблерных инструкций могут сделать часовой расчет трехчасовым. Можно говорить, что компилятор все чудесно прооптимизирует, но мое мнение заключается в том, что лучший оптимизатор - собственные руки.
Сугубо неверное мнение. Основное время как раз отжирает именно выделение/перераспределение памяти. А операторы тут вовсе ни при чем. Отсюда вывод - если тебе требуется обработка больших массивов информации - сначала надо продумать их структуру организации чтобы минимизировать как раз перераспределение памяти. И с этой точки зрения я бы посоветовал выделение линейного участка памяти необходимого размера - а уж потом работай с ним наздоровье хоть как с n-мерным массивом. Главное - соблюдать размерность.
Цитата:
Originally posted by ddnh_bc
Сугубо неверное мнение. Основное время как раз отжирает именно выделение/перераспределение памяти. А операторы тут вовсе ни при чем. Отсюда вывод - если тебе требуется обработка больших массивов информации - сначала надо продумать их структуру организации чтобы минимизировать как раз перераспределение памяти. И с этой точки зрения я бы посоветовал выделение линейного участка памяти необходимого размера - а уж потом работай с ним наздоровье хоть как с n-мерным массивом. Главное - соблюдать размерность.
Сугубо неверное мнение. Основное время как раз отжирает именно выделение/перераспределение памяти. А операторы тут вовсе ни при чем. Отсюда вывод - если тебе требуется обработка больших массивов информации - сначала надо продумать их структуру организации чтобы минимизировать как раз перераспределение памяти. И с этой точки зрения я бы посоветовал выделение линейного участка памяти необходимого размера - а уж потом работай с ним наздоровье хоть как с n-мерным массивом. Главное - соблюдать размерность.
В принципе при обычных операциях правильно, однако при обработке векторных данных действительно замедляет работу. Нет возможности использования векторных инструкций процессора и т.д. Но в общем в таких случаях перед началом операции можно брать адрес первого элемента массива
value_type *_Ptr = &array.front();
Естественно в промежутке не должно быть никаких изменений размера array.
Кроме того, если размер массива фиксирован в определенные моменты структура полностью меняется, а данные не нужны - лучше хранить данные в одномерном массиве и запоминать в другом массиве длину строк. Так данные будут размещаться в памяти линейно. Опять же если пишешь исключительно на языке высокого уровня - основной прирост производительности происходит при кардинальном изменении алгоритма обработки данных, а не от способа выделения памяти (кроме неправильного).