 |
|
|
Very basic info is provided a comparison with some other library would really add some value.
|
| Sign In·View Thread·PermaLink | 2.00/5 (1 vote) |
|
|
|
|
|
|
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
|
| Sign In·View Thread·PermaLink | |
|
|
|
|
|
|
|
|
|
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;
|
| Sign In·View Thread·PermaLink | 3.00/5 (2 votes) |
|
|
|
|
|
|
|
|
|
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
|
| Sign In·View Thread·PermaLink | |
|
|
|
|
|
|
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
|
| Sign In·View Thread·PermaLink | |
|
|
|
|
|
|
Peeters' tree looks really cool, but he is using the GNU General Public License, so you can't use it in proprietary software.
|
| Sign In·View Thread·PermaLink | |
|
|
|
|
|
|
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
|
| Sign In·View Thread·PermaLink | 5.00/5 (1 vote) |
|
|
|
|
|
|
|
|
|
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.
|
| Sign In·View Thread·PermaLink | |
|
|
|
|
|
|
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
|
| Sign In·View Thread·PermaLink | |
|
|
|
|
|
|
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.
|
| Sign In·View Thread·PermaLink | 1.00/5 (1 vote) |
|
|
|
|
|
|
Nice, a good boost intro. was really missing in CP.
Maybe this article belongs to tutorials ?
Jonathan de Halleux.
|
| Sign In·View Thread·PermaLink | |
|
|
|
|
|
|
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
|
| Sign In·View Thread·PermaLink | 5.00/5 (1 vote) |
|
|
|
|
|
|
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
|
| Sign In·View Thread·PermaLink | |
|
|
|
|
|
|
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
|
| Sign In·View Thread·PermaLink | |
|
|
|
|
|
|
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
|
| Sign In·View Thread·PermaLink | |
|
|
|
|
|
|
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
|
| Sign In·View Thread·PermaLink | 5.00/5 (1 vote) |
|
|
|
|
|
|
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
|
| Sign In·View Thread·PermaLink | 5.00/5 (1 vote) |
|
|
|
|
|
|
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
|
| Sign In·View Thread·PermaLink | |
|
|
|
|
|
|
|
|
|
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
|
| Sign In·View Thread·PermaLink | |
|
|
|
|
|
|
|
|
|
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
|
| Sign In·View Thread·PermaLink | |
|
|
|
|
General 
News 
Question 
Answer 
Joke 
Rant 
Admin 
