Re: disadvantages of using STL
this is my understanding of what "intrusive" means:
Example: Intrusive smart pointers: You are required to add the
counter to your object you want to manage.
Example: Intrusive Containers: You are required to derive from a base
class for your elements you want to manage.
In both cases you are forced to add some specific code to the class of
your objects. The pointer/container design is "intruding" your class.
On 21 Mrz., 11:24, "Tony" wrote:
Another style of container implementation is via void*. No derivation
from a common base class needed. So you have at your disposal at least
3 implementation techniques: NIH style (derive from Object), STL
templates with value semantics, void* ptr based. I never liked the NIH
style. My own library used to be value based but is now void* based.
IMHO, that was a bad decision. The generic/value semantics approach
the most universal one because you can choose to manage (smart)
OR your objects directly. Also you lost type safety by using void*.
I thought that STL-style was the intrusive style because they make
copies of the objects that get put into them and then they own them
There's nothing wrong nor intrusive (by the definition I use) with it.
If you don't want copies (because copying is expensive or not
appropriate) and/or runtime polymorphism you could use (smart)
Also intrusive because the actual objects get embedded into
things like links directly via the value semantic based template
generation process. That sounds quite intrusive (if not assuming).
Oh, I see what you mean. But there's nothing bad about it. It's
actually very good. The thing is: the container is supposed to manage
the objects of a specific type. Why not storing these objects
as a member of some other "node" object that also contains some links.
(I guess you were thinking about std::list). It doesn't quality as
On 21 Mrz., 11:59, "Tony" wrote:
"Noah Roberts" wrote in message
Pallav singh wrote:
Q What are the disadvantages of using STL ?
He said DISadvantages.
On 21 Mrz., 12:14, "Tony" wrote:
"Noah Roberts" wrote:
The STL component of the standard library is actually the best
thing about it. That whole style of programming is quite effective
and represents some of the best in system design. The STL is well
worth studying as an example of great style and design.
Was STL the first to introduce the concept of algorithms working on
containers via iterators?
I don't know. But that's not the point. The point is that the STL
so *without* runtime polymorphism which is a big advantage w.r.t. code