Здра
Можно ли в С++ динамически создать мног. массив?

double d[][];
d = new double[10][5];

или единств что возможно это

double* d;
d = new double[10*5];

и потом мучаться конвертировать индексы?
Спасибо

Здравствуйте Аноним, вы писали:

А>Здра
А>Можно ли в С++ динамически создать мног. массив?

А>double d[][];
А>d = new double[10][5];

А>или единств что возможно это

А>double* d;
А>d = new double[10*5];

А>и потом мучаться конвертировать индексы?
А>Спасибо

Попробуй так: //d[10][5];
double** d;

d=(double **)calloc(10,sizeof(double *));
for (int i=0; i<10; i++)
d[i]=(double *)calloc(5,sizeof(double));

for(i=0;i<10;i++)
for(int j=0;j<5;j++)
d[i][j]=j;

for(i=0;i<10;i++)
for(int j=0;j<5;j++)
{
CString str;
str.Format("d[%d][%d]=%.2f",i,j,d[i][j]);
AfxMessageBox(str);
}

тока удалять не забывай... в обратном порядке- сначала d[i], потом d
Пока!

Здравствуйте Аноним, вы писали:

А>Здравствуйте Аноним, вы писали:

Ну вы даете! На С++ же пишем!!!!

Трудно класс подходящий набростаь?


Тут я думаю дело в другом. При исспользовании многомерных массивов в реальных приложениях, часто необходм пересчет некого его элемента по СОСЕДНИМ по каждому измерению.

При этом в случае эмуляции такого массива линейным обращение будет происходить в РАЗНЫЕ сильно расзнесенные физически участки памяти. В этом то и кривизна. Ибо большие массивы, на своп заползающие сильно будут тормозить.


Так я к чему — можно ли чтонибудь придумать — такой класс многомерного массива, чтобы при обращении к соседним по каждому индексу элементам, реально происходило обращение к более менее соседним ячейкам памяти?.

Саша.

Здравствуйте Аноним, вы писали:

А>Попробуй так: //d[10][5];
А>double** d;

А>d=(double **)calloc(10,sizeof(double *));
А>for (int i=0; i<10; i++)
А>d[i]=(double *)calloc(5,sizeof(double));

А>for(i=0;i<10;i++)
А>for(int j=0;j<5;j++)
А>d[i][j]=j;

А>for(i=0;i<10;i++)
А>for(int j=0;j<5;j++)
А>{
А>CString str;
А>str.Format("d[%d][%d]=%.2f",i,j,d[i][j]);
А>AfxMessageBox(str);
А>}

А>тока удалять не забывай... в обратном порядке- сначала d[i], потом d
А>Пока!

Спасибо за ответ! Насчет сообщения Саши — врядли можно разместить многомерный массив так чтобы соседние элем находились по соседству т.к. распологая их рядом например по вертикали они будут находиться вразброс по горизонтали.

Здравствуйте Аноним, вы писали:

А>Здра
А>Можно ли в С++ динамически создать мног. массив?

А>double d[][];
А>d = new double[10][5];

А>или единств что возможно это

А>double* d;
А>d = new double[10*5];

А>и потом мучаться конвертировать индексы?
А>Спасибо

А может быть лучше потратить некоторое время на изучение стандартной библиотеки? Там есть такое понятие как std::valarray<T>, std::slice_array<T>. Как использовать — прекрасно описано у Страуструпа 22.4.5 — 22.4.6.

Здравствуйте Anton V. Kolotaev, вы писали:

AVK>А может быть лучше потратить некоторое время на изучение стандартной библиотеки? Там есть такое >понятие как std::valarray<T>, std::slice_array<T>. Как использовать — прекрасно описано у >Страуструпа 22.4.5 — 22.4.6.

Не подскажите где можно скачать эту книгу?

Здравствуйте Аноним, вы писали:

А>Можно ли в С++ динамически создать мног. массив?

А>double d[][];
А>d = new double[10][5];

А>или единств что возможно это

А>double* d;
А>d = new double[10*5];

Ну вот так вот можно:

double (*d)[5];
d = new double[10][5];
d[2][3];

Это будет работать только при условии, что индексы 2-го и дальше уровне фиксированные. Переменным может быть только первый.

Здравствуйте Sasparella, вы писали:

S>Так я к чему — можно ли чтонибудь придумать — такой класс многомерного массива, чтобы при обращении к соседним по каждому индексу элементам, реально происходило обращение к более менее соседним ячейкам памяти?.

Нельзя. В общем случае нельзя спроецировать двумерный массив на одномерный с соблюдением такого условия. Могу привести формальное доказательство.

Best regards,
Андрей Тарасевич,
Brainbench C and C++ Programming MVP

Здравствуйте Аноним, вы писали:
А>Не подскажите где можно скачать эту книгу?

За много лет шатания по инету 3изд. не встречалось ни разу.
2изд. есть у Мошкова (lib.ru).

Однако намного полезнее все-таки иметь при себе печатный вариант.

ZORK>Ну вот так вот можно:

ZORK> double (*d)[5];
ZORK> d = new double[10][5];
ZORK> d[2][3];

ZORK>Это будет работать только при условии, что индексы 2-го и дальше уровне фиксированные. Переменным может быть только первый.

