Статический поиск типа по адресу - C/C++

Вот есть такой шаблон, который отображает каждый тип в уникальное число (адрес статической переменной)


template <class T> 
struct TypeToX
{
  static char c;
};

А как сделать обратное отображение? Что-то типа вроде

template <char *pc>
struct XToType
{
  typedef <???> Type;
};

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

Иными словами ты хочешь использовать информацию, получаемую в run-time, на этапе компиляции. Тебе не кажется, что, ээээ, причинно-следственная связь несколько нарушена?

Напиши подробней, чего хочешь

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

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

B>Иными словами ты хочешь использовать информацию, получаемую в run-time, на этапе компиляции. Тебе не кажется, что, ээээ, причинно-следственная связь несколько нарушена?
B> ;)

почему же в ран-тайм? адрес статического объекта известен уже на этапе компиляции.

B>>Иными словами ты хочешь использовать информацию, получаемую в run-time, на этапе компиляции. Тебе не кажется, что, ээээ, причинно-следственная связь несколько нарушена?
B>>

J>почему же в ран-тайм? адрес статического объекта известен уже на этапе компиляции.

Адрес объекта с external linkage известен на этапе компиляции... точнее, шаблон может быть параметризирован таким адресом. Насчет статического объекта я не припомню такого, по крайней мере comeau ругается на попытку параметризировать шаблон адресом статической переменной. С extern это вполне проходит. Впрочем, мне тоже непонятно, почему компилятор не в состоянии определить адрес статической переменной на этапе компиляции.

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

AS>Адрес объекта с external linkage известен на этапе компиляции... точнее, шаблон может быть параметризирован таким адресом. Насчет статического объекта я не припомню такого, по крайней мере comeau ругается на попытку параметризировать шаблон адресом статической переменной. С extern это вполне проходит. Впрочем, мне тоже непонятно, почему компилятор не в состоянии определить адрес статической переменной на этапе компиляции.

Статический член имеет external linkage — Jazzer абсолютно прав.
Comeau конечно же компилит во это:

struct test
{
   static int n_;
};

int test::n_ = 0;

template<int* p>
int fn()
{
   return *p;
}

int main()
{
   int a = fn<&test::n_>();

   return 0;
}

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

B>>>Иными словами ты хочешь использовать информацию, получаемую в run-time, на этапе компиляции. Тебе не кажется, что, ээээ, причинно-следственная связь несколько нарушена?
B>>> ;)

J>>почему же в ран-тайм? адрес статического объекта известен уже на этапе компиляции.

AS>Адрес объекта с external linkage известен на этапе компиляции... точнее, шаблон может быть параметризирован таким адресом. Насчет статического объекта я не припомню такого, по крайней мере comeau ругается на попытку параметризировать шаблон адресом статической переменной. С extern это вполне проходит. Впрочем, мне тоже непонятно, почему компилятор не в состоянии определить адрес статической переменной на этапе компиляции.

9.4.2/6
Static data members of a class in namespace scope have external linkage (3.5).

AS>>Адрес объекта с external linkage известен на этапе компиляции... точнее, шаблон может быть параметризирован таким адресом. Насчет статического объекта я не припомню такого, по крайней мере comeau ругается на попытку параметризировать шаблон адресом статической переменной. С extern это вполне проходит. Впрочем, мне тоже непонятно, почему компилятор не в состоянии определить адрес статической переменной на этапе компиляции.

B>Статический член имеет external linkage — Jazzer абсолютно прав.

Извиняюсь, но где речь шла про member? Говорилось о статическом объекте. Это немного разные вещи.

ja>>адрес статического объекта

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

AS>>>Адрес объекта с external linkage известен на этапе компиляции... точнее, шаблон может быть параметризирован таким адресом. Насчет статического объекта я не припомню такого, по крайней мере comeau ругается на попытку параметризировать шаблон адресом статической переменной. С extern это вполне проходит. Впрочем, мне тоже непонятно, почему компилятор не в состоянии определить адрес статической переменной на этапе компиляции.

