Arduino.ru

...а в чем вопрос?

Заставить либо мою ф-ю работать, у меня знаний не хватает, либо предложить свою за огромное спасибо!

В вашей-то что не работает?

В выходном массиве хрень какая то

Показывайте, что за хрень...

Ну выполни. Или свою ф-ю предложи под задачу. Показывать нечего. В массиве белеберда

Нечего, так нечего. Проблема не у меня.

это просто от незнания по организации адресации в двумерном массиве, брать текущий и прямо по нужному адресу двумерного копировать

Абсолютно согласен про адресацию. Можно пример на пальцах?

ТС такие конечные функции не завязанные на логике программы удобнее писать и отлаживать в Visual Studio... там богатейшие возможности у дебаггера...

пошагово исполняешь тут же видишь какие изменения в данных в окне memory

Вот тут гляньте первые 4-5 минут, там и пример

DimaD, вы можете внятно объяснить, что должна делать ваша функция? Как только я встретил в ней массив размером 7х36 - я понял что совершенно ничего не понимаю в коде...

Такие функции вообще не надо писать. Нужно просто обращаться к тому же самому массиву по "двумерной схеме".

ТС, тут просто не нужна никакая функция.

Я, всё же, без функции не обошёлся. Но и думал, вобщем-то, больше о жареном картоше... 

а так можно? оно понятно, что в памяти это оно одно и тоже, можно пример???

Любой одномерный массив можно представить как двумерный, простая арифметика. Допустим, у нас есть массив из 10 элементов, и мы хотим обращаться к нему как к двумерному массиву из 5 строк по две ячейки в каждой. Строки - X (5 штук), ячейки - Y (по две на строку). Начальный адрес строки N будет Y*N, первая ячейка строки - Y*N, вторая ячейка строки - Y*N+1. Нумерация, ессно, с нуля.

На исходник можно взглянуть?

по адресу любой сможет, классически бы по новому имени массива двумерного, к примеру aaa [0] [0]

Ну, так и сделайте, кто не даёт? Это ж просто синтаксический сахар.

Как всегда молодых подстёбывают, а те не понимают. )))

В памяти машины любые многомерные данные представляются единой последовательностью битов (в одну линию).

DIYMan все верно написал, никто не слышит или не слушает...

а в коде можно? - PS Любой одномерный массив можно представить как двумерный...

вот имею я массив byte bbb[18] {xxxxxxxxxxxxxx....}

и как к элементам массива обратится через двумерный byte aaa[2][10] ??? и в размерности, там 18 байт, здесь двадцать... именно из языка С чтобы обращаться к одномерному как к двухмерному

a= aaa[0][5];
Serial.print(a);

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

ох давно я студию не открывал к своему стыду

как то так

typedef int arr_5x5_t[5][5];

int _tmain(int argc, _TCHAR* argv[])
{
	int flat_arr[25];
	arr_5x5_t& ref_arr = (arr_5x5_t&)flat_arr;
	arr_5x5_t* p_arr = (arr_5x5_t*)flat_arr;
	ref_arr[2][2] = 22;
	(*p_arr)[2][3] = 22;
	return 0;
}

Закастить проблем нет. В тутошнем случае один массив на другой ровно не ложится - все равно надо хвост вычислять и отрабатывать вывод с его учётом.

читаю и не пойму. о чем вы спорите.

Помойму :) ТС хотел не просто отобразить одномерный массив в двумерный. а сначала перевести байты в их символьное представление, типа 0x01 => "01" . а уже потом собрать полученные строчки в две строки.

И еще - почему никто не обратил внимание. что массив в заглавном сообщении бредовый? После 0x09 должно идти 0x0A, а вовсе не 0x10. И при преобразовании 0x10 должно давать вовсе не "10", а 16!

Да тут диспут о правильной навигации по массиву. А сбор в строку может и не нужен будет ;) С учётом значений исходного массива...

если диспут только о "правильной выборке из массива" -  зачем тут что-то кастить? используйте адрессную арифметику

#include <stdio.h>

void main() {
int  arr[8] = {1,2,3,4,5,6,7,8};
int i =2;
int j =4;
int ii, jj;
for (ii =0; ii <i; ii++) {
 for (jj=0; jj<j; jj++) {
  printf("arr[%d][%d] = %d\n",ii, jj, *(arr+ ii*4 + jj) );
  }
 }
} 

вывод

