February 2016 - Boost - lists.boost.org

recompile with -fPIC
by Marwa Refaie 09 Feb '16

09 Feb '16

Hi I try to compile "cdec" translation package , I been stuck in this error : ______________________________________________________________________________ /usr/bin/ld: /usr/lib/gcc/x86_64-linux-gnu/4.9/../../../x86_64-linux-gnu/libboost_system.a(error_code.o): relocation R_X86_64_32 against `.rodata.str1.1' can not be used when making a shared object; recompile with -fPIC/usr/lib/gcc/x86_64-linux-gnu/4.9/../../../x86_64-linux-gnu/libboost_system.a: error adding symbols: Bad value collect2: error: ld returned 1 exit status error: command 'g++' failed with exit status 1______________________________________________________________________________ I red solution like bjam boost without debug or specifiy -fPIC !!! Any help to apply any solution ?? How should I fix plz ?? Marwa N. Refaie

1 0

[smart_ptr] Interest in the missing smart pointer (that can target the stack)
by Noah 09 Feb '16

09 Feb '16

Hi all, I'm new here. Here goes: I propose a new smart pointer called, say "registered_ptr", that behaves just like a native C++ pointer, except that its value is (automatically) set to null_ptr when the target object is destroyed. This kind of smart pointer already exists and is being used in the form of, for example, QPointer and Chromium's WeakPtr (http://doc.qt.io/qt-5/qpointer.html and https://code.google.com/p/chromium/codesearch/#chromium/src/base/memory/wea…) although those implementations only apply to a specific set of object types. There's also std::experimental::observer_ptr (http://en.cppreference.com/w/cpp/experimental/observer_ptr) which seems to be trying to serve a similar purpose, but with none of the functionality. This might be as far as you need to read to decide if you think it's a good idea or not. The rest of this (kind of long) post addresses some of the details and motivation. It's instructive to compare this "registered_ptr" with (std::)shared_ptr. Both have a (modest) performance cost, although registered_ptr's performance cost is significantly lower, as will be discussed later. Both can have a significant "code safety" benefit when used for that purpose - i.e. reduce or eliminate the possibility of invalid access of an object that has already been destroyed. And both have a functional purpose other than safety or convenience (or just being a regular pointer). That functional purpose is to deal with situations when it is not easy to predict in advance (i.e. at compile time) when an object will be referenced (and stop being referenced). shared_ptr deals with these type of situations by ensuring that the object remains "alive" for as long as there are any (owning) references to the object. This assumes that the object has no "curfew". But one can imagine situations where an object needs to be destroyed at or by a certain time or event. If the object is exclusively holding an in demand resource, or security lock for example. In these cases one might prefer that late attempted references to the object fail (safely) rather than have the object's destruction delayed. registered_ptrs might be more suitable for these situations. So from this comparison it's hard to argue for the inclusion of shared_ptr and the omission of registered_ptr in the library. registered_ptr can be thought of as a kind of "non-intrusive" counterpart to shared_ptr. "But wait", you say, "shared_ptr already has a non-intrusive counterpart. Namely weak_ptr." Yes, but the difference between weak_ptr and registered_ptr is that registered_ptr is independent, not just an appendage of shared_ptr. And registered_ptr can point to stack allocated objects (just like native C++ pointers can), but at the cost of "thread safety". Referencing an object on another (asynchronous) thread's stack is inherently not safe, right? Some may be concerned with this lack of thread safety - I am not, I don't think we should be encouraging casual asynchronous object sharing - but the performance dividend of getting to put the target object on the stack rather than the heap more than makes up for it in my opinion. So I've actually already had cause to implement, and use, a version of this "registered_ptr" (I actually called it "TRegisteredPointer"), and in practice it works great. But there are, arguably, a couple of issues. Besides the thread safety (non-)issue, my implementation can only target types that can act as base classes. By default most classes can act as a base class, but native types like int, bool, etc. cannot. In my case, this is not a big issue because TRegisteredPointer is actually part of a small library that includes (safer) substitutes for int, bool and size_t that can act as base classes. The good thing is that it does seem to serve its purpose of not only being safe, but also faster than shared_ptr. Much faster when targeting stack objects as one would expect, but also faster when targeting heap objects according to my simple benchmarks (msvc2013 - Windows 7 - Haswell). My implementation can be found here: https://github.com/duneroadrunner/SaferCPlusPlus. It's in the file called "mseregistered.h". Examples of it in action can be found in the file called "msetl_example.cpp", near the end. No decent documentation yet, but the examples are commented and it should be clear what's going on. So far I've posited that the argument for registered_ptr is at least as good as the argument for shared_ptr. But let me make a further argument for why I think it's particularly important to include registered_ptr. First, let me make an argument for "safe" pointers in general. By safe pointers, I mean pointers that have zero chance of participating in a dereference to invalid memory. This will usually imply that the safe pointer will do a runtime check and throw an exception if an invalid dereference is attempted. Now, I subscribe to the C++ "trust the programmer" philosophy, so I agree that programers should have the option of avoiding these runtime checks. But security (and by extension, language safety) is so important these days that programmers should also have the option of having these runtime checks when desired. So I'm suggesting that all the smart pointers (shared_ptr, unique_ptr, etc.) come in "safe" versions as well. There is already some precedent for safe and unsafe options. For example, std::vector<> provides both the "unsafe" [] operator and the "safe" at() function. And ultimately it needs to be properly measured, but I would think that the performance cost of this kind of runtime check should be quite modest. There is plenty of opportunity for optimizing compilers to strip them out when not needed and of course these sorts of runtime checks are a favorite food of branch predictors in modern cpus right? I haven't put a lot of effort into this, but my simple benchmarks show checked dereferences being only modestly slower than unchecked dereferences. (The "msetl_example.cpp" file includes some simple benchmarks.) So why does this make registered_ptr so important? Because the "safe" version of registered_ptr would be the safe pointer with the lowest performance cost. Perhaps low enough for the safety benefits to be widely considered worth the cost. Of course the ideal would be smart pointers that could distinguish between stack allocated objects and heap allocated objects. Unfortunately, as far as I know, (standard) C++ doesn't seem to give us that facility. If we can't have those, I think we need a smart pointer that can at least accommodate stack allocated objects. Right? Noah

10 45

[Fit] Announcing Fit's formal review (March 2nd)
by paul Fultz 08 Feb '16

08 Feb '16

Dear Boost community, The formal review of the Fit library starts Wednesday, 2nd March and ends on 13th March. Fit is a header-only C++11/C++14 library that provides utilities for functions and function objects. Fit is: - Modern: Fit takes advantages of modern C++11/C++14 features. It support both `constexpr` initialization and `constexpr` evaluation of functions. It takes advantage of type deduction, varidiac templates, and perfect forwarding to provide a simple and modern interface. - Relevant: Fit provides utilities for functions and does not try to implement a functional language in C++. As such, Fit solves many problems relevant to C++ programmers, including initialization of function objects and lambdas, overloading with ordering, improved return type deduction, and much more. - Lightweight: Fit builds simple lightweight abstraction on top of function objects. It does not require subscribing to an entire framework. Just use the parts you need. Fit is divided into three components: * Function Adaptors and Decorators: These enhance functions with additional capability. * Functions: These return functions that achieve a specific purpose. * Utilities: These are general utilities that are useful when defining or using functions Fit has been tested on gcc 4.6-4.9, clang 3.4-3.7, and Visual Studio 2015. For more information see: Github: https://github.com/pfultz2/Fit/tree/boost Documentation: http://pfultz2.github.io/Fit/doc/html/ I hope everyone can participate in the review. Thanks, Paul

4 3

How best to implement a bitfield in C++ 14?
by Niall Douglas 07 Feb '16

07 Feb '16

Dear Boost, As part of the AFIO v2 rewrite I've been trying to improve on how AFIO v1 did bitfields by making better use of constexpr and the type system to make usage more natural. I'd appreciate feedback on my efforts. AFIO v1 has an example of usage at https://goo.gl/oVLIjU or https://gist.github.com/ned14/9ef2a9d00da0ffc877b8 and it took the following form: enum class flag : size_t { none=0, delete_on_close=1, disable_safety_fsyncs=2 }; BOOST_AFIO_DECLARE_CLASS_ENUM_AS_BITFIELD(flag) The BOOST_AFIO_DECLARE_CLASS_ENUM_AS_BITFIELD macro declares all the sensible global overloads you'd expect, is type safe and you can use it without surprise except in one single instance: testing for emptiness. The problem is that you cannot declare as a global operator an explicit operator bool nor member functions on enums, so one cannot do if(f) though if(!f) is fine. In AFIO v1, I used if(!!f) and if(!!(f & flag::foo)) everywhere, which is fine if a little abtuse. AFIO v2's current bitfield has an example of usage at https://goo.gl/LsjSGD or https://gist.github.com/ned14/89ee39c6b8eb5254116a and it takes the following form: struct flag : bitwise_flags<flag> { flag() = default; constexpr flag(bitwise_flags<flag> v) noexcept : bitwise_flags<flag>(v) { } static constexpr auto none(){ return bit(0);} static constexpr auto delete_on_close(){ return bit(1); } static constexpr auto disable_safety_fsyncs(){ return bit(2); } }; Here the bitwise_flags<> base class does all the implementation magic, so once again you can use it without surprise except for the obvious clanger - bitfield items are now functions, so instead of the more natural: flag f(flag::disable_safety_fsyncs); flag f2(f&flag::none); f2|=flag::delete_on_close; constexpr flag f3(flag::disable_safety_fsyncs); constexpr flag f4(f3&flag::none); You are stuck with: flag f(flag::disable_safety_fsyncs()); flag f2(f&flag::none()); f2|=flag::delete_on_close(); constexpr flag f3(flag::disable_safety_fsyncs()); constexpr flag f4(f3&flag::none()); I'll admit I started this with the static constexpr flag values being member variables which always works on MSVC and on GCC and clang when the optimiser is running. Unfortunately both GCC and clang appear to be extremely conservative about when a constexpr variable is ODR-used, indeed despite my original design of an unavoidable lvalue-to-rvalue conversion intended to force ODR-used to be off both compilers go ahead and enforce ODR-used anyway which generates undefined reference errors for the storage of the static member variables :( If you'd like to read more about that, and the WG21 DR relating to [basic.def.odr], see https://stackoverflow.com/questions/8016780/undefined-reference-to-sta tic-constexpr-char/28846608#28846608. So, do Boosters think we can actually make a C++ 14 bitfield which: 1. Is typesafe, so not a C bitfield. 2. Is convenient for programmers to declare (i.e. little boilerplate in a specific bitfield declaration). 3. Works as you'd expect a bitfield to work, including bitfield::flag. 4. if(bf) works. 5. Is 100% constexpr and generates zero runtime overhead. My thanks in advance for any advice. Niall -- ned Productions Limited Consulting http://www.nedproductions.biz/ http://ie.linkedin.com/in/nialldouglas/

6 26

expected/result/etc
by Michael Marcin 07 Feb '16

07 Feb '16

Some months ago there was a lot of discussion regarding Rust style return values for non-exceptional error handling. Did anything ever come of this? Is there a useable library? Apologies if I missed an announcement (I've been away for a bit).

7 31

[gsoc16] ATTN: Project ideas deadline 19th Feb
by Niall Douglas 07 Feb '16

07 Feb '16

Tomorrow 8th February the application period for Google Summer of Code 2016 begins, and yet we have just *one* idea on the ideas page: https://svn.boost.org/trac/boost/wiki/SoC2016 We need *plenty* more if we are to be approved again this year as a Google Summer of Code org, the deadline for which is the 19th February. So if you have some project ideas and think you could mentor a student this summer, *please* consider adding a project idea to the ideas list or stepping forward with a list of Boost libraries or topics you'd be willing to mentor. Our thanks in advance. --- Boost C++ Libraries Google Summer of Code 2016 admin https://svn.boost.org/trac/boost/wiki/SoC2016

1 0

[math] Missing constexpr statement in MPFR bindings
by Claas H. Koehler 05 Feb '16

05 Feb '16

Hi, I encountered a compiler error using gcc-5.0 with the math constants in boost 1.60.0 due to a different exception specification of math::tools::digits(): The prototype defined in math/tools/precision.hpp has a BOOST_NOEXCEPT specifier, while the implementation in math/bindings/mpfr.hpp does not have the respective specification. Adding BOOST_NOEXCEPT in math/bindings/mpfr.hpp solves the problem, i.e. compilation succeeds. I was wondering whether this is a bug or whether the error can be circumvented in another way. Regards Claas

2 1

Is there interest in Computable Calculus?
by Alexander Lauser 05 Feb '16

05 Feb '16

Hi, An arithmetic operation produces a new function using the functions in the operands and some simple expression manipulations. if I gather it right, then what you propose is basically a Computer Algebra System (i.e., a system for manipulating reals by symbolic expressions). What specifically would the goal of the library be? Best, Alex

2 5

updated version of safe integer library
by Robert Ramey 05 Feb '16

05 Feb '16

I've updated my safe integer library. Pointers to the most recent documentation and code can be found at www.blincubator.com . Or one can use documentation http://htmlpreview.github.io/?https://github.com/robertramey/safe_numerics/… repository: https://github.com/robertramey/safe_numerics I've resolved added more tests. added more examples and explanation of them added facilities to enforce a guarantee of zero runtime penalty added new section to the documentation of the above added more documentation regarding the library implementation. and other stuff. There is still a little more to do. But there is nothing that I know about that would prevent users from using this library right now to implement guaranteed correct integer arithmetic in their applications. Of course I'm interested any feedback and/or observations anyone want's to offer. Robert Ramey

5 13

[iterator] Boost zip iterator
by Claas H. Koehler 05 Feb '16

05 Feb '16

First of all thanks for implementing the support of std::pair with the zip iterator in boost 1.60. While testing the feature, I noticed that it is necessary to add the following include #include <boost/fusion/adapted/std_pair.hpp> before code using the zip iterator with std::pair. Just wondering if this was intentional behaviour or if the include should happen directly in zip_iterator.hpp. Anyway, the feature works great and is a real improvement for our projects. Regards Claas

1 0