Уважаемые знатоки! Прошу помощи в одном глупом вопросе!

имеется ситуация:


По идее, при разыменовании ULoooongerPoiter мы прочитаем произвольные 4 байта.

Вопрос:
Как сделать так, что бы ->


Всю голову сломал. Необходимо много методов, где в качестве аргумента принимается указатель на число без точки. Метод принимающий указатель должен сохранить указатель вне зависимости от типа и безопасно работать в дальнейшем как с unsigned long long. Поможите пожлста кто чем может, а то мой мозг лопнет.

Добавлено через 10 минут и 31 секунду
Вдруг если вопрос описал неясно. В общем вот такой постой класс состоящий из сеттеров и геттеров.



Думаю нет смыслу вписывать тело функций, и так понятно что 5 методов позволяют присвоить _Data и _Size значения и 2 метода возвращают эти значения. То есть, данный класс всего лишь хранит какую то простенькую информацию.

Это сообщение отредактировал(а) BearFear - 10.11.2012, 09:34

Неужели прямо безвыходная ситуация? :(

BearFear, много букв, 
два раза прочитал, так и не понял что вы хотите.

если это и есть вопрос тогда так:



нет long long это наверняка 8 байт.


что такое число без точки?

Добавлено @ 12:03
и еще
_Size это же размер,  нафига он у вас указатель я так и не понял.


Это сообщение отредактировал(а) volatile - 10.11.2012, 12:09

проверочный код


смысл класса, получить указатель на любой тип указния размера, но сохранить его как указатель на unsigned long long. Нужен этот класс для формирования динамических структур на лету.


да, и unsigned int наверняка 4 байта. В этом случае 4 байта читаем произвольные.

То есть, указатель на размер, может являться ранее записанным блоком данных. Например для этономии места в файле, мы пишем unsigned char значение экономящее 7 байт и саму строку не надо делать фиксированной длины. Да, можно использовать приведения во вложенных циклах и делать сотни строк кода. Надо что бы был класс, так как процедуру опроса очереди можно сделать параллельной. Отсюда потребность в очереди вариативных объектов описывающих задание. Ну эт пофиг. 

Приведение в стиле Си.... 


тот же результат, 0x29A0000029A. То есть, мы читаем произвольные 4 байта.

Это сообщение отредактировал(а) BearFear - 10.11.2012, 12:38

BearFear, нахрена у вас сайз указатель?
ответьте только на это

Ну ребят, наверно я не так все высказал. Вы уж сори если что. В общем надо что бы:
- на входе указатель произвольного типа POD (за искл. float / double / long double)
- на выходе указатель unsigned long long

указатель _Size для определения размера блока памяти void*. И блок памяти void* может потенциально быть указателем размера другого блока. Смысл в этом.

Это сообщение отредактировал(а) BearFear - 10.11.2012, 12:55

кажется дошло.
вы не понимаете что такое указатели.

_Size это не указатель, это размер - беззнаковое целое.

Вероятно вам нужно что-то подобное:


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

Неплохая идея с параметризацией методов... кстати! Про указатели знаем, собаку съели еще года два назад. Указатель есть ничто иное как переменная хранящая адрес. В С/C++ языке это пишется немного с подковыркой. Другое дело ссылки... хотя так же не лишены тонкостей. Повторюсь, проблема была в том, что указатель и его тип, никак не влияет на значение на которое он указывает. То есть, приведение (реинтерпретация) указателя не приведет к тому, что в рантайме все будет ок. Может я просто не так выразил задачу. Решение у самого вертится на языке но не могу сообразить.

До этого, я думал вообще указывать размер в виде void* и подставлять sizeof или контстанты определенные на стадии компиляции. В самом объекте просто делать выбрку типа по размеру соответствующему константам. Это позволило бы делать "указатель на что угодно". А уже при присваивании значения, делать временную переменную нужного типа и писать по указателю значение соответствующего типа. По сути, все упирается в число байт расположенных в блоке памяти на который указывает указатель. Их всего 5, uchar, ushort, ulong, ulonglong, uint. Сделать 5 дефайнов размера + флаг int или один из ...
ваще шаблоны решают все в данном случае. Разве что эстетика будет хромать, писать в одном модуле.


Volatile, параметризация в вашем примере позволяет работать только с типами данных. А что если длина данного 45 байт?

Это сообщение отредактировал(а) BearFear - 10.11.2012, 13:45

BearFear, вам нужно подождать feodorv, это человек не только с высочайшей квалификацией, но и обладающий дьявольским (или ангельским) терпением, и умением объяснять. (Если он пожелает конечно)
Я не могу, соори.
могу сорваться.
  


Это сообщение отредактировал(а) volatile - 10.11.2012, 14:34

Эт плохо. Терпение наше всё.

volatile,   Спасибо за высокую оценку проделываемого труда. И попробую вмешаться.

Не понятно что хочется и зачем хочется. 

Если хочется хранить указатель на некоторую память (которая может представлять собой и символ, и набор символов, и целочисленное значение различного диапазона, да что там стесняться, и  число с плавающей точкой), то нужно заводить неименованный указатель void*. Чтобы всё-таки помнить, на память какого типа указывает этот самый указатель, придётся отдельно хранить тип этого указателя. В C это выглядело бы так:

Тогда взятие целочисленного значения по этому самодельному указателю выглядело бы следующим образом:

Но вот зачем эту нужно? Что это решает? 

Экономите в одном месте, теряете в другом. Приходится хранить и указатель, и тип указателя. В производительности тоже потери: свичи и выборка невыровненных данных будут съедать время. И потери, судя по всему, будут значительно больше и ощутимее. Но хозяин барин.

ЗЫ Для C++, как смутно припоминается, было какое-то элегантное решение вопроса, но увы, его не помню.


BearFear, простите за эту правду, но очень много неточностей в Ваших высказываниях. Не буду касаться бесконечно возникающих ниоткуда "произвольных 4-х байт". Рассмотрим Ваши последние утверждения:


Это не так. Действительно, значением указателя является некий адрес в адресном пространстве процесса. Но указатель к этому адресу не сводится никоим образом. Указатель - это тип переменной в языке (для этого типа переменных, который хранит адрес, даже было придумано специальное название - указатель, а то можно было бы просто говорить - адрес такой-то, адрес сякой-то). Указатель имеет имя - имя типа переменной, на которую указывает (так и говорят - именованный указатель). Указатели с разными именами не равнозначны: int* != char*, даже unsigned char* != char*, хотя казалось бы. Итого, у нас уже три свойства указателя:

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

Поэтому утверждение 

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

Это сообщение отредактировал(а) feodorv - 10.11.2012, 21:07

Вечно вы любите человеки не к селу вставлять перлы о знаниях и тем самым повышать свою самооценку. Я могу вам кинуть массу асмокода с расписанием комментов. Но зачем это делать ЗДЕСЬ?  4 байта читаются из недопустимой области, следовательно данные произвольные. О боже, неужели "проверочный" код настолько невидимый, что его никто не читал?  Указатель указателем, а тип оригинальных данных на которые указатель указывает может иметь другую длину, отличимую от типа указателя. В лучшем случае данные "недочитаются" в худшем "перечитаются". И reinerpret как и приведение в Си может все поломать.    подвох в классе заключался в первую очередь в контексте времени.

Задача класса получить на входе указатель на любой тип, а на выходе вернуть указатель на unsigned long long. Но доступ по такому указателю само собой же недопустим! Как бы мы внутри класса это не выворачивали бы!!! В этом заключался вопрос. Как это обойти? Как сделать, переделать... я мог вопрос поставить неправильно, в виду этого не матерюсь (еще бы матерился бы) на ваше непонимание.

Блин, если бы я не понимал что есть "указатель"... я бы написал бы корявый код с ошибками и у меня даже не возник бы сей вопрос!

И "о боже"x2! Об определителе типа, представьте, догадался уже давно и кажется где то выше писал про это 
цЫтирую


Это сообщение отредактировал(а) BearFear - 10.11.2012, 19:12

Решением для такого класса могло бы стать:
- передача указателя на любой тип
- запись значения по указателю в посредника
- по деструктору класса запись обратно по полученному указателю

Но это пипец. Так недопустимо. Хотя, если ответственность за объекты очереди назначить на какой нибудь класс, то все могло бы получиться.
В общем всем спасибо ребят, всем ставлю плюсы (если не получится поставить, запишу на бумажке, поставлю после соответствующего числа сообщений моих). Задачу можно назвать решенной. Всем спасибо 

так volatile показал же как примерно это делается. Все сводится к 

в итоге получаются детали такой, например, реализации:
http://insidecpp.ru/patterns/variant/

да, только с типами. впрочем С++ язык строго типизированный, так что "не типов" не бывает, пример volatile покрывает все случаи. и для длины в 45, 2045, 200045 будет работать

Это сообщение отредактировал(а) baldina - 10.11.2012, 19:51

baldina, блин, игра слов получилась. С типами "данных" (а например не размеров).