Общий размер структуры

Так buff - это же уже адрес, Если ставить & - то нужно указывать элемент массива. Не так?

 

все верно
igor68 - лучше использовать просто buff, без & и индексов

вот такая запись очень корявая:

Код (C++):

uint8_t *b = &buff[3];

лучше так:

Код (C++):

uint8_t *b = buff +3;

 

Есть переменная buff это ячейка в памяти.
В ней хранится адрес первого элемента массива.
А если взять &buff - мы получим адрес самой переменной, а не адрес первого элемента массива.
Какая ячейка к черту, нет там никакой ячейки, ячейка - это указатель когда.
А тут просто адрес начала буфера. Поэтому если правильно преобразовать типы

Код (C++):

&buff[0] == &buff == buff
 

 

и чем она лучше?

 

Во! Понеслось!!! Жи ши пиши с буквой Ы
Речь ведь была про другое.
Вот к примеру:

Код (C++):

uint64_t TS=(*(uint64_t*)(&buff[0])) //прокатывает
uint64_t TS=(*(uint64_t*)(&buff[1])) //не прокатывает
uint64_t TS=(*(uint64_t*)(&buff[2])) //не прокатывает
uint64_t TS=(*(uint64_t*)(&buff[3])) //не прокатывает
uint64_t TS=(*(uint64_t*)(&buff[4])) //не прокатывает
uint64_t TS=(*(uint64_t*)(&buff[5])) //не прокатывает
uint64_t TS=(*(uint64_t*)(&buff[6])) //не прокатывает
uint64_t TS=(*(uint64_t*)(&buff[7])) //не прокатывает
uint64_t TS=(*(uint64_t*)(&buff[8])) //прокатывает

Кстати зависит как от платформы и наверное ещё компилятора.
Наверное на 8-ми битных будет прокатывать в любом случае,
на 16-битных кратное двум,
на 32 битных кратное 4
на 64 битных кратное 8
Досконально проверить не могу нет под рукой устройств и компиляторов разных типов.
Для себя лично взял за правило размещать подобно этому правило... хотя это:

Код (C++):

uint64_t TS= (uint64_t)(buff[1]);
TS |= (uint64_t)(buff[2] << 8);
TS |= (uint64_t)(buff[3] << 16);
TS |= (uint64_t)(buff[4] << 24);
TS |= (uint64_t)(buff[5] << 32);
TS |= (uint64_t)(buff[6] << 40);
TS |= (uint64_t)(buff[7] << 48);
TS |= (uint64_t)(buff[8] << 56);
 

Так прокатит, но уж больно трудоёмко... так что лучше располагать с умом. Думаю для 8-ми битных вообще не важно

 

Я и говорю: "ПОНЕСЛОСЬ" А где определение "buff"??? Кушать много можно только ВОДКУ, всё остальное вредно

 

А что я говорю-то?! Мне так же попадались компиляторы-телепаты... вот только они такой гвоздь иногда вгоняют, что убьёшься его "ум" обходить в ряде случаев. Самое правильное это отличать адрес параметра от самого параметра, а компилятор чем строже, тем лучше! Я читаю даже его (GCC) предупреждения вот к примеру:

Код (C++):

catserver.c:186:46: warning: passing argument 2 to restrict-qualified parameter aliases with argument 3 [-Wrestrict]
                 err = select(scslistener + 1,&fdss,&fdss,NULL,&tvs);
                                              ^~~~~ ~~~~~
 

Что ему надо? крутил и так и так... код работает на разных Linux устройствах и один компилятор молчит(всё нормально), а другой не доволен. Хотя в том и другом случае результат компиляции рабочий.

 

Только вот такая:

Код (C++):

uint8_t *b = &buff[0] + 3;
или
uint8_t *b = &buff + 3;
 

Правильная... ну это если компилятор не к телепат. Телепатические способности были обнаружены у
Borland C++ 6.

 

"остапа несло..."
Напишите четко, что тут прокатывает или нет. я не понимаю.
Для меня запись

Код (C++):

uint64_t TS=(*(uint64_t*)(&buff[2]))

- это говнокод


я пишу так

Код (C++):

uint64_t TS=(*(uint64_t*)(buff + 2))

 

Оно и видно
какая разница int8_t buff или int8_t *buff... верно??? А что Вы пили? Я то же так хочу

 

с этого места поподробнее ))

Внимание, вопрос!
Вот вам описание массива

Код (C++):

int8_t buff[8];

Какой тип имеет переменная buff :
а ) int8_t buff
б) int8_t *buff
?

 

Код (C++):

int8_t buff[_size];
//так
int64_t TS=(*(int64_t*)(&buf[addr]));
//или так
int8_t *abuff = &buff[_addr]; // _addr при указании начала иначе int8_t *abuff = &buff
int64_t TS=(*(int64_t*)(abuff + <если надо смещение от начала>));

Как говорил это для компиляторов без телепатии.
Вообще-то Вы можете гулять как хочете, я же буду гулять как я хочу

 

имя массива - это всегда указатель на его начало.

 

да не вопрос. гуляйте как хотите. только ведь это у вас проблемы с компиляторами. а не у меня.

Игорь, cдается мне, что вы не понимаете элементарных вещей про массивы в Си
имя массива в Си - это адрес первого(нулевого) элемента.
Если массив описан как
uint8_t buff[8]. то buff - это ссылочкая переменная типа uint8_t* и указывает она на начало массива

А впрочем как хотите

 

Согласен и не спорю!!! Только вот устал прыгать от GCC на VisualStudio и потом в Keil uVision и везде свои ограничения и правила... но так как я привык делать срабатывает везде одинаково. Ну если не считать темы про размерность массива, о чём вообще-то и тема. А совсем не про адреса/указатели.

 

Где ж не спорите?
Опять бредятину пишете:

пишите так и все будет работать везде одинаково:

Код (C++):

int8_t *abuff = buff + _addr; // _addr при указании начала иначе
int8_t *abuff = buff;

почему у меня это работает и в Ардуино и ВижуалСтудии. и в Кейле?
Может потому что на самом деле тема как раз про адреса и указатели... а вы их не понимаенте

 

ну здрасте)) массив и есть указатель на его первый элемент. Индекс - смещение адреса от первого элемента.

а можно как-то по-другому массив описать?

 

И тут согласен. На Си с 1994г, и привычки старые. К C++ так и не привык как к таковому. А что Вы так до этого доматались? Я в старом стиле работаю.

 

Кстати у меня в Кейле именно это и не работает

 

потому что корень ваших проблем со структурами именно в этом.

и не обманывайте себя, вы работаете не "в старом стиле", а просто неправильно.
Все что я написал выше - относится к Си так же как к С++