- Boost - lists.boost.org

Boost compatible with Clang C++11 dialect?
by Torrey Lyons 19 Dec '11

19 Dec '11

When enabling C++11 support on Xcode 4.2 using Clang 3.0 there are many build conflicts in Boost. The C++11 language dialect is not on by default, but we would like to use it. Apparently Boost is not detecting that the compiler already has these features built in when C++11 support is turned on. Should we expect Boost 1.48.0 to work with Clang 3.0 using the C++11 language dialect? Is there a known workaround? Thanks for any tips or insights. -- Torrey VSee: torrey(a)vsee.com <http://vsee.com/call?torrey@vsee.com> | Cell: 310.940.6397 Teamwork made simple vsee.com Blog <http://vsee.com/blog/> Facebook <http://www.facebook.com/VSeeLab> Twitter <http://twitter.com/vsee>

1 0

[bind][phoenix] Compliance with function template bind
by Vicente J. Botet Escriba 19 Dec '11

19 Dec '11

Hi, Boosthas Boost.Bind and Boost.Phoenix that provides a bind function. Are them compliant with C++11 for 20.8.9 Function template bind (in particular move semantics)? If yes, how they work for C++03 compilers? If not, is there any plan to adapt them to support move semantics? Best, Vicente

2 3

[Concept Checking] function_requires
by Jens Müller 18 Dec '11

18 Dec '11

Hi all, as far as I understand http://www.boost.org/doc/libs/1_48_0/libs/concept_check/reference.htm#depre…, function_requires() is deprecated. However, the documentation does not mention very clearly how to replace it. Is the BOOST_CONCEPT_ASSERT macro the replacement? E.g., does function_requires< VertexListGraphConcept<Graph> >(); now become BOOST_CONCEPT_ASSERT((VertexListGraphConcept<Graph>)); function_requires still appears in a lot of test cases of the Graph library. So if it is that easy to change, I would hand in a patch. Best regards, Jens

2 7

[math.special_functions] broken in trunk
by Tim Blechmann 18 Dec '11

18 Dec '11

