двухбайтное число в quint16

[Edynchik]

Есть такая ситуация, число лежит в массиве побайтно младшими вперед например 0x020e, т.е.

Код:

buf[0] = 0x0e;buf[1] =0x02;

как сделать так, чтобы записать число в quint16? пробовал

Код:

quint16 n = (quint16)buf[1];

,чтобы явное преобразование захватило сразу два байта, но что то не выходит, прошу помощи.

[Old]

Есть такая ситуация, число лежит в массиве побайтно младшими вперед например 0x020e, т.е.

Код:

buf[0] = 0x0e;buf[1] =0x02;

как сделать так, чтобы записать число в quint16? пробовал

Код:

quint16 n = (quint16)buf[1];

,чтобы явное преобразование захватило сразу два байта, но что то не выходит, прошу помощи.

buf[0]

[Edynchik]

да и buf[0] пробовал выдает не 2 а 14, что то тоже не то, там вроде указатель должен быть???

[kambala]

наверное что-то типа такого должно быть:

Код

C++ (Qt)
quint16 n = *(reinterpret_cast<quint16 *>(buf));

[Edynchik]

спасибо, правда сейчас нет под рукой компилятора, завтра проверю.

[Пантер]

qFromLittleEndian, qFromBigEndian.

[juvf]

наверное что-то типа такого должно быть:

Код

C++ (Qt)
quint16 n = *(reinterpret_cast<quint16 *>(buf));

будет работать до поры до времени, пока адрес buf выровнен. если не проследить за выравниванием, то словите ошибку во время выполнения, причем трудноуловимую. лучше не баловаться подобным приведением типа, а сделать что-то типа