arr[0][0] = 1
arr[0][1] = 2
arr[0][2] = 3
arr[0][3] = 4
arr[1][0] = 5
arr[1][1] = 6
arr[1][2] = 7
arr[1][3] = 8 

если ему нужен строковый и в каждой строке по два байта, то это будет совсем другом массив )))
преобразование числа в строку где-то применялось тут при по байтном  выводе содержимого EEPROM в монитор порта, но я так понимаю, сам массив строковый на стадии компиляции уже должен быть и проинициализирован!?

Теперь выведи так исходный массив из пяти айтемов, например. ;)

и в чем прорблема? - главное вовремя остановится :)

Вы вообще о чём? Если один массив не налазит на другой, то никак Вы его не натяните.

Всё же просто, представьте вот такой диалог

- Я сделал супер-пуперную реализацию двумерного массива на базе одномерного!
- А что будет, если на последнюю строку не хватает данных или иным способом вылезти за границы твоего двумерного массива?
- Да, тоже самое, что и если вылезти за границы честно объявленного двумерного массива!

Тоже самое! Ну не контролируются в этом языке границы массивов!

У меня нет проблемы, она у ТС, который включает босса и бросает на прилавок свой исходник, требуя разобраться с его багами или выдать ему более лучший (видимо подразумевая гарантийный случай) вариант.

#include <stdio.h>

void main() {
int  arr[8] = {1,2,3,4,5,6,7,8};
int i =2;
int j =4;
int ii, jj;
for (ii =0; ii <i; ii++) {
 for (jj=0; jj<j; jj++) {
  printf("arr[%d][%d] = %d\n",ii, jj, *(arr+ ii*4 + jj) );
  }
 }
} 

Насколько я понял, ua6em спрашивал не об этом. Он хотел "синтаксического сахара", чтобы писать как с "честно объявленным" двумерным массивом и не париться.

a= aaa[0][5];
Serial.print(a);

Можно и уважить, только вот сдаётся мне, что ua6em всё знает и сам, только нас троллит.

В общем, ладно, троллит - так троллит, будем считать, что я попался. Вот пример, в котором Ваша адресная операция выведена в шаблон из трёх строк, а с ним уже можно писать "как обычно" - "с сахаром". (Если у кого-то есть вопросы типа "а что, если там нецелое количество строк?", см. мой пост #30)

#include <Printing.h>

//
// inline класс для работы с одномерным массивом любого типа,
// как с двумерным с длиной строки columns
// Параметры: 
//		- базовый одномерный массив с данными
//		- длина строки (количество столбцов) в двумерном массиве
// 
template<auto n, const size_t columns> struct DoubleDimArray {
	inline typeof(n) operator [] (const size_t row) { return n + row * columns; }
};

//
//	Одномерный массив чисел
//
int intSingleDim [] = {
	900, 901, 902, 903, 904, 
	910, 911, 912, 913, 914, 
	920, 921, 922, 923, 924, 
	930, 931, 932, 933, 934 
};

//
//	Одномерный массив указателей на char
//
const char * pCharSingleDim [] = {
 	"pChar_0x0", "pChar_0x1", "pChar_0x2",
 	"pChar_1x0", "pChar_1x1", "pChar_1x2",
 	"pChar_2x0", "pChar_2x1", "pChar_2x2",
 	"pChar_3x0", "pChar_3x1", "pChar_3x2",
 	"pChar_4x0", "pChar_4x1", "pChar_4x2",
 	"pChar_5x0", "pChar_5x1", "pChar_5x2"
};

//
//	Одномерный массив объектов типа String
//
const String stringSingleDim [] = {
 	"String_0x0", "String_0x1", "String_0x2", "String_0x3",
 	"String_1x0", "String_1x1", "String_1x2", "String_1x3",
 	"String_2x0", "String_2x1", "String_2x2", "String_2x3",
 	"String_3x0", "String_3x1", "String_3x2", "String_3x3",
 	"String_4x0", "String_4x1", "String_4x2", "String_4x3"
};

//
//	Массив array_of_int_4x5 - двумерный "4 строки / 5 столбцов"
// базируется на данных одномерного массива intSingleDim
//
DoubleDimArray<intSingleDim, 5> array_of_int_4x5;

//
//	Массив array_of_PChar_6x3 - двумерный "6 строк / 3 столбца"
// базируется на данных одномерного массива pCharSingleDim
//
DoubleDimArray<pCharSingleDim, 3> array_of_PChar_6x3;

//
//	Массив array_of_String_5x4 - двумерный "5 строки / 4 столбца"
// базируется на данных одномерного массива stringSingleDim

//
DoubleDimArray<stringSingleDim, 4> array_of_String_5x4;

void setup(void) {
	Serial.begin(57600);
	//
	printVar(array_of_int_4x5[0][0]);
	printVar(array_of_int_4x5[0][1]);
	printVar(array_of_int_4x5[2][3]);
	printVar(array_of_int_4x5[3][4]);
	Serial.println();
	printVar(array_of_PChar_6x3[0][0]);
	printVar(array_of_PChar_6x3[1][2]);
	printVar(array_of_PChar_6x3[2][1]);
	printVar(array_of_PChar_6x3[5][2]);
	Serial.println();
	printVar(array_of_String_5x4[0][0]);
	printVar(array_of_String_5x4[1][2]);
	printVar(array_of_String_5x4[2][1]);
	printVar(array_of_String_5x4[4][3]);
}

void loop(void) {
	delay(100500);
}

Результат

array_of_int_4x5[0][0]=900
array_of_int_4x5[0][1]=901
array_of_int_4x5[2][3]=923
array_of_int_4x5[3][4]=934

array_of_PChar_6x3[0][0]=pChar_0x0
array_of_PChar_6x3[1][2]=pChar_1x2
array_of_PChar_6x3[2][1]=pChar_2x1
array_of_PChar_6x3[5][2]=pChar_5x2

array_of_String_5x4[0][0]=String_0x0
array_of_String_5x4[1][2]=String_1x2
array_of_String_5x4[2][1]=String_2x1
array_of_String_5x4[4][3]=String_4x3

ua6em, Вы этого хотели?

Точно!!! И это не троллинг. Я имею представление как это организовать на ассемблере (точнее в кодах, но не атмеги), хотелось бы увидеть как на С. Увидел. Осталось разобраться!
По сути то надо было объявить нужной мерности массив и передать (заменить адрес переменной массива) ему в качестве адреса, адрес существующего массива. Так?

То-есть получили даже не сахар, а мёд )))
(В вашем примере)
 