it seems, there is a problem in boost.math in trunk. the boost.heap testsuite originally used boost.random, but the test farm reports some issues: In file included from ../boost/math/special_functions.hpp:32, from ../boost/random/generate_canonical.hpp:22, from ../boost/random.hpp:52, from ../libs/heap/test/mutable_heap_tests.hpp:1, from ../libs/heap/test/fibonacci_heap_test.cpp:12: ../boost/math/special_functions/expint.hpp: In function ???void boost::math::detail::expint_i_imp_113a(T&, const T&)???: ../boost/math/special_functions/expint.hpp:1028: error: expected primary- expression before ???(??? token (compare http://tinyurl.com/bqfputx) for now, i've reverted to the libc random() function to work around this issue, but it would be great, if someone with insights in boost.math could have a look. thanks, tim

2 2

Add macros for the "enum class" concept?
by Daryle Walker 18 Dec '11

18 Dec '11

Should we add preprocessor stuff to conditionally use the C++11 "enum class" construct? #if Whatever #define BOOST_HAVE_ENUM_CLASS #endif //... #if BOOST_HAVE_ENUM_CLASS #define BOOST_ENUM_CLASS( Name ) enum class Name #define BOOST_ENUM_CLASS_BASE( Name, Type ) enum class Name : Type #define BOOST_ENUM_CLASS_REFER( Type, Enumerator ) (Type :: Enumerator) #else #define BOOST_ENUM_CLASS( Name ) enum Name #define BOOST_ENUM_CLASS_BASE( Name, Type ) BOOST_ENUM_CLASS( Name ) #define BOOST_ENUM_CLASS_REFER( Type, Enumerator ) (Enumerator) #endif I'm not sure that the second version of BOOST_ENUM_CLASS_BASE is the best alternative. Nor do I know if the parentheses around enumerators are best. You can use BOOST_ENUM_CLASS in an enum definition header and BOOST_ENUM_CLASS_BASE as a header or a forward declaration. Since enumerators can be scoped, BOOST_ENUM_CLASS_REFER encapsulates the need to add the enum type's name.

5 9

[parameter] type predicates vs. concepts
by Lorenzo Caminiti 18 Dec '11

18 Dec '11

Hello all, What's the difference between using a Boost.Parameter type predicate and using a concept? I think parameter type predicates are unary metafunctions used to resolve the function call, concepts are asserted on the type after the call has been resolved... Is there more? Can I always do with type predicates what I can do with concepts? Is there ever a reason to use/need both? For example here has_equal_to is the type predicate while DefautlConstructible is the concept. Could/should I have used has_[...]_default_constructor in and_ the type predicate instead of the DefaultConstructible concept? #include <boost/parameter.hpp> #include <boost/concept/requires.hpp> #include <boost/concept_check.hpp> #include <boost/type_traits/has_equal_to.hpp> #include <iostream> template< typename X > BOOST_CONCEPT_REQUIRES( ((boost::DefaultConstructible<X>)), (bool) ) is_default_impl ( X const& x ) { return x == X(); } BOOST_PARAMETER_NAME(x) BOOST_PARAMETER_FUNCTION( (bool), is_default, tag, (required (x, *(boost::has_equal_to<tag::x::_>)) ) ) { return is_default_impl(x); } struct no_equal {}; struct no_default { no_default(int) {} }; bool operator== ( no_default const&, no_default const& ) { return true; } int main ( void ) { std::cout << is_default(123) << std::endl; // ok // parameter error: cannot resolve is_default() call // std::cout << is_default(no_equal()) << std::endl; // concept error: no default constructor // std::cout << is_default(no_default(1)) << std::endl; return 0; } Thanks a lot. --Lorenzo

4 7

Boost Iterator Library - small extension proposal
by Detlef Wilkening 18 Dec '11

18 Dec '11

Hello Boostler, at first, excuse my english - I am not a native speaker. I used sometimes the Boost.Iterator library - especially the filter iterators. I like them much, but I don't like the work to create the iterator objects. --- Example: struct IsEven { inline bool operator()(int n) const { return n%2==0; } }; vector<int> v; IsEven iseven; filter_iterator<IsEven, vector<int>::iterator> filter_iter_begin(iseven, v.begin(), v.end()); filter_iterator<IsEven, vector<int>::iterator> filter_iter_end(iseven, v.end(), v.end()); --- My first problem is, that I need 3 times "v.end()" and 2 times "iseven". And the type is very long. I don't think, that the "make" functions makes it much better. I use "auto" from C++11 in this example, to make it a little bit shorter. --- Example: struct IsEven { inline bool operator()(int n) const { return n%2==0; } }; vector<int> v; IsEven iseven; auto filter_iter_begin2 = make_filter_iterator<IsEven>(v.begin(), v.end()); auto filter_iter_end2 = make_filter_iterator<IsEven>(v.end(), v.end()); --- Again I need 3 times "v.end()" and 2 times the type "IsEven". And the type is again very long - thanks to "auto" in C++11. My second problem is, that both use cases don't work well with lambda expressions in C++11. For "make" I need the type of the lambda, which I don't have - and I need it 2 times. And in the first solution I must write the lambda expression 2 times, which is not good. Perhaps there are some other solutions, wich I don't see - than please explain them to mee. ----- My proposal is a new "make" function, which is easer to use (only 1 time "v.end()") and works well with lambda expressions, but has furthermore a stupid type - but in C++11 with "auto" that doen't matter. --- template<class Iter, class Fct> pair<filter_iterator<Fct, Iter>, filter_iterator<Fct, Iter>> make_filter_iterators(Iter begin, Iter end, Fct fct) { filter_iterator<Fct, Iter> filter_iter_begin(fct, begin, end); filter_iterator<Fct, Iter> filter_iter_end(fct, end, end); return pair<filter_iterator<Fct, Iter>, filter_iterator<Fct, Iter>> (filter_iter_begin, filter_iter_end); } Usage: vector<int> v; auto iters = make_filter_iterators( v.begin(), v.end(), [](int n){ return n%2==0; }); copy(iters.first, iters.second, ostream_iterator<int>(cout, " ")); --- You see, with "auto" easy to use, and work well with lambda expressions. My proposal is to add such a "make" function to all iterator adaptors in Boost.Iterator. Thank you for reading my idea. Greetings Detlef Wilkening

3 3

[Math.Constants] Help needed with the preprocessor
by John Maddock 18 Dec '11

18 Dec '11

Folks we have a problem: rather late in the day I've discovered that our Math.Constants code doesn't compile on anything except VC++, and the problem is preprocessor token pasting. So I'm hoping we have some experts around here that can help! The issue is we currently construct the constants from a macro invocation such as: BOOST_DEFINE_MATH_CONSTANT(half, 5.000000000000000000000000000000000000, 00000000000000000000000000000000000000000000000000000000000000000000000000, -01); But the "-01" part (the exponent) isn't a valid pp-token, so trying to token-paste it fails on GCC (compiler error). Does anyone know if there's a way to overcome this? As an alternative, I've considered something like: BOOST_DEFINE_MATH_CONSTANT(ln_two, 6.931471805599453094172321214581765680e-001, "6.93147180559945309417232121458176568075500134360255254120680009493393621969694715605863326996418687542001481021e-001"); But this would still require token pasting of the 6.931471805599453094172321214581765680e-001 part. But is this now a valid pp-token if the "-" is internal to the token? It works on the compilers I've tried, but I don't want to be skewered by this again down the line.... Truly hating the preprocessor yours, John.

6 8

Re: [boost] New libraries implementing C++11 features in C++03
by Brent Spillner 18 Dec '11

18 Dec '11

On 24 Nov 2011 09:11:19 Joel de Guzman wrote: >Man! Of course you should use the examples in 1.45. Those examples >are for 1.48 and uses new features implemented in 1.48! Sheesh! I fully understand that. The point is that the Phoenix interface is evolving much more quickly than that of probably any other Boost library. Even apart from the fact that there already have been two bottom-up rewrites, there are enough significant changes between point releases that even small example programs are tied to a particular version of the library. Why is the optimal way to write a small calculator example today so different from the optimal way to write it six months ago? I'm not disputing that you're making forward progress, just highlighting this as another barrier to entry that Local likely won't have. >Double Sheesh! If you've spent even a few seconds looking into the >error (beyond fault-finding), you will see that a simple textual >search of "error" will reveal this: Yes, it's possible to wade through the error messages and figure out what went wrong. And Qi is clearly trying to help out with traceable assertions; that may well be the best we can do. But no reasonable person would claim that hundreds of lines of error message, mostly filled with types that the user never directly constructed, are the most desirable way to report a simple syntax error. This problem is endemic to all ET libraries and compilers, and it would be very, very hard to do much better. Again, though, I think you're underselling this as a barrier to entry. How many people would ever learn C++ if all libraries did this? >Now having said that, and before I leave this thread, let me remind >everyone that **you can also have statement syntax in Phoenix** if you >have a complex statement and you fear writing complex phoenix lambda >expressions. It's called phoenix::functions. The important issue here isn't just statement /syntax/, it's that we have options available that don't turn what looks like an ordinary C++ statement into a massive AST with its own mini-compiler behind the scenes.

18 38

Boost.Math and Math Constants
by Paul A. Bristow 17 Dec '11

17 Dec '11

Boost.Math has always had an inconspicuous collection of useful math constants, mainly those that are used internally. The presentation of these was as a function-template, called for example, as pi<double>(). using namespace boost::math::constants; return pi<Real>() * r * r; This leads to some rather ugly equations and is most unpopular with scientific and engineering users. John Maddock has now added a new cunning feature that allows the vast majority of users who just want a built-in double to get the constants quickly as plain variables. So in non-template code, users can write using boost::math::double_constants; double area = pi * r * r; and users can read the equations easily. (Float and long double are similarly available in their own namespaces). The original mechanism which can be used for higher multiprecision user-defined floating-point types appears unchanged but has been improved to work better with UDTs and high precision types. Some draft detailed docs about just these new proposals are at http://boost-sandbox.sourceforge.net/libs/math_constants/doc/html/index.html We would like to be sure that 1 This additional mechanism of presenting constants is acceptable. 2 It is acceptable to add more constants (current new list is about 60 constants). Are there important constants that you think we have missed? Do we need a mini-review? Other views? Paul PS 1 Are there important constants that you think we have missed? 2 Please tell me of mistakes and typos in the draft docs. --- Paul A. Bristow, Prizet Farmhouse, Kendal LA8 8AB UK +44 1539 561830 07714330204 pbristow(a)hetp.u-net.com

9 24