B>>Статический член имеет external linkage — Jazzer абсолютно прав.

AS>Извиняюсь, но где речь шла про member? Говорилось о статическом объекте. Это немного разные вещи.

речь про member шла в начальном посте.
я же в контексте пишу :)

А как же все-таки сделать обратное отображение? Это ведь возможно в С++?

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

_W>А как сделать обратное отображение? Что-то типа вроде
_W>

_W>template <char *pc>
_W>struct XToType
_W>{
_W>  typedef <???> Type;
_W>};
_W>

А что тебе даст такое отображение? ИМХО копаешь не туда. Все равно это будет статический тип этапа компиляции. Без преимуществ

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

_W>template <class T> 
_W>struct TypeToX
_W>{
_W>  static char c;
_W>};

_W>А как сделать обратное отображение? Что-то типа вроде

_W>template <char *pc>
_W>struct XToType
_W>{
_W>  typedef <???> Type;
_W>};

А нафига?
Посмотри, как ты это будешь использовать:

XToType< &TypeToX<some_type>::c >::Type

Указывать произвольный char* нельзя — только адрес члена TypeToX.
Так зачем все эти танцы с бубном? some_type уже содержится в выражении.

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

Может специализировать XToType для всех типов, которые у тебя используются. А по умолчанию сделать шаблон, который бы генерил ошибку при инстациировании (Как у Александреску)?

... << RSDN@Home 1.1.0 stable >>

Я все — таки хотел сделать макрос typeof(). Проблема была только в этом. Я, кажется, понял свою ошибку.
Если есть шаблон вроде template <char *c> struct XToType { по адресу выясняем тип } и в качестве параметра подтавляем адрес статической переменной, то ничего не выйдет. Ибо тип должен определится во время компиляции, а значение указателя становится только во время линкования [offtop](как это по-русски? редактирование связей?)[/offtop].

Так что прервый пост от господина Bell был отчасти верен.
Невозможно в compile-time выяснить то, что становится известно только в link-time. У меня хромает причинно-следсвенноя связь.

Вопрос: когда в C++ появится typeof ?

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

_W>Я все — таки хотел сделать макрос typeof(). Проблема была только в этом. Я, кажется, понял свою ошибку.
_W>Если есть шаблон вроде template <char *c> struct XToType { по адресу выясняем тип } и в качестве параметра подтавляем адрес статической переменной, то ничего не выйдет. Ибо тип должен определится во время компиляции, а значение указателя становится только во время линкования [offtop](как это по-русски? редактирование связей?)[/offtop].

_W>Так что прервый пост от господина Bell был отчасти верен.
_W>Невозможно в compile-time выяснить то, что становится известно только в link-time. У меня хромает причинно-следсвенноя связь.

_W>Вопрос: когда в C++ появится typeof ?

const type_info* typeid(typename | instance)
const char* type_info::name() const

тебя не устраивают?

_Winnie wrote:

> Вот есть такой шаблон, который отображает каждый тип в уникальное число (адрес статической переменной)
[]

> А как сделать обратное отображение?

[]

Можно попробовать заюзать blessed visitor pattern:

////////////////////////////////////////////////////////////////////////////////

#include <typeinfo>
#include <iostream>
#include <map>
#include <memory>

#include <boost/mpl/identity.hpp>

////////////////////////////////////////////////////////////////////////////////

template<class T>
struct type_id_generator
{
     static char const unique_address;
};

template<class T> char const type_id_generator<T>::unique_address(0);

template<class T>
size_t type_id()
{
     return reinterpret_cast<size_t>(&type_id_generator<T>::unique_address);
}

////////////////////////////////////////////////////////////////////////////////

struct type_visitor
{
     template<class T>
     void visit(boost::mpl::identity<T>)
     {
         std::cout << __FUNCSIG__ << '\n';
     }
};

struct type_reflector
{
     virtual void accept(type_visitor&) const = 0;
};

////////////////////////////////////////////////////////////////////////////////