а у ТС есть проблемы???
 

совсем нет.

Насколько я понимаю код Евгения (а мне кажется что понимаю) - по сути эта та же адресная арифметика что у меня(сорри за нескромность :) в сообщении #26, но только оформленная в общем виде - как перегрузка оператора взятия элемента по индексу

стандартными ИМХО, нет. Адрес переменной в Си - насколько я знаю, константа, подменить его нельзя.

https://godbolt.org/

Абсолютно точно. Так я же там так и написал (обращаясь к Вам): "пример, в котором Ваша адресная операция выведена в шаблон из трёх строк".

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

Давайте я ему отвечу.

ua6em, Вы путаете c прямым углом. Не делается это в ассемблере ни за один такт, ни за десять, потому, что нету там никаких массивов.

То, что Вы пишете, делается одной командой на любом языке, но только не объявлением доп массива (нахрена Вам под него память выделять), а объявлением указателя:

double superMassiv[100500];
.....
double * escheMassiv  =  superMassiv;
//
// А теперь, на здоровье
//
double f = escheMassiv [2]; // берётся элемент №2 массива superMassiv

ну тогда видимо совсем понесло :). потому что Вы немного не о том, как мне кажется.

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

То есть вот такой пример не сработает:

double superMassiv[100500];
.....
double * escheMassiv  =  superMassiv;
//
// А теперь, на здоровье
//
double f = escheMassiv [2][2]; 

А ua6em предлагает обьявить переменную как двумерный массив, и потом изменить ее адрес, присвоив ей адрес другой переменной - одномерного массива

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

Хотя, почему к указателю нельзя как к двумерному? Подсуньте указатель  escheMassiv из прошлого поста в шаблон, что я определил выше. Он его сожрёт за милую душу - вот и двумерность. Адресную арифметику ж никто не отменял.

Вообще-то, Си - не мой родной язык, но у меня как-то отложилось, что в Си массив и указатель - это одно и то же.

Скорее "имя массива является указателем на его первый элемент".

Увы, вряд ли эту фразу можно понять однозначно, если не знать, чем при этом является имя простой переменной (для сравнения).

По гамбургскому счёту - да, но есть существенный нюанс. При объявлении массива под все его элемент выделяется память, а отдельно под указатель - не выделяется. При объявлении указателя - память выделяется под указатель, а под элементы - не выделяется.

а как этот указатель понимает двумерность и размерности двумерности?