Re: Interesting but sensitive topic to discuss (HELP: - OOP and CASE tools)

[drs <drs@inxpress.net>]

Piercarlo Grandi wrote:

[C++ prototypes omitted]

>So far this is not an OO program, according to your definition, for
>there are no objects whatsoever in it, only classes, and there are no
>``interactions'' among classes in it either.

This is correct. "classes" are merely prototypes in C++. "Objects" are properly 
instantiations, as far as C++ or smalltalk is concerned.

alovejoy> The architecture and design of a program is a function of what
alovejoy> **objects** it contains and how they interact.

>Now let's try to add some more detail:

  // the above plus ...

  main()
  {
    complex c1, c2;
	//etc.
  }

>Is this an OO program? It's hard for me to see any objects in it either
>for I can only see variables (memory objects, a different concept) and
>they don't interact with each other in any sort of interesting meaning
>of the word.

Well, c1 and c2 are indeed instantiations of the above prototype; they have a 
defined address and can do things (unlike the prototype). You're wrong if you 
think c1 and c2 are not objects; they are. entities of the class complex create 
their own scope, which is internal and allows internal processes. This really is 
quite different from C. Now, if your idea is that "Object-oriented"  boils down to 
message sending, then I think you're correct; but by that definition there are 
only a few true "object-oriented" languages, and C++ is not one of them. 

>Objects do come into existence (thanks to the execution of constructors)
>only during the _execution_ of the program, and they are passed as
>arguments to various procedures at execution time too; they don't seem
>to be contained in the *program*, and even when they are contained in a
>computation created by executing the program they don't seem to
>interact, any more than the arguments to a procedure may be said to
>``interact''.

This is wrong. c1 and c2 are scoped within the whole of main(). This is 
not really different from any globally scoped object in, say, smalltalk.
You could easily cause c1 and c2 to interact, although your example 
does not call for much interaction. Performing an addition of two 
complex numbers is not really much of an "interaction" anyway because
the numbers themselves are probably const. The overloaded + probably
instantiates a new number, and changes nothing in the args. But let's 
suppose class bicycle

class bicycle
{
	Wheel w1, w2;
	Brake b1, b2;
	Frame f1;
	Seat s1;
	Freewheel fw1;
	//etc.
	public:
	
	void ride();
	void slowdown();
	void changegears();
	//more methods for interaction between parts
};

The parts model the whole. If you now instantiate an instance of 
class bicycle, in order of it to do anything, the parts *must* interact.
So the issue of what really is "Object-oriented" turns much more 
on a world-view (a way of concieving a problem, perhaps) than on
any particular feature such as "runtime polymorphism." Setting up a 
bicycle object is *qualitatively* different than doing computations about
riding using C functions. 


Regards,

DRS