Re: How to learn the C++ way?
moleskyca1@yahoo.com wrote in news:1154120006.944830.195500
@m73g2000cwd.googlegroups.com:
Thank you for sharing, I have learned from this post.
W. J. La Cholter wrote:
For example, if you were to avoid generic practices for containers,
then you'd be stuck with something like pre-Java generics for storing
a collection of objects. Perhaps, everything would have to inherit
from a common base class to be stored. If you try to use certain
generic algorithms without functional Boost Lambda (or C++ TR1's
implementation), you'd have to write ad-hoc functions to apply
transforms across objects that don't quite fit the interface. If you
implement your domain objects using a functional technique, you really
wouldn't have a three-tiered architecture anymore.
This part is very interesting to me. I still have argument with java
people about why is STL better than the pre-Java generics collection in
Java. As you say, everything must inherit from a base in order to be in
the collection. I know this is bad. Can you break it down for
beginner/intermediate like me and others I argue with? Here is some
pseudo-code (and C++ used to be like this pre-STL remember RougeWave
RWCollection?). Why is line 25 so bad? Why forcing inheritance from
Collectable is so bad?
1 // all must inherit from here to be in a Collection
2 class Collectable
3 {
4 virtual int comp(const Collectable *, const Collectable *) = 0;
5 };
6 class Collection
7 {
8 public:
9 void add(Collectable *);
10 size_t size();
11 Collectable *getAt(size_t);
12 };
13 class Canvas; // forward declaration
14 class Shape: public Collectable
15 {
16 public:
17 virtual void draw(Canvas &) = 0;
18
19 };
20 class Canvas
21 {
22 public:
23 void render(Collection &sc) {
24 for ( size_t i = 0; i < sc.size(); i++ )
25 ((Shape *)sc.getAt(i))->draw(*this);
The immediate answer is that the operation can fail for many different
reasons. There's nothing stopping the collection from holding
different types. In C++, without native garbage collection, you're
force to manage the item's destruction. You've also cluttered your
class hierarchy. If you wish to have a Shape play with other other
things, you need to add interfaces. Sun can get around this by
modifying java.lang.Object when they have the need to support new
features.
The theoretical answer is that Collection doesn't represent what you
want it to. It represents a collection of anything. Presumably, you
just want a collection of shapes. That could be represented as
std::vector<boost::shared_ptr<Shape> >. The shared_ptr is a safe way
to manage the object lifetime. If you want a collection of anything,
you could use std::vector<boost::any>.
26 }
27 };
28 class Rectangle: public Shape
29 {
30 public:
31 void draw(Canvas &) {;} // override to draw rectangle
32 };
33 class Triangle: public Shape
34 {
35 public:
36 void draw(Canvas &) {;} // override to draw Triangle
37 };
38
C++ because it's multi-paradigm, is well suited for "say what you
mean" and "mean what you say." You can represent or model your
relationships, and clearly transform them into code. Being
"collectable" is orthogonal, or separate from a shape's having other
properties. Moreover, later on, if you wish to add more properties,
such as Renderable or Printable, you'd need have to hope the existing
interface suits your needs or you'd have to add an interface.
An interesting solution adopted in Java is the use of reflection to
implement orthogonal things like serialization or object-relational
mapping. In the old way, to make something persistent, you'd have it
derive from something like "Persistible." A better solution is
something like Hibernate, in which the bindings are defined
declaratively at run-time. That's preferable to mucking up a class
hierarchy, but injects dynamism that may not be necessary.
Another limitation to the above approach is that you cannot implement
something like the Non-Virtual Interface idiom (see other posts in the
group or C++ Coding Standards by Sutter and Alexandrescu): the
interface is public and the implementation uses private virtual
functions.
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]