Привет всем !

Начинаю учить С++. Столкнулся с проблемой:
Есть два указателя ссылающиеся на какие-то данные.

BYTE *uk1;
BYTE *uk2;

Хочеться получить третий указатель, указывающий на данные на которые
указывает первый указатель + данные на которые указывает второй указатель.

Здравствуйте Simple Boy,

Можно сделать так:

//Байт занимает 8 бит
Byte* uk1, uk2;
//Берем данные по 1 указателю и приводим к типу long
long data_uk1 = *uk1;
//Создаем хранилище для наших данных
long data = data_uk1;
//Сдвигаем данные, чтобы можно было добавить другие
data = data << 16;
long data_uk2 = *uk2;
//Добавляем данные 2 указателя
data = data&(data_uk2);
//Получаем указатель на наши данные
long* data_uk = &data;


Можно другим способом через структуру

struct Data
{
Byte data_1;
Byte data_2;
} data_store;

int main()
{
//Заносим данные в структуру
data_store.data_1 = *uk1;
data_store.data_2 = *uk2;
//Берем указатель на структуру
Data* data_uk = &data_store;
return 0;
}

Надеюсь это то, что тебе нужно

С Уважением Краснокутский Василий

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

VK>Byte* uk1, uk2;

Ашибачка, аднака. Тип ukr2 — Byte. Надо

Byte *ukr1, *ukr2;

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

VK>int main()
VK>{
VK>//Заносим данные в структуру
VK>data_store.data_1 = *uk1;
VK>data_store.data_2 = *uk2;
VK>//Берем указатель на структуру
VK>Data* data_uk = &data_store;
VK>return 0;
VK>}

А как же выравнивание структур?
Хотя скорее всего сработает.

Здравствуйте volk,
А что ты имел ввиду под выравниванием структур (Мне это действительно интересно ...)?
Можно конечно и так (но это надо работать с алиасами типов, а не со строго заданными
long и byte):

int main()
{
long data = *uk1;
data = data << sizeof(*uk1)*8;
data = data | (*uk2);
long* p_data = &data;
return 0;
}

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

SB>Хочеться получить третий указатель, указывающий на данные на которые
SB>указывает первый указатель + данные на которые указывает второй указатель.

Кто саказал что указатели можно складывать? Если можно, то объясни что такое операция сложения для двух указателей?

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

VK>Здравствуйте volk,
VK>А что ты имел ввиду под выравниванием структур (Мне это действительно интересно ...)?
VK>Можно конечно и так (но это надо работать с алиасами типов, а не со строго заданными
VK>long и byte):

VK>int main()
VK>{
VK>long data = *uk1;
VK>data = data << sizeof(*uk1)*8;
VK>data = data | (*uk2);
VK>long* p_data = &data;
VK>return 0;
VK>}

А не проще ли воспользоваться объединениями?
Что нибудь такое ( если я правильно понял чего хочет автор вопроса ):

union BytesToShort
{
    unsigned char    bytes[2];
    unsigned short    data; 
};

BytesToShort converter ;
converter.bytes[0] = *Ptr1;
converter.bytes[1] = *Ptr2;
unsigned short* num = &converter.data;

Здравствуйте Batiskaf,
А какая разница ?? Структура размещается в памяти последовательно, объединение тоже ...
И в чем выигрыш ?

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

VK>Здравствуйте Batiskaf,
VK>А какая разница ?? Структура размещается в памяти последовательно, объединение тоже ...
VK>И в чем выигрыш ?

Я не уверен на 100%, но, по-моему, компилятор имеет право заниматься выравниванием членов структуры, в результате чего могут появиться дырки (а размер не будет равен сумме размеров). Объединение вообще не располагается последовательно, к нему такой термин неприменим, потому что все его члены лежать по одному адресу. А массив, который в этом объединении есть, дырок содержать не может.

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

You will always get what you always got
  If you always do  what you always did

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

VK>Здравствуйте Batiskaf,
VK>А какая разница ?? Структура размещается в памяти последовательно, объединение тоже ...
VK>И в чем выигрыш ?

Ну в данном случае, разницы действительно нет. Но кто-то справедливо заметил про выравнивание полей структуры.
Например:

struct A
{
char a;
short b;
long c;
};

Полагаться в коде на то что sizeof(A) == 7 никак нельзя ( писать HardCode вообще никогда не стоит ), этот размер вообще может зависеть от опций выравнивания компилятора.
Так что для таких вещей мне кажется структуры стоит применять с осторожностью, а у объединения все поля распологаются на одном и том же месте, никаких сдвигов между ними нет, вот и выравнивать нечего. Да и запись гораздо нагляднее, нет некрасивых кастингов.

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

J>Здравствуйте Vasiliy_Krasnokutsky, Вы писали:

VK>>Здравствуйте Batiskaf,
VK>>А какая разница ?? Структура размещается в памяти последовательно, объединение тоже ...
VK>>И в чем выигрыш ?

J>Я не уверен на 100%, но, по-моему, компилятор имеет право заниматься выравниванием членов структуры, в результате чего могут появиться дырки (а размер не будет равен сумме размеров). Объединение вообще не располагается последовательно, к нему такой термин неприменим, потому что все его члены лежать по одному адресу. А массив, который в этом объединении есть, дырок содержать не может.

J>Поэтому, если не хочешь напороться на выравнивание, используй объединение с массивом.

С выравниванием можно боротся еще так:

#pragma pack(push,1)
struct
{
...
}
#pragma pack(pop)

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

SB>Привет всем !

SB>Начинаю учить С++. Столкнулся с проблемой:
SB>Есть два указателя ссылающиеся на какие-то данные.

SB>BYTE *uk1;
SB>BYTE *uk2;

SB>Хочеться получить третий указатель, указывающий на данные на которые
SB>указывает первый указатель + данные на которые указывает второй указатель.

Постараюсь ответить по существу.
Если ты только начинаешь учить указатели, то можешь представлять указатель просто как номер ячейки памяти, начиная с которой лежат какие-то данные (в сущности, указатель этим и является).

Тип указателя определяет, на данные какого типа он указывает (извиняюсь за тавтологию).

А вот сколько ячеек занято под данные, указатель не знает, он лишь помнит первую ячейку. Количество данных надо хранить отдельно.

Твоя ситуация. Начиная с какой-то ячейки памяти uk1 лежит сколько-то данных (N штук) типа BYTE. В совсем другом месте памяти uk2 лежит еще сколько-то данных (M штук).

Делать надо следующее:
создаем массив на M+N данных:
BYTE* uk3 = new BYTE[M+N];
Копируем в этот массив данные c uk1 (N штук), а за ними -- и с uk2 (M штук).
int i3 = 0;
int i;
for (i=0; i<N; i++) { uk3[i3] = uk1[i]; i3 = i3 + 1; }
for (i=0; i<M; i++) { uk3[i3] = uk2[i]; i3 = i3 + 1; }

uk3 и есть искомый указатель.
В конце работы неплохо бы уничтожить созданный оператором new массив uk3:
delete [] uk3;

Очень может быть, что в твоем случае N=M=1. Но об этом ты умолчал.
Если N=M=1, то циклов не надо, хотя если они будут, это тоже верно.

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