quint16 n = buf[0] + (buf[1] >> ;

[Igors]

наверное что-то типа такого должно быть:

Код

C++ (Qt)
quint16 n = *(reinterpret_cast<quint16 *>(buf));

будет работать до поры до времени, пока адрес buf выровнен. если не проследить за выравниванием, то словите ошибку во время выполнения, причем трудноуловимую. лучше не баловаться подобным приведением типа, а сделать что-то типа

quint16 n = buf[0] + (buf[1] >> ;

Что за мифическое выравнивание? Давайте проверим

Код

C++ (Qt)
#pragma pack(push, 1)
struct CTest {
 char ch;
 char buf[128];
};
#pragma pack(pop)
...
CTest test;
quint16 * dst = (quint16 *) &test.buf[0];
*dst = 5;
qDebug() << dst << *dst;
 

Неужели *dst не будет правильно читаться/писаться если стоит по нечетному адресу ?  

[juvf]

Что за мифическое выравнивание? Давайте проверим

А не везде эти прагмы работают. Например последний случай на UC-8410 = http://www.moxa.com/product/UC-8410.htm, ARM процессор, эти прагмы не работают. Выравнивание 4.

я присал

если не проследить за выравниванием, то словите ошибку во время выполнения

вы же мне привели код, в котором проследили за выравниванием. Во вторых ваш тестовый код не выявит ни чего.

Код:

CTest test;
quint16 * dst = (quint16 *) &test.buf[0];//допустим buf - нечетный алдрес и выравнивание к 4.
*dst = 5; // если buf на нечетном адресе, то тут ловим ошибку... пишется куданить в сторону. допустим записали в адрес buf-1
qDebug() << dst << *dst; //тут опять ловим ошибку.... опять обращение в сторону и читаем не из адреса buf, а из адреса buf-1

вывод в любом случае будет 5

лучше так проверить

Код:

#pragma pack(push, 1)
char buf[128] = {0};
#pragma pack(pop)
...
buf[1] = 0x34;
buf[2] = 0x12;
quint16 *dst = (quint16 *) &buf[1];
cout << "dst = " << *dst << endl;
*dst = 0xABCD;
cout << "buf[1] = " << buf[1] << "\tbuf[2] = " << buf[2] << endl;

[Igors]

лучше так проверить

Давайте так (чуть изменил печать)

Код

C++ (Qt)
#pragma pack(push, 1)
char buf[128] = {0};
#pragma pack(pop)
 
buf[1] = 0x34;
buf[2] = 0x12;
quint16 *dst = (quint16 *) &buf[1];
printf("dst = 0x%x\n", (int) *dst);
*dst = 0xABCD;
printf("dst = 0x%x\n", (int) *dst);
 

Вывод

dst = 0x1234
dst = 0xabcd

// если buf на нечетном адресе, то тут ловим ошибку... пишется куданить в сторону. допустим записали в адрес buf-1

С чего Вы это взяли Пишется начиная с того адреса который дали. Просто если он не выровнен, процессор затратит больше времени ("штрафные такты" и все такое) - но никакой ошибки мы не словим

[Old]

С чего Вы это взяли Пишется начиная с того адреса который дали. Просто если он не выровнен, процессор затратит больше времени ("штрафные такты" и все такое) - но никакой ошибки мы не словим

Вы ошибаетесь. Точнее пытаетесь судить обо всем по своим знаниям.
А человек выше даже указал процессор, который не умеет читать не выровненные данные.

[juvf]

лучше так проверить

Давайте так (чуть изменил печать)

Код

C++ (Qt)
#pragma pack(push, 1)
char buf[128] = {0};
#pragma pack(pop)
 
buf[1] = 0x34;
buf[2] = 0x12;
quint16 *dst = (quint16 *) &buf[1];
printf("dst = 0x%x\n", (int) *dst);
*dst = 0xABCD;
printf("dst = 0x%x\n", (int) *dst);
 

Вывод

dst = 0x1234
dst = 0xabcd

// если buf на нечетном адресе, то тут ловим ошибку... пишется куданить в сторону. допустим записали в адрес buf-1

С чего Вы это взяли Пишется начиная с того адреса который дали. Просто если он не выровнен, процессор затратит больше времени ("штрафные такты" и все такое) - но никакой ошибки мы не словим

А о чем вообще спор? ТС спросил как из байтового массива получить 2-хбайтное? Ему посоветовали

quint16 n = *(reinterpret_cast<quint16 *>(buf));

Видать ТС новичок и плохо разбирается в привидении типа.  Он этот код использует у себя.... и возможно его buf[0] выровнен к 4. Или у него процессор 8-ми битный. Он в своем коде ни когда не словит ошибку.  Я предостерёг, что пользуясь таким кодом нужно следить за выравниванием. В чем я не прав? Ни кто ему не сказал сделай так

#pragma pack(push, 1)
char buf[128] = {0};
#pragma pack(pop)
quint16 n = *(reinterpret_cast<quint16 *>(buf)

Нужно понимать, что на конкретной архитектуре выравнивание может быть 2 или 4. На некоторых архитектурах не работают прагмы. То, что вы проверили на конкретной архитектуре и заработало - это не значит что будет работать везде. На AVR без прагмы всё будет работать.
ТС использует такое приведение типа без прагмы, как посоветовали, код будет работать. ТС усвоит урок. Потом в другом месте сделает также (или использует этот код)... и обратится по невыровненным данным.... выстрелит себе в ногу. "Прозанимается любовью" с этой багой.... и соскочит на жаву. А потом возникают на форумах холивары, что с/с++ гавно.

Вы в своем коде проследили за выравниванием, т.е. вы прагмами изменили выравнивание к 1. Я говорю тоже самое - нужно учитывать выравнивание.

ps

Код:

*dst = 0xABCD;
printf("dst = 0x%x\n", (int) *dst);

я уже говорил, что такой код не дает проверки. если разыменование *dst происходит неправильно, то вы в неправильный адрес запишите 0xABCD, а потом проверяете прочитав также из неправильного адреса.

[Igors]

Цитированием не злоупотребляйте плз

ТС использует такое приведение типа без прагмы, как посоветовали, код будет работать. ТС усвоит урок. Потом в другом месте сделает также (или использует этот код)... и обратится по невыровненным данным.... выстрелит себе в ногу. "Прозанимается любовью" с этой багой.... и соскочит на жаву. А потом возникают на форумах холивары, что с/с++ гавно.

Трогательная забота о ТС - но у него своя голова есть А захочет на жабу - тем лучше, слабаки не нужны. Еще до PowerPC я работал на Mac, тогда проц motorola не умел писать в нечет - но он выбрасывал исключение "address must be even". Если опять такой появится и возникнет необходимость его поддержки (Вашу ссылку открыть не могу, но гипотетически это возможно)- ну тогда много чего полетит, и много чего придется переписывать. А до этого не стоит шарахаться от мифических угроз, типа "а вот есть такой проц где.. и тогда, тогда... о ужас!!!"  Стандарт запрещает писать по невыровненному адресу? Насколько мне известно - нет. Ну и все, а там посмотрим. Заказ на работу с причудливым процом еще надо получить.

Вот куда более реальная проблема: на Вындоуз тип long всегда 4 байта. а вот на Mac он 8 в 64-bit но 4 в 32-bit. Связанные с этим ошибки совсем не редки. Следуя Вашей логике нужно немедленно истребить все long заменив на что-то типа SInt32. Но сделали ли Вы это? 

[juvf]

Стандарт запрещает писать по невыровненному адресу? Насколько мне известно - нет. Ну и все, а там посмотрим. Заказ на работу с причудливым процом еще надо получить.

Если на конкретной архитектуре выравнивание 4, то с подобным приведением типа вы должны позаботиться о выравнивании. либо вы должны чтобы buf был кратен 4, либо вы должны указать прагмой нужное выравнивание. выравнивание 4 - это не мифический процессор. Вот  http://www.moxa.com/product/UC-8410.htm - вполне не мифическая микроЭВМ с немифическим Intel XScale IXP435 533 MHz processor.

Что за мифическое выравнивание? Давайте проверим
Код

#pragma pack(push, 1)
struct CTest {
 char ch;
 char buf[128];
};
#pragma pack(pop)
...
CTest test;
quint16 * dst = (quint16 *) &test.buf[0];
*dst = 5;
qDebug() << dst << *dst;

Неужели *dst не будет правильно читаться/писаться если стоит по нечетному адресу ?

Смешно както.... "Что за мифическое выравнивание? Давайте проверим" - и тут же приводите проверочный код, в котором вы позаботились о выравнивании. Если это выравнивание мифическое, зачем вы прагмой изменили выравнивание к 1? Ваш проверочный код выровнен к 1. И данные выровнены к 1. Можно спокойно обращаться к адресам кратным 1. Вы проверьте без выравнивания.

шарахаться от мифических угроз, типа "а вот есть такой проц где.. и тогда, тогда... о ужас!!!"

От каких мифических угроз?  На любом процессоре и любой архитектуре, если делаешь привидение типа

Код:

quint16 n = *(reinterpret_cast<quint16 *>(buf));

проследи, чтобы буф был выровнен. если по дефолту выравнивание 4 - смотри чтоб буф был выровнен к 4. Если ваш буф по нечетному адресу, то измени выравнивание к 1 (хотя не везде это сработает). Так или иначе, но программист обязан следить за выравниванием, при подобном приведении типа. В чем я не прав?

С ваших слов, выравнивание это миф и о нем заботиться не нужно. И в качестве доказательства приводите пример с выровненными данными. В чем смысл?

[Igors]

От каких мифических угроз?  На любом процессоре и любой архитектуре, если делаешь привидение типа

Код:

quint16 n = *(reinterpret_cast<quint16 *>(buf));

проследи, чтобы буф был выровнен. если по дефолту выравнивание 4 - смотри чтоб буф был выровнен к 4. Если ваш буф по нечетному адресу, то измени выравнивание к 1 (хотя не везде это сработает). Так или иначе, но программист обязан следить за выравниванием, при подобном приведении типа. В чем я не прав?

Возможно Вы имели ввиду нечто типа

Код

C++ (Qt)
struct CTest {
  char ch;
  quint16 val;
}; 
CTest test;
...
 
quint16 n = *(reinterpret_cast<quint16 *> (&test.ch + 1);
 

Да, это неверно, n будет совсем не test.val, до которого еще 1 байт. Да, если сделаем #pragma pack 1 для CTest - тогда будет верно. С этим никто не спорит, но это совсем не значит что reinterpret_cast что-то "не так приводит" или читается/пишется куда-то "налево". reinterpret_cast четко работает с тем адресом что дали. Напр если это &test.val - то он и будет читаться/писаться, какое бы выравнивание ни стояло.

Если на конкретной архитектуре выравнивание 4, то с подобным приведением типа вы должны позаботиться о выравнивании. либо вы должны чтобы buf был кратен 4, либо вы должны указать прагмой нужное выравнивание. выравнивание 4 - это не мифический процессор. Вот  http://www.moxa.com/product/UC-8410.htm - вполне не мифическая микроЭВМ с немифическим Intel XScale IXP435 533 MHz processor.

Я открыл ссылку, поискал "align" - не нашел. Пожалуйста "ткните носиком".