Ok, someone copied the old version of the file to another location which was also in the include path and was evaluated before the modified file... Thanks anyway for spending your time to read this post. Best Regards, Ovanes On Tue, May 16, 2006 12:14, Ovanes Markarian said:
I have some strange behavior on RH Enterprise Linux 2.6.9-34 with gcc (GCC) 3.2.3 version and boost::shared_ptr template.
The thning which drives me crazy compiles for one library without any problems and for the other library it can't compile one of my typedefs.
Maybe some of you have had the similar problem before. Here some snippet:
I have some really simple type traits definitions:
template <class T> struct traits_internal { typedef T type; typedef T& ref; typedef T* ptr; typedef const T* const_ptr; typedef const T& const_ref; typedef const T const_type; };
template <class T> struct traits : traits_internal<T> {};
template <class T> struct traits<T*> : traits_internal<T> {};
template <class T> struct traits<T&> : traits_internal<T> {};
then I have a factory class, which can creates an empty class instance, copies the instance from another instance or copies it from the underlying POD (raw data).
template<class Type_, class Raw_, class MemMan_> struct Creator { public: typedef typename msg_factory::traits<Type_>::type val_type; typedef typename msg_factory::traits<Type_ >::const_type const_type; typedef typename msg_factory::traits<Raw_>::type raw_type; typedef typename msg_factory::traits<MemMan_>::type man_type; typedef boost::shared_ptr<val_type> smart_ptr; typedef boost::shared_ptr<const_type> const_smart_ptr;
private: /** * a union container which decides which member to use, POD or Class * used to save space required by 2 pointers */ typedef msg_factory::PointerContainer<val_type, raw_type> ptr_container; typedef Creator<Type_, Raw_, MemMan_> my_type;
public: inline explicit Creator(man_type* m = NULL) : memMan(m), copy_from(static_cast<val_type*>(NULL)){}
inline explicit Creator(const raw_type* s, man_type* m = NULL) : memMan(m), copy_from(s) {}
inline explicit Creator(const val_type& t, man_type* m = NULL) : memMan(m), copy_from(&t) {}
inline ~Creator(){}
inline operator smart_ptr()const { return smart_ptr((copy_from.is_valid()?(copy_from.first()?(new val_type(*copy_from.first(), memMan)):(new val_type(copy_from.second(), memMan))):(new val_type(memMan)))); }
private: inline Creator(const my_type&) {}
inline my_type& operator=(const my_type&) {return *this;}
template <class OtherType_, class OtherRaw_, class OtherMemMan_> inline Creator(const Creator<OtherType_, OtherRaw_, OtherMemMan_>&) {}
template <class OtherType_, class OtherRaw_, class OtherMemMan_> inline Creator& operator =(const Creator<OtherType_, OtherRaw_, OtherMemMan_>&) {return *this;}
man_type* memMan; ptr_container copy_from; };
class ClassB : public ClassA { public: typedef Creator<ClassB, POD_B, ClassA> heap_instance; typedef heap_instance::smart_ptr smart_ptr; -->typedef heap_instance::const_smart_ptr const_smart_ptr;
private: friend class Creator<ClassB, POD_B, ClassA>;
explicit ClassB(ClassA *pcDataManager = NULL);
explicit ClassB(const POD_B *ptCopyFromPOD, ClassA *pcDataManager = NULL);
explicit ClassB(const ClassB ©FromOtherClassB, ClassA *pcDataManager = NULL);
//some class data follows }
In this line compiler raises the error: ISO C++ forbids declaration of `const_smart_ptr' with no type /some/path/here/fname:lineno: cannot declare member ` Creator<ClassB, POD_B, ClassA>::const_smart_ptr' within `ClassB' /some/path/here/fname:lineno: syntax error before `;' token *** Error code 1
Somehow it does not know the type, even if I try in Creator to change the typedef from:
typedef boost::shared_ptr<const_type> const_smart_ptr; to typedef boost::shared_ptr<val_type> const_smart_ptr;
I still get an error at this line. And the most weired thing is, why it can compile a line before?! Where typedef boost::shared_ptr<val_type> smart_ptr; is used as forward declaration?
I also tried in the Creator to change typedef boost::shared_ptr<const_type> const_smart_ptr; to typedef smart_ptr const_smart_ptr;
And compiler was able to compile it... Do you have any suggestions? I am using boost 1.33_0
Many thanks,
Ovanes Markarian