|
|
Comments and Discussions
|
|
 |
|
Very basic info is provided a comparison with some other library would really add some value.
|
|
|
|
|
Boost library provide string.hpp for performing various operation on string.
When im trying to include this file i m getting following error messages.:-
/* code
#include"boost/algorithm/string.hpp"
*/
Error :- :c:\boost\algorithm\string\yes_no_type.hpp(22) : error C2265: '' : reference to a zero-sized array is illegal
c:\boost\algorithm\string\yes_no_type.hpp(23) : see reference to class template instantiation 'boost::algorithm::size_descriptor' being compiled
c:\boost_1_34_0\boost\mpl\bool.hpp(37) : fatal error C1506: unrecoverable block scoping error..
What can be the reason for this..
tony
|
|
|
|
|
|
Hello,
i try to use boost in my projects, regular expressions for example, but i recive only an error!
This is my first try with boost, an example from boost homepage:
boost::tregex r(__T("(?:\\A|.*\\\\)([^\\\\]+)"));
boost::tmatch what;
Error Message:
error C2039: 'tregex' : is not a member of 'boost'
error C2065: 'tregex' : undeclared identifier
how to use now this regular expressions in vc6 projects??
thanks in advance
break;
|
|
|
|
|
Does boost come with n-ary tree container?
Sonork 100.41263:Anthony_Yio
Life is about experiencing ...
|
|
|
|
|
No it's one of the few things that boost doesn't have - the experts still argue about how tree classes should be written.
Boost does however have the Boost Graph Library, which is a superset of all trees, and can be used to construct trees - some of the examples do this. I found the learning curve for the BGL to be very steep, one of the very few parts of boost that is like that.
If you can keep you head when all about you
Are losing theirs and blaming it on you;
If you can dream - and not make dreams your master;
If you can think - and not make thoughts you aim;
Yours is the Earth and everything that's in it.
Rudyard Kipling
|
|
|
|
|
Using Boost would be my primary choice, but since Boost doesn't have it (N-Ary tree) at the moment. I will use STL n-ary tree by Kasper Peeters instead.
thanks, nice intro to Boost.
Sonork 100.41263:Anthony_Yio
|
|
|
|
|
Peeters' tree looks really cool, but he is using the GNU General Public License, so you can't use it in proprietary software.
|
|
|
|
|
Heya Everyone,
I recently gave a presentation to my colleagues here at work on the wonders of the Boost library. It gives a gentle introduction to Boost and nine of the libraries.
It was well received and went for about an hour. I thought that others may be able to use it so I've made it available here[^].
Feel free to use/abuse modify, whatever!
Cheers,
Matt
|
|
|
|
|
the link is not working.. 
|
|
|
|
|
Boost contains a lot of libraries... but it contains even more hidden goodies if you start looking into the "not yet" accepted libraries.
To find them, go to the boost mailing list on yahoo and look into the files sections. After crawling a bit, I found (I'm giving only a few):
- The Relational Templated Library: this project is to SQL as Spirit is for parsers
- hashed containers (hash_map, hash_set, ...)
- socket streams
- filtered stream buffers
- a lot of format libraries
- etc...
Jonathan de Halleux.
|
|
|
|
|
Thanks for the response, good luck with IoBind and it's proposal for inclusion into Boost.
If you've got any additional links and / or material that you think needs to be added, or other components which you consider essential I'd appreciate any advice you could give.
If you can keep you head when all about you
Are losing theirs and blaming it on you;
If you can dream - and not make dreams your master;
If you can think - and not make thoughts you aim;
Yours is the Earth and everything that's in it.
Rudyard Kipling
|
|
|
|
|
uBLAS is a C++ wrapper around the BLAS (Basic Linear Algebra Subroutines). It also contains bindings to LAPACK (Linear Algebra Package).
I think this package maybe deserves some attention. In fact, it would to time to put a good tutorial on CP about Numerical Algebra: When it comes to matrix computation, there are basically to solution:
Home made
I see people implementing their own matrix classes and therefore implementing their own +, -, *, etc... and worse inversion operator (usually a cut and paste from Numerical Recipies): you should always avoid this solution when it comes to matrix computation:
- personnal implementations are error-prone. Moreover, error are difficult to track down.
- Algorithms are usually not the "top of the notch". Matrix computation is not a still science and algorithms haved evolved a lot in the past few years
- You can do what you want, your implementation will be slower than LAPACK counter part
- It takes a lot of time and code to write to get a decent matrix class
You can add many things to this list...
LAPACK
On the other you have the BLAS and LAPACK who are optimized Fortran routines written by numerical algebra gurus:
- It's free
- Algorithms are error free!
- Algorithms are fast
- You can solve all the classical problems: eigen values, LU, Choleski, etc... You don't need to type it again
One thing that makes LAPACK difficult to use is that it's basically a Fortran library, you need the right memory alignment and function calls tend to be long and tedious. This is where uBLAS comes into the play:
- uBLAS has bindings to LAPACK
- uBLAS is a template wrapper, minimum function overhead (all methods are inline and optimized away by the compiler)
Jonathan de Halleux.
|
|
|
|
|
Nice, a good boost intro. was really missing in CP.
Maybe this article belongs to tutorials ?
Jonathan de Halleux.
|
|
|
|
|
Hi,
Good introduction.
The more introductions and articles about boost we have the more people will learn how to use these amazing libraries.
Just a note, though, regarding auto_pts.
auto_ptrs, were never meant as smart pointers per se, so the limitations and faults you mention aren't really limitations and faults (but can actually be considered features). auto_ptrs are meant as an exception safe mechanism for memory management. People have gone to great trouble to get the feature of not allowing them to be stored in containers to work.
I think that adding them to the STL before other real smart-pointers may arguably be confusing, but real smart-pointers are one of the most probable candidaes for the next STL release, indeed, mostly based on the boost smart pointers.
Anyway, I think every C++ user should be familiar with the Boost smart pointers and I hope your article spurs people to go and explore more.
Thanks,
Adi
|
|
|
|
|
I agree with you in general, however I think std::auto_ptr should not be copy-constructible or assignable (albeit with a non-const reference). IMO ownership should be transferred using swap and/or attach/detach.
However, std::auto_ptr is the way it is and it's a very valueable piece of code if used as intended.
/Mårten
|
|
|
|
|
Making auto_ptrs copy-constructible and assignable is what gives them their power as bare pointer replacements in the case of returning a pointer from a function.
It removes the age old dilemma of who'll deallocate the pointer.
Now the allocating function can trust the auto_ptr to take care of cleaning up.
But I agree: "it's a very valueable piece of code if used as intended".
Adi
|
|
|
|
|
Thanks. Just wondering do you plan any more articles on this subject? I have been looking for an intro for BOOST for over a year because I can not understand the provided documentation.
John
|
|
|
|
|
I'm more than willing to add to this article or write additional material, I don't claim to be a Boost expert, but I've been working with it for a little while. I think that most of the documentation is OK, but sometimes it can be a bit hard to find what you're looking for - the standard of documentation varies significantly across components.
What type of things were you looking for in particular? Any particular components?
If you can keep you head when all about you
Are losing theirs and blaming it on you;
If you can dream - and not make dreams your master;
If you can think - and not make thoughts you aim;
Yours is the Earth and everything that's in it.
Rudyard Kipling
|
|
|
|
|
I was generally looking for more examples on how and where to use the library. I have looked into using boost code for a long time but when I read the examples I either don't understand what is happening or where someone would use it in a real world example. When I look at the pointers stuff. WOW there are so many types! I am not sure where to start. I use the smart pointer from the following article http://www.codeproject.com/cpp/smartptr.asp[^]
Does boost offer a better solution?
Also, is there any use for the threads library in a win32 application? To me it looks like you sacrifice performance and functionality for portability.
Thanks in advance,
John
|
|
|
|
|
John M. Drescher wrote:
I use the smart pointer from the following article http://www.codeproject.com/cpp/smartptr.asp
Stefan Chekanov's SmartPointer that you've been using is just different to the Boost Smart Pointers.
boost::shared_ptr and boost::shared_array offer reference counting, similar to Chekanov's 'RefCountPtr', the boost approach to thread safety varies away from the design in Chekanov's work.
The number of classes involved with the Boost smart pointers is probably less than you would expect, they are just spread around in lots of header files.
I haven't worked with Chekanov's classes so the following comments are from the short look that I've just had.
1/ It is likely that the class will not be able to uphold an exception safety guarantee. I'm not going to cite a specific example, nothing was glaring obvious, but proving exception guarantees is hard, very hard.
2/ The constructor which accepts a SmartPtrBase, which can be used to convert pointer types is likely to be risky if used inappropriately to convert the types of pointers (threaded -> non-threaded), which could allow incorrect access to a resource.
3/ The Boost Smart pointers reference counts will be safe in the presence of threads, however they do not aquire criticle sections (see the CSyncAccessRep class) so the contained object will not be safeguarded in multiple threads. This is perhaps the biggest difference, if you decide to change Smart Pointer implementations.
4/ Parameterization: Chekanov states that to avoid having to supply additional template parameters he provides the additional classes. All of the boost smart pointers have been designed to only take a single parameter (the type of the pointer).
But Greg Colvin and Jerry Schwarz argued that "parameterization will discourage users", and in the end we choose to supply only the direct implementation
See: http://www.boost.org/libs/smart_ptr/smart_ptr.htm[^] for more information.
If you are looking for a full blown parameterization capable smart pointer, Loki (from 'Modern C++ Design' fame) has now received a large ammount of testing, and may be appropriate.
My personal opinion on smart pointers is that they are a must-have tool, but I'm only going to use something I know isn't going to fail in unexpected ways. Also, if I decide to change platforms, my code should require as little work as possible to port. Smart pointer code is one of the areas where I know that tiny changes can have a massive effect in the presence of exceptions, and proving that a solution is exception safe is a time consuming job. I'm willing to cede to the known experts in the field, Colvin, Abrahams, Dawes and Dimov along with all the other users and library writers that the boost smart pointers will 'just work' - no matter what.
If you can keep you head when all about you
Are losing theirs and blaming it on you;
If you can dream - and not make dreams your master;
If you can think - and not make thoughts you aim;
Yours is the Earth and everything that's in it.
Rudyard Kipling
|
|
|
|
|
Thanks for taking the time to write a very detailed reply...
John
|
|
|
|
|
John M. Drescher wrote:
Also, is there any use for the threads library in a win32 application? To me it looks like you sacrifice performance and functionality for portability.
I'm not sure where functionality and performance losses could come from, but my knowledge of threading isn't the greatest. To me it looks like all the overhead is at construction / destruction of a thread object. I'm more than willing to trade that for being able to pass parameters into my function in a typesafe way (using function objects and binders), rather than attempting to cast void pointers.
I guess it's another example of 'adding an extra level of indirection' to solve a problem. If you can work easily with win32 threads then use that, it's the beauty of boost, you can pick and choose which bits you want,
If you can keep you head when all about you
Are losing theirs and blaming it on you;
If you can dream - and not make dreams your master;
If you can think - and not make thoughts you aim;
Yours is the Earth and everything that's in it.
Rudyard Kipling
|
|
|
|
|
How about Boost.function? Recently a article http://www.codeproject.com/cpp/CallbackDemo.asp[^] there was a suggestion to use Boost.function instead. I looked at the documentation and examples and have absolutly no idea about the usefulness of Boost.function and how I could use it to replace a callback mechanism.
John
|
|
|
|
|
John M. Drescher wrote:
Recently a article http://www.codeproject.com/cpp/CallbackDemo.asp
Just a couple of comments on that particular article:
- The way the sample app is written makes it relatively hard to see what callbacks are doing
- Big chunks of the code aren't type safe (void pointers) - big mental alarm bells start ringing in my head, getting all the louder when I see C-style casts.
- Some of the functions should really be using standard library elements, without even considering boost.
In the cases where you're writing the code, it's generally easiest to specify that anything with function call semantics is acceptable. The simplest way to do that is to templatize all of the functions. STL does this, that's why all the STL algorithms are templatized. Function objects in the standard are meant to be light-weight, so the types shouldn't really be significant. The consequence of that is that it's hard to exchange global functions for member function pointers.
The following code, which is a rewrite of the mentioned article's sample code uses boost::bind. If the callback does not support a conversion to a string type, the build will fail.
The basic idea to remember is that a callback (for a member function) needs to have two things: first an object pointer (or reference) and second the member function pointer. Binding like this allows you to attach the object to the member function pointer, in this case most if not all of this should be possible without using boost, by just using standard library elements (the second part of my response isn't). What makes boost bind/function/mem_fn outstanding in this area is that you can have any number of arguments.
#include <iostream>
#include <sstream>
#include <boost/bind.hpp>
using namespace std;
template<class T>
void globalCallback(T callback)
{
ostringstream oss;
oss << "From a global callback" << endl;
callback(oss.str());
}
class Add
{
public:
template<class T>
bool addNumbers(int num1, int num2, T callback)
{
ostringstream oss;
oss << "Adding " << num1 << " + " << num2 << " = " << (num1+num2) << endl;
callback(oss.str());
return true;
}
};
class Multiply
{
public:
template<class T>
bool multiplyNumbers(int num1, int num2, T callback)
{
ostringstream oss;
oss << "Adding " << num1 << " * " << num2 << " = " << (num1*num2) << endl;
callback(oss.str());
return true;
}
};
class Test
{
public:
void testStart()
{
cout << "Start" << endl;
Add add; Multiply multi;
cout << "\n> Setting CallbackOutputStars !\n";
add.addNumbers (120, 30, boost::bind(&Test::callbackOutputStars,this,_1));
multi.multiplyNumbers(3, 22, boost::bind(&Test::callbackOutputStars,this,_1));
cout << "\n> Setting CallbackOutputDollar !\n";
add.addNumbers (33, 66, boost::bind(&Test::callbackOutputStars,this,_1));
multi.multiplyNumbers(5, 10, boost::bind(&Test::callbackOutputStars,this,_1));
cout << ("\n> Finally the callback from a global function :\n");
globalCallback(boost::bind(&Test::callbackOutputStars,this,_1));
cout << "Done" << endl;
}
private:
void callbackOutputStars(const std::string& str)
{
ostringstream oss;
oss << " ***** Some stars ***** " << str << endl;
cout << oss.str();
}
void callbackOutputDollar(const std::string& str)
{
ostringstream oss;
oss << " $$$ Now with Dollar $$$ " << str << endl;
cout << oss.str();
}
};
int main()
{
Test t;
t.testStart();
return 0;
}
However, if you need a callback facility are you going to know the types involved? Most of the time the answer to that question is yes. [Slightly OT: As a student, that one concept took me months to get my head around, especially with so many templates whizzing around].
boost::function does this by letting you restrict the incoming types a bit better. Think of it as a flag to other programmers about what you are doing.
#include <boost/function.hpp> void globalCallback(boost::function1<void,std::string> callback)
{
ostringstream oss;
oss << "From a global callback" << endl;
callback(oss.str());
}
class Add
{
public:
bool addNumbers(int num1, int num2, boost::function1<void,std::string> callback)
{
ostringstream oss;
oss << "Adding " << num1 << " + " << num2 << " = " << (num1+num2) << endl;
callback(oss.str());
return true;
}
};
class Multiply
{
public:
bool multiplyNumbers(int num1, int num2, boost::function1<void,std::string> callback)
{
ostringstream oss;
oss << "Adding " << num1 << " * " << num2 << " = " << (num1*num2) << endl;
callback(oss.str());
return true;
}
};
I built both samples under MSVC6, and noticed a degradation in compile time performance using boost::function.
If you can keep you head when all about you
Are losing theirs and blaming it on you;
If you can dream - and not make dreams your master;
If you can think - and not make thoughts you aim;
Yours is the Earth and everything that's in it.
Rudyard Kipling
|
|
|
|
|
Thank You very much for your time to write such a long and informative answer...
John
|
|
|
|
|
|
MattyT wrote:
It's always surprising to me that many of my colleagues don't know or use Boost as it's a terrific resource
I know of it but haven't used it yet. I think more people will use it over time as it becomes better known and documented. It was the same with STL. I knew of it a long time before I started using it - mainly because it took me a while before I understood how to use it.
Also, we must reckon with the following stages when encountering new technolgy (or, at least, they're common stages for me!)
1. Bafflement.
2. Understanding but then asking: but what's the point?
3. Encountering a problem(s) for which the new technology provides a tailor-made solution.
Kevin
|
|
|
|
|
Boost is becoming increasingly important, especially considering the upcoming Standards review:
On comp.std.c++ Beman Dawes wrote:
Of the 12 proposals accepted so far, 10 grew out of the Boost libraries.
With momentum like that behind the Boost, it seems to me like it can't be ignored - developers need to be aware that many of these components are, in addition to being 'top notch', likely to be adopted into the c++ Standard.
http://std.dkuug.dk/jtc1/sc22/wg21/docs/library_technical_report.html[^]
If you can keep you head when all about you
Are losing theirs and blaming it on you;
If you can dream - and not make dreams your master;
If you can think - and not make thoughts you aim;
Yours is the Earth and everything that's in it.
Rudyard Kipling
|
|
|
|
|
The key thing for me is usually point 3 in my post. I need to encounter a problem for which I can use the new technique (once I've understood how to use it). I don't usually use new stuff just for the sake of it. Especially, as others may have to maintain my code.
I think there just always will be some lag between what the average developer uses it and what's new. Even now many developers shy away from STL and stick to unnecessarily low-level, error-prone code. I know this from having done lots of maintenance programming recently, and not on really old code.
However, my main problem at the moment is finding any kind of work at all in the current market, having been out of work for most of the past couple of years. So Boost doesn't get me too excited just at the moment. Not to mention that, in the UK, C++ is bottom of the skills table and bottom of the rates table too! Not much of an incentive to invest time in learning quite demanding stuff.
Kevin
|
|
|
|
|
|
MattyT wrote:
I found that being aware of new features and techniques really changed the way that you approach and solve problems. Suddenly you find your tools (the language) more flexible and solutions become more natural.
I certainly like to be aware of the latest ideas on a subject, even if I don't use them straight away (otherwise I wouldn't have read this article!). But new ideas aren't always easy to grasp. For example, STL seemed mysterious and complicated to me for some time.
There's also the fact that if you use something obscure you will baffle the majority of other developers who may have to maintain your code. Of course, at some point we've all got to move on. It's a question of striking a balance. I started using STL heavily after it had been around for some time and there were books on the subject. At that point I expected conscientious C++ developers to be using it, even if they weren't. And a lot of C++ developers still aren't!
MattyT wrote:
But adding Boost knowledge to your repertoire can't hurt can it?
The problem is that, looking at adverts for C++ jobs, things such as Boost are not requested. All of the complementary technolgies seem to have higher importance - ATL, COM, SQL Server, .NET.
MattyT wrote:
would certainly make me more likely to hire someone for a C++ role...
There are all sorts of things I could add to my repertoire but it's a question of priorities. I think it's better to focus on things that are in demand in the marketplace which, from the way things are going in the UK, might soon be something other than programming!
Kevin
|
|
|
|
|
|
|
 General  News  Suggestion  Question  Bug  Answer  Joke  Rant  Admin
|
An overview of the Boost library
| Type | Article |
| Licence | |
| First Posted | 6 Jul 2003 |
| Views | 179,657 |
| Bookmarked | 94 times |
|
|
Submit an article or tip
Post your Blog
But adding Boost knowledge to your repertoire can't hurt can it? 
