- Boost-users - lists.boost.org

any_ptr
by cl_corba_at 27 May '02

27 May '02

Hi all! any_ptr was a typo in an older documentation, but this leads me to this question: any stores the type values in the template class holder, which is derived from placeholder to provide an uniform interface. This approach works fine for new classes where the data representation is done inside the any class, but for legacy code I would also like to have an any_ptr, which uses a holder that POINTS to a variable rather than containing it. With this I could extend existing classes with algorithms depending on any. Has any_ptr considered in the past and if yes, what have been the reasons to decide against it? Thanks in advance, CL

1 0

BGL, 6 degrees of Kevin Bacon and MSVC 6 compile error
by a_schweitzer 25 May '02

25 May '02

Hello, I am trying to build the "6 degrees of kevin bacon" example of the BGL in MSVC 6. When I do I get an "internal compile error". Does anyone know a fix/work-around? The compilation gets to this line (about #73): typedef adjacency_list < vecS, vecS, undirectedS, property<vertex_name_t,std::string >, property < edge_name_t,std::string > > Graph; Graph g; If Graph g is declared I get the following ugly error: d:\program files\microsoft visual studio\vc98\include\xmemory(59) : fatal error C1001: INTERNAL COMPILER ERROR (compiler file 'msc1.cpp', line 1794) Please choose the Technical Support command on the Visual C++ Help menu, or open the Technical Support help file for more information Note that if I change the std::string in vertex_name property to an int the compilation proceeds. Thanks for any help Andy Schweitzer

3 3

RE: [Boost-Users] boost::lexical_cast string to string problem - New proposition available
by Terje Slettebø 25 May '02

25 May '02

>--- In Boost-Users@y..., Tom Matelich <tmatelich@z...> wrote: > I and many others have requested fixes for this for a very long time. > Basically, it involves creating class templates to do the actual conversion. > It's not the most complicated system, just nobody has done it yet. If you > search the boost list archives, you'll see a lot of mail about this. There > is no quick solution to your problem though. I've searched the archive, now, and see that there's been quite a few propositions for changes, but apparently none of them have ended up in the lexical_cast implementation. There's also a couple of propositions, here (http://groups.yahoo.com/group/boost/files/lexical_cast_propositions/) Some of the proposed changes are: - wlexical_cast - A version that can use wide characters - basic_lexical_cast - A version that takes the interpreter (stringstream) as a parameter, to support things like changing locale - Being able to set number base (dec, oct or hex). This would be implicitly possible using basic_lexical_cast - Being able to set precision for numerical conversions. This may also be done with basic_lexical_cast - Checking for change of sign, when using unsigned numbers. This is addressed using an integer adapter, in the above lexical_cast_propositions One problem with doing these changes, after having talked with Kevlin Henney a while ago (without knowing it had been already proposed, I proposed an extra parameter, for setting the number base). is that he prefers to not have extra parameters in the interface, as it then will no longer look like a cast, and it may be less generic, depending on the way it's done. For example, a base-setting argument wouldn't make much sense if you converted from floating point to string. In any case, I have actually just now made a version of lexical_cast, that fixes the problem pointed out by OP, here, and I've made it available in the Boost files section (http://groups.yahoo.com/group/boost/files/lexical_cast_proposition/) I've also put a unit test for it, there. Feedback is welcome. It doesn't change the interface in any way, so it should be ok. The new version supports conversion between string and char, including char containing whitespace, and when the string is empty, or containing only whitespace. If the source or destination (or both) is basic_string or char/wchar_t, it will set the interpreter to use the char type used, so it implicitely supports wide characters. Wide character support requires partial specialisation if one of the operands is not either basic_string or char/wchar_t. In the case where the source is basic_string, it also uses pass by const reference, for efficiency. It's tested on Intel C++ 6.0, MSVC 6.0 and BCC 5.6. Regards, Terje

2 4

boost::shared_ptr and atomic_count_linux.hpp
by Jerry Napoli 24 May '02

24 May '02

Hi, I'm using boost version 1.27.0 on an x86 linux platform and have just upgraded my kernel to 2.4.18. After the upgrade, boost::shared_ptr fails to compile because functions such as "atomic_inc_and_test", "atomic_dec_and_test", etc.. which were previously defined in "atomic.h" are no longer defined there. I can get around the problem by using an older "atomic.h" or by using pthreads, but I was wondering why those functions were removed from the header. Any ideas? Thanks, Jerry jnapoli(a)iteamsolutions.com [Non-text portions of this message have been removed]

3 2

Seeking example of using quaternion class
by yg-boost-users＠m.gmane.org 23 May '02

23 May '02

Hi, I am trying to use the quaternion class for 3d rotation and wonder if anyone has a sample of how to do this. If we have quaterion q1 and want to rotate by q2 the expression, I believe, is result = q2 * q1 * inv( q2 ). Is the correct syntax using ::boost::quaternion operators result = q2 *= q1 /= q2 ?? Do the quats need to be "unit quaternions" before these operations? What is the best way to create an unit quat? thanks john ware

1 0

Re: [boost] boost::lexical_cast string to string problem - New proposition available
by Terje Slettebø 23 May '02

23 May '02

(This posting is also sent to the Boost list) Following a suggestion at the Boost User's list, I've updated the lexical_cast version in the Boost files section (http://groups.yahoo.com/group/boost/files/lexical_cast_proposition/) to use implicit conversion, where possible. This means it uses the fastest and most accurate conversion available, and only resorts to using stringstream when it has to. It uses boost::is_convertible for this. Even if that may not work on all compilers, if it doesn't work, it will just resort to using stringstream. However, this does mean that the semantics is changed slightly. In the cases where an implicit conversion exists, it may give a different result than if not, in the case of char/wchar_t. Without implict conversion, you get 1 -> '1'. With implicit conversion, you get 1 -> 1 (ASCII 1). As far as I can tell, this only affects conversions between char/wchar_t and other types, though. If this is a problem, please let me know, and I can change it to make an exception for char/wchar_t. Another thing is that there's now an option to configure the interpreter stream, as well. This is done _without_ changing the interface of lexical_cast. Instead, it's done in a trait-like fashion, by making the interpreter object available through an associated component, which is used by lexical_cast. The reason this is optional, is that when enabled, it relies on having a static stringstream object. This has two effects (unless implicit conversion is used): - It may well make lexical_cast faster, as it avoids the creation and destruction of a stringstream object, each time it's called. - Unless stringstream is reentrant, which is probably not the case, it means that when the option is enabled, lexical_cast is not thread safe. Therefore, this option is off by default, which gives the usual behaviour - stringstream objects are created at the function call. If the option is used, it lets you configure the stream used, in any way. This way, one can implement all the features of the "wish list" in the previous posting in this thread, such as. - wlexical_cast - A version that can use wide characters - This is already handled by the previous version. - basic_lexical_cast - A version that takes the interpreter (stringstream) as a parameter, to support things like changing locale - Being able to set number base (dec, oct or hex). This would be implicitly possible using basic_lexical_cast - Being able to set precision for numerical conversions. This may also be done with basic_lexical_cast - These are all handled now. - Checking for change of sign, when using unsigned numbers. This is addressed using an integer adapter, in the other lexical_cast_propositions The lack of formatting is what is largely the reason I haven't used lexical_cast much. With control over the formatting, it may be more widely applicable. Since the stream may be different, for different conversions (char, wchar_t or other character type), one need to supply the source and destination types, when configuring the stream. Here's an example of its use. --- Start --- #define BOOST_LEXICAL_CAST_STREAM // Enables stream configuration #include <iostream> #include <iomanip> #include <string> #include "lexical_cast.hpp" int main() { boost::lexical_cast_stream<std::string,double>::stream() << std::setprecision(0); std::cout << boost::lexical_cast<std::string>(1.0/3.0) << '\n'; boost::lexical_cast_stream<std::string,double>::stream() << std::setprecision(10); std::cout << boost::lexical_cast<std::string>(1.0/3.0) << '\n'; boost::lexical_cast_stream<std::string,int>::stream() << std::setbase(16); std::cout << boost::lexical_cast<std::string>(0x1234) << '\n'; } --- End --- This prints. 0.333333 0.3333333333 1234 Any suggestions for changes or additions, including interface changes, is welcome. I realise that the way to change the stream formatting is rather long-winded, but I haven't found a shorter way to do it (the name has to be different from lexical_cast, too). Suggestions for alternative ways are welcome. I've not found a way to make the stream configurable, and yet avoid a static stringstream. If the stringstream is created when lexical_cast is called, it means any configuration information is lost. Even if it copied the state from another stream, that other stream would have to exist, such as being static, so that would only move it. Despite the extra code, to handle implicit conversions, where available, by examining the resulting assembly output (from Intel C++), it's in fact able to optimise _all_ of it away, producing indentical code as if built in conversions were used directly. Here's an example. int n; double d=1.23; int main() { n=boost::lexical_cast<int>(d); } 00401084 fld qword ptr [d (00427db0)] 0040108A fstp qword ptr [esp+8] 0040108E mov esi,dword ptr [esp+8] 00401092 mov edx,dword ptr [esp+0Ch] 00401096 mov ecx,edx 00401098 shr ecx,14h 0040109B and ecx,7FFh 004010A1 cmp ecx,3FEh 004010A7 jle main+52h (004010c6) 004010A9 mov eax,edx 004010AB neg ecx 004010AD add ecx,41Eh 004010B3 shld eax,esi,0Bh 004010B7 or eax,80000000h 004010BC shr eax,cl 004010BE test edx,edx 004010C0 jge main+54h (004010c8) 004010C2 neg eax 004010C4 jmp main+54h (004010c8) 004010C6 xor eax,eax 004010C8 mov [n (0042bef8)],eax int n; double d=1.23; int main() { n=d; } 0041AFF0 fld qword ptr [d (00427db0)] 0041AFF6 fstp qword ptr [esp+8] 0041AFFA mov esi,dword ptr [esp+8] 0041AFFE mov edx,dword ptr [esp+0Ch] 0041B002 mov ecx,edx 0041B004 shr ecx,14h 0041B007 and ecx,7FFh 0041B00D cmp ecx,3FEh 0041B013 jle main+1A022h (0041b032) 0041B015 mov eax,edx 0041B017 neg ecx 0041B019 add ecx,41Eh 0041B01F shld eax,esi,0Bh 0041B023 or eax,80000000h 0041B028 shr eax,cl 0041B02A test edx,edx 0041B02C jge main+1A024h (0041b034) 0041B02E neg eax 0041B030 jmp main+1A024h (0041b034) 0041B032 xor eax,eax 0041B034 mov [n (0042b84c)],eax The code is identical. :) Thus, you get a generic conversion, with the speed and accuracy of built in conversions, where that is possible. It's a good thing I have a unit test, so I could do regression testing, to make sure I haven't broken anything. Regards, Terje

1 0

Problems with read_graphviz()
by Paolo Fosser 23 May '02

23 May '02

Hi to everybody, first of all I beg pardon if my English isn't much good: I'm Italian! I'm working with gcc 3.0.1 on a Linux Mandrake sys with kernel 2.4.8. The problem I'm having is that the second call of read_graphviz() in the same program causes a Segmentation fault. What can I do? Thank you in advance, Paolo PS Advices about the language are welcome too ;)

1 0

Boost thread examples
by imi123_1999 22 May '02

22 May '02

Is there any other site from where we can get the example programs illustrating the usage of boost libraries especially threads. I found the example programs present on boost web site not sufficient to fully understand the concepts. So please tell me from where i can get the further information regarding the usage of boost thread library.

3 2

Thread destruction in boost
by giltayar 21 May '02

21 May '02

>From boost:thread documentation, it is clear that deleting a thread does not kill the thread. I very much approve of this. killing a thread is a very "strong" operation. The problem is that there is now no connection between the system thread and the object itself, which (debatably) kills the idiom in C++ connection the object and the resource (I never remember its name). Was the idea of doing a "join()" in the dtor brought up? I.e., the dtor waiting for the thread to finish? I used it in my library, and it was _very_ effective, as I could _know_ that the thread and the object have parallel lifetimes, and it also helped me because it prevented many "thread-leakage" problems. Gil P.S. The question was - "Was the idea of doing a join() in the dtor ever brought up?"

3 5

RE: [Boost-Users] boost::lexical_cast string to string problem
by Tom Matelich 21 May '02

21 May '02

I and many others have requested fixes for this for a very long time. Basically, it involves creating class templates to do the actual conversion. It's not the most complicated system, just nobody has done it yet. If you search the boost list archives, you'll see a lot of mail about this. There is no quick solution to your problem though. -----Original Message----- From: Jason Fischl [mailto:yg-boost-users@m.gmane.org] Sent: Monday, May 20, 2002 5:21 PM To: boost-users(a)yahoogroups.com Subject: [Boost-Users] boost::lexical_cast string to string problem I'm seeing a problem with lexical_cast. The following code when trying to convert from string to string fails when passed an empty string. The library code that is doing this lexical_cast does not and can not know that the input and output types are the same. I believe that this code should not throw. #include <iostream> #include <boost/lexical_cast.hpp> main() { std::string input(""); try { boost::lexical_cast<std::string>(input); } catch (boost::bad_lexical_cast& e) { std::cout << "Failed" << std::endl; } } Info: <http://www.boost.org> Wiki: <http://www.crystalclearsoftware.com/cgi-bin/boost_wiki/wiki.pl> Unsubscribe: <mailto:boost-users-unsubscribe@yahoogroups.com> Your use of Yahoo! Groups is subject to http://docs.yahoo.com/info/terms/

1 0