 |
C++Talk.NET
C++ language newsgroups
|
| View previous topic :: View next topic |
| Author |
Message |
Richard Smith
Guest
|
 Posted: Thu Jul 17, 2003 3:17 pm Post subject: Re: Article: allocators...exceptions...new/delete [reply to: |
 |
|
"Dhruv Matani" <dhruvbird (AT) gmx (DOT) net> wrote
| Quote: | What I had in mind was something like this:
#include <memory
#include
|
I assume this is the one from
http://www.geocities.com/dhruvbird/nstl0.2.zip. For the benefit of anyone
else reading this thread, list_node_allocator is a stateless allocator
declared as follows.
namespace nstd {
template
class list_node_allocator;
}
| Quote: | #include <boost/pool/pool.hpp
|
Let me quote the declaration of fast_pool_allocator:
namespace boost {
template
class UserAllocator = /* default value */,
class Mutex = /* default value */,
unsigned NextSize = 32>
class fast_pool_allocator;
}
Note in particular the extra template parameters.
| Quote: | template <template
struct foo {
//type t;
some_alloc<int> ia;
};
|
The template argument to foo must be a class template with one template
parameter.
| Quote: | int main ()
{
foo <nstd::list_node_allocator> f;
|
This is fine: list_node_allocator is a class template with one template
parameter.
| Quote: | foo <boost::fast_pool_allocator> f1;
|
This is not legal: fast_pool_allocator is a class template with four
template parameters. The fact that the last three have default values is
irrelevant. There is a core language defect report (DR150) about this. See
http://anubis.dkuug.dk/jtc1/sc22/wg21/docs/cwg_closed.html#150
for more details. Some compilers do accept this code, but you must bear in
mind that it is not strictly legal. Unless this is resolved (and I hope it
will be in C++0x), this is one reason why allocators don't work too well as
template template parameters.
| Quote: | That would eliminate the need to pass the type explicitly, and also, the
rebind hack would disappear in case of a list, or the map, etc......
|
I agree, this would have been nice, but I think it's too late now.
| Quote: | Now, it would be great if this would work:
#include <memory
#include
#include
template //NOTE.
struct foo {
//type t;
some_alloc<type> ia;
//now, if you want a node allocator, just do:
//some_alloc<node_struct> na;
};
|
The way to do this with the current allocator framework would to introduce a
typedef for the node allocator:
template <class Alloc> struct foo {
typedef typename Alloc::template rebind<node_struct>::other
node_allocator;
It's a bit of a mouthful, and explaining to novices precisely what that
"template" keyword is doing in the middle can be a bit difficult.
| Quote: | int main ()
{
foo <nstd::list_node_allocator f; //NOTE.
foo <boost::fast_pool_allocator f1; //NOTE.
}
I'm not too sure about whether the code is even correct. Please tell me
if
it's correct, because I don't trust g++ much on template issues.
|
No. Your code is illegal for two reasons. First the declaration of foo is
syntactically incorrect. You have:
template <template //NOTE.
struct foo {
1. If you want foo to have one template parameter that is a class, you must
write
template <class Alloc> struct foo;
foo< nstd::list_node_allocator f;
2. If you want it to have one template parameter that is a template class,
you must write something like the following, but making sure you give the
template template parameter the correct number and types of arguments
template <template struct foo;
foo< nstd::list_node_allocator > f;
3. If you want both a type (int) and a template (e.g.
nstd::list_node_allocator), you must give the template two parameters:
template <class Type, template struct foo;
foo< int, nstd::list_node_allocator > f;
Only the first of these solves the problem of allocators with additional
template parameters, and brings us back to rebind. You cannot do anything
like akin to template parameter deduction on function calls, which seems to
be what you're trying to do.
| Quote: | Something that I'm quite sure about is that the boost allocator example
(f1 object thing) does not compile because of the the n number of
parameters that it has.
|
Correct. See above.
| Quote: | One more thing: Is it legal to access 'type' within the struct, as in,
can you do something like this inside the struct:
some_alloc<type> alloc;
It doesn't seem to work on g++.
|
As indeed it shouldn't. You're code is syntactically incorrect, and
shouldn't compile even with nstd::list_node_allocator. Instead, you should
either use Alloc::value_type (if you're using solution 1), or just use Type
(if you're using solution 3). If you use solution 2, you cannot get at the
type at all.
--
Richard Smith
---
[ comp.std.c++ is moderated. To submit articles, try just posting with ]
[ your news-reader. If that fails, use mailto:std-c++@ncar.ucar.edu ]
[ --- Please see the FAQ before posting. --- ]
[ FAQ: http://www.jamesd.demon.co.uk/csc/faq.html ]
|
|
| Back to top |
|
 |
|
|
You cannot post new topics in this forum
You cannot reply to topics in this forum
You cannot edit your posts in this forum
You cannot delete your posts in this forum
You cannot vote in polls in this forum
|
|
FAQ
Search
Memberlist
Usergroups
Register
Profile
Log in to check your private messages
Log in