Спасибо, а почему *d в скобках? Извини за вопрос, я только учусь

Здравствуйте Аноним, вы писали:

ZORK>>Ну вот так вот можно:

ZORK>> double (*d)[5];
ZORK>> d = new double[10][5];
ZORK>> d[2][3];

ZORK>>Это будет работать только при условии, что индексы 2-го и дальше уровне фиксированные. Переменным может быть только первый.

А>Спасибо, а почему *d в скобках? Извини за вопрос, я только учусь

Я думаю что в стандарте или книгах по C++ возможно найти более точное определение — я не искал. Но идея следующая, когда в типе присутствует правая часть, то что-бы описать не него указатель используются скобки. Такая техника, наиболее часто используется для описания указателей на функции. Примеры:

int (*pF)(int n); — указатель на функцию int f(int n)

int (C::* f)(int n); — указатель на не статический метод int f(int n), класса C

typedef int (*func)(int n); — описение типа func, как указателя на функцию

typedef int (*arr)[30][50]; — можно понимать как указатель на массив [30][50], или просто как массив [n][30][50]

...ну и т.д.

ZORK, Спасибо! теперь понятно.

А как тогда объявить динамечески двумерный массив указателей на функции которые принимают int и возвращают double. Что то я запутался...

Здравствуйте Аноним, вы писали:

А>А как тогда объявить динамечески двумерный массив указателей на функции которые принимают int и возвращают double. Что то я запутался...

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

typedef double (*_f)(int);
_f (*arr)[40];

и тогда можно делать

double r = arr[1][2](12);

Вообще-то * в скобках объясняется тем, что в C любые скобки (круглые или квадратные) имеют приоритет над звездой. Так что, если требуется, чтобы перемнная была указателем на массив, требуется написать именно так. Общий алгоритм разбора сложных типов такой: (из MSDN)

1. Начинаем с переменной.
2. Смотрим в пределах скобок направо:
а) Если там есть круглые скобки, то это функция. Все, что в этих скобках, интерпритируется как параметры этой функции.
б) Если там есть квадратные скобки, то это массив. В скобках должно стоять целое положительное число, которое рассматривается как количество элементов массива.
3. Теперь посмотрим налево. Если там есть звездочка, то это указатель.
4. Выбираемся из скобок на скобки более низкого уровня вложенности и повторяем шаги 2-3.
5. Так мы делаем, пока не доберемся до определения типа.

Пример:
char *(*(*a)(void))[10];
^ ^ ^ ^^ ^ ^
7 6 4 21 3 5

Итак, по порядку.

1. a определяется как...
2. ...указатель на...
3. ...функцию, не принимающую параметров и возвращающую...
4. ...указатель на...
5. ...массив из 10...
6. ...указателей на...
7. ...char.

Спасибо, уважаемый Аv за это объяснение. :-)
Теперь даже мне не страшны никакие указатели :-)

Здравствуйте Андрей Тарасевич, вы писали:

АТ>Здравствуйте Sasparella, вы писали:

S>>Так я к чему — можно ли чтонибудь придумать — такой класс многомерного массива, чтобы при обращении к соседним по каждому индексу элементам, реально происходило обращение к более менее соседним ячейкам памяти?.

АТ>Нельзя. В общем случае нельзя спроецировать двумерный массив на одномерный с соблюдением такого условия. Могу привести формальное доказательство.

Доказательство? Ооочень интересно было бы? ;o)

По-моему, если написать грамотный хелпер-класс, то можно все сэмулировать. Многомерный массив всегда можно развернуть в одномерный (см. реализацию SafeArray), а удобства в работе можно скрыть за переопределением оператора [].

Здравствуйте Аноним, вы писали:

А>Здравствуйте Anton V. Kolotaev, вы писали:

AVK>>А может быть лучше потратить некоторое время на изучение стандартной библиотеки? Там есть такое >понятие как std::valarray<T>, std::slice_array<T>. Как использовать — прекрасно описано у >Страуструпа 22.4.5 — 22.4.6.

А>Не подскажите где можно скачать эту книгу?

ftp://the-gate.dnsalias.net/library/

Здравствуйте VladD2, вы писали:

АТ>>Нельзя. В общем случае нельзя спроецировать двумерный массив на одномерный с соблюдением такого условия. Могу привести формальное доказательство.

VD>Доказательство? Ооочень интересно было бы? ;o)

VD>По-моему, если написать грамотный хелпер-класс, то можно все сэмулировать. Многомерный массив всегда можно развернуть в одномерный (см. реализацию SafeArray), а удобства в работе можно скрыть за переопределением оператора
[].

Никто не возражает, что двумерный массив можно спроецировать на одномерный. Речь идет о такой проекции, где рядом стоящие элементы в двумерном оказываются рядом и в одномерном. Интуитивно понятно, что такой проекции в общем случае быть не может, т.к. окрестность элемента двумерного массива содержит на порядок больше элементов, чем окрестность элемента одномерного массива.

Доказательство приведу позже. Голова сейчас другим забита.

Best regards,
Андрей Тарасевич,
Brainbench C and C++ Programming MVP

VD>ftp://the-gate.dnsalias.net/library/

Огромное спасибо — очень полезный ресурс