October 2005 - Boost-users - lists.preview.boost.org

[serialization]save object to a previous version
by Li Lirong 14 Oct '05

14 Oct '05

Hi, As I understand, the class versioning system permits a program to load archives created by previous versions of the program. However, is it possible to explicitly save some of objects to a previous version so that previous versions of the program can read the saved archive? Regards, Lirong

2 1

Re: [Boost-users] Report from Mont Tremblant C++ Committee meeting
by Jeff Garland 14 Oct '05

14 Oct '05

On Thu, 13 Oct 2005 12:52:30 -0400, Daryle Walker wrote > On 10/12/05 5:38 AM, "John Maddock" <john(a)johnmaddock.co.uk> wrote: > > [SNIP] > > And for those who think that in-place modification is the way to go: you do > > realise that it's often *slower* than building a new string don't you? > > And what if the string uses more than half of the available space? > (I'm not advocating in-place modification, but just mentioning that > "return a copy" has its flaws too.) That's why the library supports both interfaces -- essentially letting the user decide. Jeff

1 0

Is there a boost way to avoid this macro usage?
by Rush Manbert 13 Oct '05

13 Oct '05

Hi all, I posted this question to comp.lang.c++.moderated and got a single reply that basically said "it looks like you need to use macros", but I thought I would ask the same question here, just in case you MPL folks have some tricks up your boost library sleeves. Basically, I need to make an enum and a static array of structures from one data set and I only know one way to do it, and it involves an amount of "trickiness" that some find disturbing. The original post: In the code shown below, the CODE_TABLE macro is used to insert a sequence of CODE(codeValue) macros. By changing the definition of CODE(codeValue) right before each usage of CODE_TABLE, I can create an enumeration of codeValues, then use the same CODE_TABLE definition to create a static lookup table that can be used to find information about a codeValue, given its numeric value. In this case, I am finding the name of the enumerated value. In the real application, there are a number of other fields available. (As you can probably tell, I have written a lot of C code in my time.) IMHO, the benefit of this technique is that you only maintain CODE_TABLE. All of the required code bits are generated from it. The downside is that Macros are Evil, the macro-that-is-a-list-of-macros is confusing, and you need to carefully redefine CODE(codeValue) in the proper locations. Additionally, the real application will have multiple classes that each define their own CODE_TABLE contents, so making it all work correctly is a little tricky. My question is this: Is there any method available in C++ that can let me do away with the macros while preserving the nice quality that only one data structure needs to be maintained? Something sophisticated and tricky with templates perhaps? I expect that the fact that I stringize the enum name when creating the lookup table makes a macro the only choice. But, since that is only one component in each lookup table entry in the real code, I might be willing to give it up in order to lose the macros. Here is the code example. Contents of foo.h: ----------------- #define CODE_TABLE \ CODE(FooCodeA) \ CODE(FooCodeB) #define CODE(codeValue) codeValue, class foo { public: typedef enum { // Here comes the first use of CODE_TABLE CODE_TABLE } CodesT; foo (CodesT theCode) : m_code (theCode) {} const char *lookup (void) const; const int getCode (void) const {return m_code;} private: CodesT m_code; typedef struct { CodesT theCode; const char *pTheCodeAsString; } CodeLookupTableT; static CodeLookupTableT m_lookupTable[]; }; Contents of foo.cpp: ------------------- #include "foo.h" // Now we redefine CODE so that we can initialize the // static lookup table #undef CODE #define CODE(codeValue) {codeValue, #codeValue}, foo::CodeTableLookupT foo::m_lookupTable[] = { CODE_TABLE }; // The lookup method that finds the string description // from the numeric code const char *foo::lookup (void) const { for (int i = 0; i < (sizeof m_lookupTable)/(sizeof m_lookupTable[0]); ++i) { if (m_lookupTable[i].theCode == m_code) return m_lookupTable[i].pTheCodeAsString; } return "Unknown code value"; } contents of main.cpp: ------------------- #include <iostream> #include "foo.h" using namespace std; int main (int argc, char * const argv[]) { foo myFoo (foo::FooCodeB); cout << "myFoo with code number....: " << myFoo.getCode() << endl << " looks up the code name as: " << myFoo.lookup() << endl; return 0; } Output from running the program: ------------------------------- myFoo with code number....: 1 looks up the code name as: FooCodeB Thanks, Rush

2 5

Hash Map
by Piyush Kapadia 13 Oct '05

13 Oct '05

Is there any faster version of std::map ? I heard there is a faster hashmap implementation, does boost have anything in this regard ?

4 3

[shared_ptr] Two basic questions
by Matthias Kaeppler 13 Oct '05

13 Oct '05

Hello, I have two questions regarding the proper use of boost::shared_ptr; both actually arose after reading http://www.boost.org/libs/smart_ptr/example/shared_ptr_example.cpp 1. In order for some class to work with std::set, you have to supply an operator with "less than" semantics. Why are you instead declaring a "greater than" operator? 2. In your examples, sometimes you're passing a shared_ptr by value, and sometimes by reference-to-const. Which is the better practice? Usually, common pointers are passed by value, but since in shared_ptr a reference counting mechanism keeps track of the copies, maybe it's better to pass it by reference whenever possible? Thanks in advance, Matthias Kaeppler -- Matthias Kaeppler | Tel: +49 631 3405805 Gerhart-Hauptmann-Str. 16a | Mob: +49 176 20108693 D-67663 Kaiserslautern | E-Mail: matthias at finitestate dot org

3 2

[operators] boost::operators-like functionality for methods
by Geoffrey Irving 13 Oct '05

13 Oct '05

Hello, Is it possible to get boost::operator like functionality for general methods? In other words, I'd like to be able to do the following: template<...> struct complete : public ... { void f(){a();} void g(); }; struct C : public complete<...> { void a(); void b(){g();} }; The resulting class C would have methods a,b,g,f. Here C::b refers to the complete::g and complete::f refers to C::a, so the dependencies are circular. It seems like the boost::operators setup can handle this kind of circular dependency, but I'm not how to do it for methods. Thanks, Geoffrey

2 1

MPL map / multi index dependency bug
by Zach Laine 13 Oct '05

13 Oct '05

The following code does not compile using gcc 3.4.3. I tried it with the same results using 1.32 and 1.33. Reversing the order of the #includes fixes the problem. Is this a known order dependency? If so, I couldn't find it documented anywhere. #include <boost/multi_index_container.hpp> #include <boost/mpl/map.hpp> int main() { return 0; } Compiler output: In file included from /usr/local/include/boost-1_33/boost/mpl/map/aux_/begin_end_impl.hpp:20, from /usr/local/include/boost-1_33/boost/mpl/map/map0.hpp:30, from /usr/local/include/boost-1_33/boost/mpl/map/map10.hpp:19, from /usr/local/include/boost-1_33/boost/mpl/map/map20.hpp:19, from /usr/local/include/boost-1_33/boost/mpl/map.hpp:36, from test.cpp:2: /usr/local/include/boost-1_33/boost/mpl/map/aux_/iterator.hpp:41: error: wrong number of template arguments (2, should be 1) /usr/local/include/boost-1_33/boost/mpl/void.hpp:37: error: provided for `template<class T> struct boost::mpl::is_void_' /usr/local/include/boost-1_33/boost/mpl/map/aux_/iterator.hpp:41: error: `type' is not a member of `<declaration error>' /usr/local/include/boost-1_33/boost/mpl/map/aux_/iterator.hpp:41: error: `type' is not a member of `<declaration error>' /usr/local/include/boost-1_33/boost/mpl/map/aux_/iterator.hpp:42: error: template argument 1 is invalid /usr/local/include/boost-1_33/boost/mpl/map/aux_/iterator.hpp:44: error: expected `{' before '>' token /usr/local/include/boost-1_33/boost/mpl/map/aux_/iterator.hpp:44: error: expected unqualified-id before '>' token /usr/local/include/boost-1_33/boost/mpl/map/aux_/iterator.hpp:44: error: expected `;' before '>' token /usr/local/include/boost-1_33/boost/mpl/map/aux_/iterator.hpp:62: error: expected nested-name-specifier before "item_by_order" /usr/local/include/boost-1_33/boost/mpl/map/aux_/iterator.hpp:62: error: ISO C++ forbids declaration of `item_by_order' with no type /usr/local/include/boost-1_33/boost/mpl/map/aux_/iterator.hpp:62: error: expected `;' before '<' token

2 2

[Beginner] Setting up a function which generates normally distributed numbers
by Snorre Jakobsen 13 Oct '05

13 Oct '05

Hello I'm sorry if this is answered in the documentation, but I didn't find it. I want a function which returns a normally distributed number. #include <boost/random.hpp> #include <time.h> using namespace boost; double SampleNormal (double mean, double sigma) { mt19937 rng; // select random number generator rng.seed((unsigned int) time(0)); // seconds since 1970 // select desired probability distribution normal_distribution<double> norm_dist(mean, sigma); // bind random number generator to distribution, forming a function variate_generator<mt19937&, normal_distribution<double> > normal_sampler(rng, norm_dist); // sample from the distribution return normal_sampler(); } This (from http://surl.se/tvk) works very well, except if it's invoked (with same parameters) more often than once a second. If so, the generator gets equal seeds and returns equal values. How can I construct my program so the seeding happens only once? My experience with templates is limited, but I do have a grasp of the idea. Thanks for any hints. Snorre Jakobsen, Norway

2 1

thread-safe iostreams - ideas for implementation ?
by marc 12 Oct '05

12 Oct '05

thread-safe iostreams - ideas for implementation ? I am currently experimenting with the boosth thread/mutex libraries, and did notice that the standard io streams are not thread safe. In the boost examples, this is handles by some global mutexes which are locked before writing to cout, cerr. I would like to have some classes which - behave exactly as cout, cerr and named file out streams - are thread safe mutex locked Are there any ideas on how to do this ?? I have the following possibilities in mind: 1) make a wrapper class around ostreams which have assigned a specific file or ostream as a member, make each input to operator<<() locked by a lock to a static mutex. advantage: not that hard to implement disadvantage: when outputting multiple things, like in mutex-cout << 'A' << 'B' << std::endl; another thread can come in between 'A' and 'B'. Not really thread safe, as I would like to have the entire line protected. 2) Make some trickery with manipulators and use the std:: stremas, something like cout << lock << 'A' << 'B' << std::endl << unlock ; advantage: pretty ok syntax (albeit one can forget to unlock!) disadvantage: I really have no idea how to implement in a niece and easy way .. 3) Make some trickery with out-put buffering something like having a class modeled like a stream_buff, which is large enough to hold what's written to the associated streams, and which does write to the cout or file streams in a mutex-locked fashion whenever it's manually flushed. ??? silly or possible ?? 4) finaly, a class having a boring print(std::string) function, which sets a lock on the static mutex advantage: easy-peasy disadvantage: C-print like, needs a new class type for each out-file, as a new static mutex has to be assigned to each out-file No nice C++ straming possible whatever I want to write needs to be converted into a std::string first. implementatio: can be templated by a string parameter which is the name of the file, or 'cout'/'cerr' Probably my ideas are not very bright, so I would appreciate some input from boost::thread users, which undoubtely have met the same problem before. Cheers, Marc -- Marc Cromme, cand. polyt, Ph.D Senior Developer, Project Manager Index Data Aps Købmagergade 43, 2 1150 Copenhagen K. Denmark tel: +45 3341 0100 fax: +45 3341 0101 http://www.indexdata.com INDEX DATA Means Business for Open Source and Open Standards

1 0

[Review] TR1 library accepted
by Beman Dawes 12 Oct '05

12 Oct '05

John Maddock's TR1 library is accepted by Boost. Coincidentally, ISO has just announced that TR1 unanimously passed its final ballot, and so is now official. There were four reviews of John's submission, all urging acceptance. For most of the relatively few issues raised during review, John has already responded. Unless I missed it, however, John hasn't responded to Jonathan Wakely's review comments yet, anduld do so when he gets a chance. For example: It might be useful to list all the BOOST_HAS_TR1_XXX macros on the Configuration page, so you can glance at them all at once (most people will know what components each macro relates to.) Otherwise you have to read through a lot of text on the "TR1 By Subject" page to see what's available. Congratulations to John, and thanks to our reviewers! --Beman Dawes, Review Manager

1 0