template<class T>
struct type_reflector_impl : type_reflector
{
     virtual void accept(type_visitor& v) const
     {
         v.visit(boost::mpl::identity<T>());
     }
};

typedef std::map<size_t, type_reflector const*> registered_types_t;
registered_types_t registered_types;

template<class T>
struct register_type
{
     typedef type_reflector_impl<T> reflector;
     register_type()
         : reflector_(new reflector)
     {
         registered_types.insert(
             registered_types_t::value_type(
                   type_id<T>()
                 , reflector_.get()
                 )
             );
     }

     std::auto_ptr<reflector const> reflector_;
};

////////////////////////////////////////////////////////////////////////////////

namespace {

register_type<void> register_void__;
register_type<bool> register_bool__;
register_type<int> register_int__;

struct whatever;
register_type<whatever> register_whatever__;

}

////////////////////////////////////////////////////////////////////////////////

void visit_type(size_t id)
{
     registered_types_t::const_iterator i(registered_types.find(id));
     if(i != registered_types.end())
     {
         type_visitor v;
         i->second->accept(v);
     }
     else
     {
         std::cout << "unknown type_id\n";
     }
}

////////////////////////////////////////////////////////////////////////////////

int main()
{
     visit_type(type_id<void>());
     visit_type(type_id<bool>());
     visit_type(type_id<int>());
     visit_type(type_id<double>());
     visit_type(type_id<whatever>());
     return 0;
}

////////////////////////////////////////////////////////////////////////////////

--
Maxim Egorushkin
MetaCommunications Engineering
http://www.meta-comm.com/engineering/

Posted via RSDN NNTP Server 1.8 beta

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

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

_W>>Вопрос: когда в C++ появится typeof ?
К>

К>const type_info* typeid(typename | instance)
К>const char* type_info::name() const
К>

К>тебя не устраивают?

Простейший пример, чего хотелось бы делать.

template <class Ptr>
void fun(Ptr ptr)
 {
  ...
  
  typeof(*ptr) object=*ptr;
  
  ...
 }

... << RSDN@Home 1.1.0 stable >>

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

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

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

B>>Иными словами ты хочешь использовать информацию, получаемую в run-time, на этапе компиляции. Тебе не кажется, что, ээээ, причинно-следственная связь несколько нарушена?
B>>

J>почему же в ран-тайм? адрес статического объекта известен уже на этапе компиляции.

Не совсем. Только как некий символ. А реальное значение он получит окончательно, скорее всего, только после загрузки приложения.

... << RSDN@Home 1.1.0 stable >>

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

Ш>Простейший пример, чего хотелось бы делать.

Ш>template <class Ptr>
Ш>void fun(Ptr ptr)
Ш> {
Ш>  ...
  
Ш>  typeof(*ptr) object=*ptr;
  
Ш>  ...
Ш> }

Жалко ещё, что нельзя ещё вот так делать: my_vector.iterator v = my_vector.begin();
Потому что тогда с лёгкостью можно было бы определить макрос typeof

template<class T>
struct typeview_t { typedef T type; };

template<class T>
typeview_t<T> typeview(T t) { return typeview_t<T>(); }

#define typeof(t) typeview(t).type

Кстати, а есть какие-то смысловые преграды к этому, или просто не удосужились?

... << RSDN@Home 1.1.2 stable >>

От:	_Winnie	C++.freerun
Дата:	13.02.04 07:46
Оценка:

	От:	Bell
	Дата:	13.02.04 08:13
	Оценка:

	От:	Аноним
	Дата:	13.02.04 08:15
	Оценка:

От:	jazzer	Skype: enerjazzer
Дата:	13.02.04 09:04
Оценка:	7 (1)

От:	Andrew S	http://alchemy-lab.com
Дата:	13.02.04 09:16
Оценка:

	От:	Шахтер
	Дата:	14.02.04 02:03
	Оценка:

	От:	Шахтер
	Дата:	14.02.04 02:03
	Оценка:

	От:	Кодт
	Дата:	14.02.04 09:29
	Оценка: